forked from aya/aya
340 lines
11 KiB
C++
340 lines
11 KiB
C++
|
|
|
|
#include "RoundRobinPhysicsSender.hpp"
|
|
#include "Replicator.hpp"
|
|
#include "Compressor.hpp"
|
|
|
|
#include "Player.hpp"
|
|
|
|
|
|
#include "RakNet/GetTime.hpp"
|
|
#include "RakNet/RakPeerInterface.hpp"
|
|
#include "NetworkSettings.hpp"
|
|
#include "ConcurrentRakPeer.hpp"
|
|
#include "Client.hpp"
|
|
|
|
#include "World/SendPhysics.hpp"
|
|
#include "World/World.hpp"
|
|
#include "World/Primitive.hpp"
|
|
#include "World/Assembly.hpp"
|
|
|
|
#include "DataModel/PartInstance.hpp"
|
|
|
|
#include "DataModel/ModelInstance.hpp"
|
|
|
|
#include "DataModel/Workspace.hpp"
|
|
|
|
#include "DataModel/PhysicsService.hpp"
|
|
|
|
|
|
#include "RakNet/RakNetStatistics.hpp"
|
|
|
|
|
|
using namespace Aya;
|
|
using namespace Aya::Network;
|
|
|
|
SYNCHRONIZED_FASTFLAG(PhysicsPacketSendWorldStepTimestamp)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
RoundRobinPhysicsSender::RoundRobinPhysicsSender(Replicator& replicator)
|
|
: PhysicsSender(replicator)
|
|
, lastCharacterSendTime(Time::now<Time::Fast>())
|
|
{
|
|
}
|
|
|
|
|
|
void RoundRobinPhysicsSender::sendPhysicsData(RakNet::BitStream& bitStream, const Assembly* assembly)
|
|
{
|
|
AYAASSERT(assembly);
|
|
|
|
if (assembly)
|
|
{
|
|
senderStats = NULL;
|
|
if (replicator.settings().trackPhysicsDetails)
|
|
{
|
|
senderStats = &(replicator.replicatorStats.physicsSenderStats);
|
|
}
|
|
|
|
const PartInstance* part = PartInstance::fromConstPrimitive(assembly->getConstAssemblyPrimitive());
|
|
|
|
if (canSend(part, assembly, bitStream))
|
|
{
|
|
Player* player = replicator.findTargetPlayer();
|
|
ModelInstance* m = player ? player->getCharacter() : 0;
|
|
bool detailed = m && m->isAncestorOf(part);
|
|
|
|
if (replicator.isStreamingEnabled())
|
|
{
|
|
bitStream << false; // token: not done with packet
|
|
bitStream << false; // not CFrame only
|
|
|
|
if (replicator.trySerializeId(bitStream, part))
|
|
{
|
|
RakNet::BitSize_t characterBytes = bitStream.GetNumberOfBytesUsed();
|
|
CoordinateFrame cFrame = part->getCoordinateFrame();
|
|
float accumulatedError;
|
|
sendMechanism(bitStream, part, detailed, currentStepTimestamp, cFrame, accumulatedError, NULL);
|
|
if (senderStats && detailed)
|
|
{
|
|
senderStats->details.characterAnim.increment();
|
|
senderStats->details.characterAnimSize.sample(bitStream.GetNumberOfBytesUsed() - characterBytes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
replicator.serializeId(bitStream, NULL); // token: done with this mechanism
|
|
}
|
|
}
|
|
else if (replicator.trySerializeId(bitStream, part))
|
|
{
|
|
RakNet::BitSize_t characterBytes = bitStream.GetNumberOfBytesUsed();
|
|
CoordinateFrame cFrame = part->getCoordinateFrame();
|
|
float accumulatedError;
|
|
sendMechanism(bitStream, part, detailed, currentStepTimestamp, cFrame, accumulatedError, NULL);
|
|
if (senderStats && detailed)
|
|
{
|
|
senderStats->details.characterAnim.increment();
|
|
senderStats->details.characterAnimSize.sample(bitStream.GetNumberOfBytesUsed() - characterBytes);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
const SimJob* RoundRobinPhysicsSender::findTargetPlayerCharacterSimJob()
|
|
{
|
|
if (const Player* player = replicator.findTargetPlayer())
|
|
{
|
|
if (const Primitive* primitive = player->getConstCharacterRoot())
|
|
{
|
|
return SimJob::getConstSimJobFromPrimitive(primitive);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
class RoundRobinPhysicsSender::JobSender : public boost::noncopyable
|
|
{
|
|
// Hacky way to keep track of the first object sent, since it may be sent again after reportClosestMechanism
|
|
const Assembly* firstA;
|
|
const SimJob* firstM;
|
|
|
|
RoundRobinPhysicsSender& sender;
|
|
ConcurrentRakPeer* rakPeer;
|
|
const int maxStreamSize;
|
|
|
|
shared_ptr<RakNet::BitStream> bitStream;
|
|
PacketPriority packetPriority;
|
|
|
|
unsigned int emptySize;
|
|
|
|
|
|
void openPacket()
|
|
{
|
|
bitStream.reset(new RakNet::BitStream(maxStreamSize));
|
|
*bitStream << (unsigned char)ID_TIMESTAMP;
|
|
RakNet::Time now = RakNet::GetTime();
|
|
#if !defined(__linux) && !defined(__APPLE__)
|
|
*bitStream << now;
|
|
#else
|
|
*bitStream << static_cast<unsigned long long>(now);
|
|
#endif
|
|
*bitStream << (unsigned char)ID_PHYSICS;
|
|
emptySize = bitStream->GetNumberOfBitsUsed();
|
|
++packetCount;
|
|
itemCount = 0;
|
|
}
|
|
|
|
void openPacketPhysicsOffset(RakNet::Time& newTimeStamp)
|
|
{
|
|
bitStream.reset(new RakNet::BitStream(maxStreamSize));
|
|
*bitStream << (unsigned char)ID_TIMESTAMP;
|
|
RakNet::Time now = RakNet::GetTime();
|
|
#if !defined(__linux) && !defined(__APPLE__)
|
|
*bitStream << now;
|
|
#else
|
|
*bitStream << static_cast<unsigned long long>(now);
|
|
#endif
|
|
*bitStream << (unsigned char)ID_PHYSICS;
|
|
#if !defined(__linux) && !defined(__APPLE__)
|
|
*bitStream << newTimeStamp;
|
|
#else
|
|
*bitStream << static_cast<unsigned long long>(newTimeStamp);
|
|
#endif
|
|
emptySize = bitStream->GetNumberOfBitsUsed();
|
|
++packetCount;
|
|
itemCount = 0;
|
|
}
|
|
|
|
void closePacket()
|
|
{
|
|
if (bitStream->GetNumberOfBitsUsed() > emptySize)
|
|
{
|
|
// Packet "end" tag
|
|
if (sender.replicator.isStreamingEnabled())
|
|
*bitStream << true;
|
|
else
|
|
sender.replicator.serializeId(*bitStream, NULL);
|
|
|
|
// Send ID_PHYSICS
|
|
ReplicatorStats::PhysicsSenderStats& physStats = sender.replicator.physicsSenderStats();
|
|
rakPeer->Send(bitStream, packetPriority, UNRELIABLE, PHYSICS_CHANNEL, sender.replicator.remotePlayerId, false);
|
|
physStats.physicsPacketsSent.sample();
|
|
physStats.physicsPacketsSentSmooth.sample();
|
|
physStats.physicsPacketsSentSize.sample(bitStream->GetNumberOfBytesUsed());
|
|
|
|
sender.itemsPerPacket.sample(itemCount);
|
|
}
|
|
bitStream.reset();
|
|
}
|
|
|
|
public:
|
|
int packetCount;
|
|
unsigned int itemCount;
|
|
|
|
JobSender(RoundRobinPhysicsSender& sender, ConcurrentRakPeer* peer)
|
|
: sender(sender)
|
|
, rakPeer(peer)
|
|
, firstA(NULL)
|
|
, firstM(NULL)
|
|
, packetPriority(sender.replicator.settings().getPhysicsSendPriority())
|
|
, packetCount(0)
|
|
, itemCount(0)
|
|
, maxStreamSize(sender.replicator.getPhysicsMtuSize())
|
|
{
|
|
}
|
|
void close()
|
|
{
|
|
if (bitStream)
|
|
closePacket();
|
|
}
|
|
~JobSender()
|
|
{
|
|
close();
|
|
}
|
|
|
|
// Returns true if it wants another sample
|
|
bool report(const SimJob& simJob)
|
|
{
|
|
if (SFFlag::getPhysicsPacketSendWorldStepTimestamp())
|
|
{
|
|
float timeOffsetDueToPhysics = 0.0f;
|
|
Workspace* w = ServiceProvider::find<Aya::Workspace>(&sender.replicator);
|
|
if (w)
|
|
{
|
|
timeOffsetDueToPhysics = w->getWorld()->getUpdateExpectedStepDelta();
|
|
}
|
|
|
|
// Generates timestamp for this frame, minus a small offset based on
|
|
// missed or extra world steps taken.
|
|
RakNet::Time passStamp = (RakNet::Time)((TaskScheduler::singleton().lastCyclcTimestamp +
|
|
Time::Interval(sender.replicator.getRakOffsetTime() - timeOffsetDueToPhysics))
|
|
.timestampSeconds() *
|
|
1000.0);
|
|
|
|
if (!bitStream)
|
|
openPacketPhysicsOffset(passStamp);
|
|
}
|
|
else
|
|
{
|
|
if (!bitStream)
|
|
openPacket();
|
|
}
|
|
|
|
sender.sendPhysicsData(*bitStream, simJob.getConstAssembly());
|
|
|
|
const int newSize = bitStream->GetNumberOfBytesUsed();
|
|
|
|
itemCount++;
|
|
|
|
return newSize < maxStreamSize;
|
|
}
|
|
|
|
bool operator()(SimJob& m)
|
|
{
|
|
return report(m);
|
|
}
|
|
};
|
|
|
|
|
|
void RoundRobinPhysicsSender::step()
|
|
{
|
|
if (Instance::fastDynamicCast<Client>(replicator.getParent()))
|
|
{
|
|
float bufferHealth = replicator.rakPeer->GetBufferHealth();
|
|
if ((Time::nowFast() - lastBufferCheckTime).seconds() > 3.0)
|
|
{
|
|
if (bufferHealth <= 0.5)
|
|
{
|
|
// buffer is growing, reduce packets per step
|
|
if (sendPacketsPerStep > 1) // don't go below 1
|
|
sendPacketsPerStep--;
|
|
}
|
|
else if (bufferHealth >= 0.9)
|
|
{
|
|
// buffer health is good, push more data
|
|
Workspace* w = ServiceProvider::find<Aya::Workspace>(&replicator);
|
|
if (w)
|
|
{
|
|
if ((itemsPerPacket.value() * sendPacketsPerStep) < w->getWorld()->getSendPhysics()->getNumSimJobs())
|
|
sendPacketsPerStep++;
|
|
}
|
|
}
|
|
|
|
lastBufferCheckTime = Time::nowFast();
|
|
}
|
|
}
|
|
}
|
|
|
|
int RoundRobinPhysicsSender::sendPacket(int maxPackets, PacketPriority packetPriority, ReplicatorStats::PhysicsSenderStats* stats)
|
|
{
|
|
if (replicator.getBufferCountAvailable(maxPackets, packetPriority) <= 0)
|
|
return 0;
|
|
|
|
JobSender jobSender(*this, replicator.rakPeer.get());
|
|
|
|
// TODO: Check timer and feed these gradually?
|
|
Workspace* w = ServiceProvider::find<Aya::Workspace>(&replicator);
|
|
if (w)
|
|
{
|
|
const SimJob* characterSimJob = findTargetPlayerCharacterSimJob();
|
|
|
|
if (characterSimJob)
|
|
{
|
|
// For a minimal level of responsiveness, occasionally send the character with a high priority
|
|
const Time t = Time::now<Time::Fast>();
|
|
if (t > lastCharacterSendTime + Time::Interval(0.1))
|
|
{
|
|
jobSender.report(*characterSimJob);
|
|
lastCharacterSendTime = t;
|
|
}
|
|
else
|
|
{
|
|
characterSimJob = NULL; // don't ignore me below
|
|
}
|
|
}
|
|
|
|
int numSimJobs = w->getWorld()->getSendPhysics()->getNumSimJobs();
|
|
int numSimJobsReported = 0;
|
|
|
|
for (int i = 0; i < maxPackets; i++)
|
|
{
|
|
numSimJobsReported +=
|
|
w->getWorld()->getSendPhysics()->reportSimJobs(jobSender, jobStagePos, characterSimJob, numSimJobs - numSimJobsReported);
|
|
|
|
if (numSimJobsReported >= numSimJobs)
|
|
break;
|
|
|
|
jobSender.close();
|
|
}
|
|
}
|
|
|
|
// jobSend close automatically on destruction
|
|
|
|
return jobSender.packetCount;
|
|
};
|