431a9c00a5
On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably. 99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified. Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects. Most remaining warnings are now unused parameters.
146 lines
3.9 KiB
C++
146 lines
3.9 KiB
C++
#ifndef STAR_NET_ELEMENT_SIGNAL_HPP
|
|
#define STAR_NET_ELEMENT_SIGNAL_HPP
|
|
|
|
#include "StarNetElement.hpp"
|
|
|
|
namespace Star {
|
|
|
|
// NetElement that sends signals during delta writes that can be received by
|
|
// slaves. It has no 'state', and nothing is sent during a store / load, and
|
|
// it only keeps past signals for a maximum number of versions. Thus, it is
|
|
// not appropriate to use to send updates to long term states, only for event
|
|
// like things that are not harmful if missed.
|
|
template <typename Signal>
|
|
class NetElementSignal : public NetElement {
|
|
public:
|
|
NetElementSignal(size_t maxSignalQueue = 32);
|
|
|
|
void initNetVersion(NetElementVersion const* version = nullptr) override;
|
|
|
|
void netStore(DataStream& ds) const override;
|
|
void netLoad(DataStream& ds) override;
|
|
|
|
void enableNetInterpolation(float extrapolationHint = 0.0f) override;
|
|
void disableNetInterpolation() override;
|
|
void tickNetInterpolation(float dt) override;
|
|
|
|
bool writeNetDelta(DataStream& ds, uint64_t fromVersion) const override;
|
|
void readNetDelta(DataStream& ds, float interpolationTime = 0.0) override;
|
|
|
|
void send(Signal signal);
|
|
List<Signal> receive();
|
|
|
|
private:
|
|
struct SignalEntry {
|
|
uint64_t version;
|
|
Signal signal;
|
|
bool received;
|
|
};
|
|
|
|
size_t m_maxSignalQueue;
|
|
NetElementVersion const* m_netVersion = nullptr;
|
|
bool m_netInterpolationEnabled = false;
|
|
Deque<SignalEntry> m_signals;
|
|
Deque<pair<float, Signal>> m_pendingSignals;
|
|
};
|
|
|
|
template <typename Signal>
|
|
NetElementSignal<Signal>::NetElementSignal(size_t maxSignalQueue) {
|
|
m_maxSignalQueue = maxSignalQueue;
|
|
}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::initNetVersion(NetElementVersion const* version) {
|
|
m_netVersion = version;
|
|
m_signals.clear();
|
|
}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::netStore(DataStream&) const {}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::netLoad(DataStream&) {
|
|
}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::enableNetInterpolation(float) {
|
|
m_netInterpolationEnabled = true;
|
|
}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::disableNetInterpolation() {
|
|
m_netInterpolationEnabled = false;
|
|
for (auto& p : take(m_pendingSignals))
|
|
send(std::move(p.second));
|
|
}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::tickNetInterpolation(float dt) {
|
|
for (auto& p : m_pendingSignals)
|
|
p.first -= dt;
|
|
|
|
while (!m_pendingSignals.empty() && m_pendingSignals.first().first <= 0.0f)
|
|
send(m_pendingSignals.takeFirst().second);
|
|
}
|
|
|
|
template <typename Signal>
|
|
bool NetElementSignal<Signal>::writeNetDelta(DataStream& ds, uint64_t fromVersion) const {
|
|
size_t numToWrite = 0;
|
|
for (auto const& p : m_signals) {
|
|
if (p.version >= fromVersion)
|
|
++numToWrite;
|
|
}
|
|
if (numToWrite == 0)
|
|
return false;
|
|
|
|
ds.writeVlqU(numToWrite);
|
|
|
|
for (auto const& p : m_signals) {
|
|
if (p.version >= fromVersion)
|
|
ds.write(p.signal);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::readNetDelta(DataStream& ds, float interpolationTime) {
|
|
size_t numToRead = ds.readVlqU();
|
|
for (size_t i = 0; i < numToRead; ++i) {
|
|
Signal s;
|
|
ds.read(s);
|
|
if (m_netInterpolationEnabled && interpolationTime > 0.0f) {
|
|
if (!m_pendingSignals.empty() && m_pendingSignals.last().first > interpolationTime) {
|
|
for (auto& p : take(m_pendingSignals))
|
|
send(std::move(p.second));
|
|
}
|
|
m_pendingSignals.append({interpolationTime, std::move(s)});
|
|
} else {
|
|
send(std::move(s));
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename Signal>
|
|
void NetElementSignal<Signal>::send(Signal signal) {
|
|
m_signals.append({m_netVersion ? m_netVersion->current() : 0, signal, false});
|
|
while (m_signals.size() > m_maxSignalQueue)
|
|
m_signals.removeFirst();
|
|
}
|
|
|
|
template <typename Signal>
|
|
List<Signal> NetElementSignal<Signal>::receive() {
|
|
List<Signal> received;
|
|
for (auto& p : m_signals) {
|
|
if (!p.received) {
|
|
received.append(p.signal);
|
|
p.received = true;
|
|
}
|
|
}
|
|
return received;
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|