Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-20 18:44:01 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge branch 'receive_packets' of https://github.com/huffman/hifi into atp

Browse source
This commit is contained in:
Stephen Birarda 2015-07-13 14:26:23 -07:00
commit 775c1b7310
16 changed files with 163 additions and 239 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

92
assignment-client/src/Agent.cpp
View file

@ -48,75 +48,53 @@ Agent::Agent(const QByteArray& packet) :
DependencyManager::set<ResourceCacheSharedItems>();
DependencyManager::set<SoundCache>();
auto& packetReceiver = DependencyManager::get<NodeList>()->getPackingReceiver();
auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
packetReceiver.registerPacketListener(PacketType::MixedAudio, this, "handleAudioPacket");
packetReceiver.registerPacketListener(PacketType::SilentAudioFrame, this, "handleAudioPacket");
packetReceiver.registerPacketListener(PacketType::OctreeStats, this, "handleOctreePacket");
packetReceiver.registerPacketListener(PacketType::EntityData, this, "handleOctreePacket");
packetReceiver.registerPacketListener(PacketType::EntityErase, this, "handleOctreePacket");
packetReceiver.registerPacketListener(PacketType::Jurisdiction, this, "handleJurisdictionPacket");
}
void Agent::readPendingDatagrams() {
QByteArray receivedPacket;
HifiSockAddr senderSockAddr;
auto nodeList = DependencyManager::get<NodeList>();
void Agent::handleOctreePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
QByteArray mutablePacket = QByteArray(packet->getData(), packet->getSizeWithHeader());
int messageLength = mutablePacket.size();
while (readAvailableDatagram(receivedPacket, senderSockAddr)) {
if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
PacketType::Value datagramPacketType = packetTypeForPacket(receivedPacket);
auto packetType = packet->getType();
if (datagramPacketType == PacketType::Jurisdiction) {
int headerBytes = numBytesForPacketHeader(receivedPacket);
if (packetType == PacketType::OctreeStats) {
SharedNodePointer matchedNode = nodeList->sendingNodeForPacket(receivedPacket);
if (matchedNode) {
// PacketType_JURISDICTION, first byte is the node type...
switch (receivedPacket[headerBytes]) {
case NodeType::EntityServer:
DependencyManager::get<EntityScriptingInterface>()->getJurisdictionListener()->
queueReceivedPacket(matchedNode, receivedPacket);
break;
}
}
} else if (datagramPacketType == PacketType::OctreeStats
|| datagramPacketType == PacketType::EntityData
|| datagramPacketType == PacketType::EntityErase
) {
// Make sure our Node and NodeList knows we've heard from this node.
SharedNodePointer sourceNode = nodeList->sendingNodeForPacket(receivedPacket);
sourceNode->setLastHeardMicrostamp(usecTimestampNow());
QByteArray mutablePacket = receivedPacket;
int messageLength = mutablePacket.size();
if (datagramPacketType == PacketType::OctreeStats) {
int statsMessageLength = OctreeHeadlessViewer::parseOctreeStats(mutablePacket, sourceNode);
if (messageLength > statsMessageLength) {
mutablePacket = mutablePacket.mid(statsMessageLength);
// TODO: this needs to be fixed, the goal is to test the packet version for the piggyback, but
// this is testing the version and hash of the original packet
// need to use numBytesArithmeticCodingFromBuffer()...
if (!DependencyManager::get<NodeList>()->packetVersionAndHashMatch(receivedPacket)) {
return; // bail since piggyback data doesn't match our versioning
}
} else {
return; // bail since no piggyback data
}
datagramPacketType = packetTypeForPacket(mutablePacket);
} // fall through to piggyback message
if (datagramPacketType == PacketType::EntityData || datagramPacketType == PacketType::EntityErase) {
_entityViewer.processDatagram(mutablePacket, sourceNode);
}
}
int statsMessageLength = OctreeHeadlessViewer::parseOctreeStats(packet, senderNode);
if (messageLength > statsMessageLength) {
mutablePacket = mutablePacket.mid(statsMessageLength);
} else {
return; // bail since no piggyback data
}
packetType = packetTypeForPacket(mutablePacket);
} // fall through to piggyback message
if (packetType == PacketType::EntityData || packetType == PacketType::EntityErase) {
_entityViewer.processDatagram(mutablePacket, senderNode);
}
}
void Agent::handleJurisdictionPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
QByteArray receivedPacket = QByteArray::fromRawData(packet->getData(), packet->getSizeWithHeader());
int headerBytes = numBytesForPacketHeader(receivedPacket);
// PacketType_JURISDICTION, first byte is the node type...
switch (receivedPacket[headerBytes]) {
case NodeType::EntityServer:
DependencyManager::get<EntityScriptingInterface>()->getJurisdictionListener()->
queueReceivedPacket(packet, senderNode);
break;
}
}
void Agent::handleAudioPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
_receivedAudioStream.parseData(receivedPacket);
_receivedAudioStream.parseData(QByteArray::fromRawData(packet->getData(), packet->getSizeWithHeader()));
_lastReceivedAudioLoudness = _receivedAudioStream.getNextOutputFrameLoudness();

3
assignment-client/src/Agent.h
View file

@ -52,11 +52,12 @@ public:
public slots:
void run();
void readPendingDatagrams();
void playAvatarSound(Sound* avatarSound) { _scriptEngine.setAvatarSound(avatarSound); }
private slots:
void handleAudioPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
void handleOctreePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
void handleJurisdictionPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
private:
ScriptEngine _scriptEngine;

2
assignment-client/src/AssignmentClient.cpp
View file

@ -122,7 +122,7 @@ AssignmentClient::AssignmentClient(Assignment::Type requestAssignmentType, QStri
}
auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
packetReceiver.registerPacketListener(PacketType::CreateAssignment, this, "handleCreateAssignmentPacket");
packetReceiver.registerPacketListener(PacketType::CreateAssignment, this, "handleStopNodePacket");
packetReceiver.registerPacketListener(PacketType::StopNode, this, "handleStopNodePacket");
}

86
assignment-client/src/AssignmentClientMonitor.cpp
View file

@ -53,7 +53,9 @@ AssignmentClientMonitor::AssignmentClientMonitor(const unsigned int numAssignmen
auto addressManager = DependencyManager::set<AddressManager>();
auto nodeList = DependencyManager::set<LimitedNodeList>();
connect(&nodeList->getNodeSocket(), &QUdpSocket::readyRead, this, &AssignmentClientMonitor::readPendingDatagrams);
auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
packetReceiver.registerPacketListener(PacketType::NodeJsonStats, this, "handleNodeJsonStatsPacket");
packetReceiver.registerPacketListener(PacketType::NodeJsonStats, this, "handleNodeJsonStatsUnknownNodePacket");
// use QProcess to fork off a process for each of the child assignment clients
for (unsigned int i = 0; i < _numAssignmentClientForks; i++) {
@ -201,63 +203,43 @@ void AssignmentClientMonitor::checkSpares() {
}
}
void AssignmentClientMonitor::handleNodeJsonStatsPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
auto senderSockAddr = packet->getSenderSockAddr();
void AssignmentClientMonitor::readPendingDatagrams() {
auto nodeList = DependencyManager::get<NodeList>();
// update our records about how to reach this child
senderNode->setLocalSocket(senderSockAddr);
QByteArray receivedPacket;
HifiSockAddr senderSockAddr;
QVariantMap packetVariantMap = JSONBreakableMarshal::fromStringBuffer(packet->getPayload());
QJsonObject unpackedStatsJSON = QJsonObject::fromVariantMap(packetVariantMap);
while (nodeList->getNodeSocket().hasPendingDatagrams()) {
receivedPacket.resize(nodeList->getNodeSocket().pendingDatagramSize());
nodeList->getNodeSocket().readDatagram(receivedPacket.data(), receivedPacket.size(),
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
// get child's assignment type out of the decoded json
QString childType = unpackedStatsJSON["assignment_type"].toString();
AssignmentClientChildData *childData =
static_cast<AssignmentClientChildData*>(senderNode->getLinkedData());
childData->setChildType(childType);
// note when this child talked
senderNode->setLastHeardMicrostamp(usecTimestampNow());
}
if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
if (packetTypeForPacket(receivedPacket) == PacketType::NodeJsonStats) {
QUuid packetUUID = uuidFromPacketHeader(receivedPacket);
SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket);
if (!matchingNode) {
// The parent only expects to be talking with prorams running on this same machine.
if (senderSockAddr.getAddress() == QHostAddress::LocalHost ||
senderSockAddr.getAddress() == QHostAddress::LocalHostIPv6) {
if (!packetUUID.isNull()) {
matchingNode = DependencyManager::get<LimitedNodeList>()->addOrUpdateNode
(packetUUID, NodeType::Unassigned, senderSockAddr, senderSockAddr, false, false);
AssignmentClientChildData *childData = new AssignmentClientChildData("unknown");
matchingNode->setLinkedData(childData);
} else {
// tell unknown assignment-client child to exit.
qDebug() << "asking unknown child to exit.";
void AssignmentClientMonitor::handleNodeJsonStatsUnknownNodePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
auto senderSockAddr = packet->getSenderSockAddr();
auto diePacket = NLPacket::create(PacketType::StopNode, 0);
nodeList->sendPacket(std::move(diePacket), senderSockAddr);
}
}
}
// The parent only expects to be talking with prorams running on this same machine.
if (senderSockAddr.getAddress() == QHostAddress::LocalHost ||
senderSockAddr.getAddress() == QHostAddress::LocalHostIPv6) {
QUuid packetUUID = uuidFromPacketHeader(QByteArray::fromRawData(packet->getData(), packet->getSizeWithHeader()));
if (!packetUUID.isNull()) {
senderNode = DependencyManager::get<LimitedNodeList>()->addOrUpdateNode
(packetUUID, NodeType::Unassigned, senderSockAddr, senderSockAddr, false, false);
AssignmentClientChildData *childData = new AssignmentClientChildData("unknown");
senderNode->setLinkedData(childData);
} else {
// tell unknown assignment-client child to exit.
qDebug() << "asking unknown child to exit.";
if (matchingNode) {
// update our records about how to reach this child
matchingNode->setLocalSocket(senderSockAddr);
QVariantMap packetVariantMap =
JSONBreakableMarshal::fromStringBuffer(receivedPacket.mid(numBytesForPacketHeader(receivedPacket)));
QJsonObject unpackedStatsJSON = QJsonObject::fromVariantMap(packetVariantMap);
// get child's assignment type out of the decoded json
QString childType = unpackedStatsJSON["assignment_type"].toString();
AssignmentClientChildData *childData =
static_cast<AssignmentClientChildData*>(matchingNode->getLinkedData());
childData->setChildType(childType);
// note when this child talked
matchingNode->setLastHeardMicrostamp(usecTimestampNow());
}
} else {
// have the NodeList attempt to handle it
nodeList->processNodeData(senderSockAddr, receivedPacket);
}
auto diePacket = NLPacket::create(PacketType::StopNode, 0);
auto nodeList = DependencyManager::get<NodeList>();
nodeList->sendPacket(std::move(diePacket), senderSockAddr);
}
}
}

3
assignment-client/src/AssignmentClientMonitor.h
View file

@ -35,9 +35,10 @@ public:
void stopChildProcesses();
private slots:
void readPendingDatagrams();
void checkSpares();
void childProcessFinished();
void handleNodeJsonStatsPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
void handleNodeJsonStatsUnknownNodePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
public slots:
void aboutToQuit();

49
assignment-client/src/audio/AudioMixer.cpp
View file

@ -543,44 +543,43 @@ void AudioMixer::sendAudioEnvironmentPacket(SharedNodePointer node) {
}
}
void AudioMixer::readPendingDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr) {
if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
nodeList->processNodeData(senderSockAddr, receivedPacket);
}
}
void AudioMixer::handleMicrophoneAudioNoEchoPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
nodeList->findNodeAndUpdateWithDataFromPacket(packet->getData());
auto nodeList = DependencyManager::get<NodeList>();
nodeList->findNodeAndUpdateWithDataFromPacket(packet);
}
void AudioMixer::handleMicrophoneAudioWithEchoPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
nodeList->findNodeAndUpdateWithDataFromPacket(packet->getData());
auto nodeList = DependencyManager::get<NodeList>();
nodeList->findNodeAndUpdateWithDataFromPacket(packet);
}
void AudioMixer::handleInjectAudioPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
nodeList->findNodeAndUpdateWithDataFromPacket(packet->getData());
auto nodeList = DependencyManager::get<NodeList>();
nodeList->findNodeAndUpdateWithDataFromPacket(packet);
}
void AudioMixer::handleSilentAudioFramePacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
nodeList->findNodeAndUpdateWithDataFromPacket(packet->getData());
auto nodeList = DependencyManager::get<NodeList>();
nodeList->findNodeAndUpdateWithDataFromPacket(packet);
}
void AudioMixer::handleAudioStreamStatsPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
nodeList->findNodeAndUpdateWithDataFromPacket(packet->getData());
auto nodeList = DependencyManager::get<NodeList>();
nodeList->findNodeAndUpdateWithDataFromPacket(packet);
}
void AudioMixer::handleMuteEnvironmentPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
auto nodeList = DependencyManager::get<NodeList>();
SharedNodePointer sendingNode = nodeList->nodeWithUUID(packet->getSourceID());
if (sendingNode->getCanAdjustLocks()) {
auto packet = NLPacket::create(PacketType::MuteEnvironment);
auto newPacket = NLPacket::create(PacketType::MuteEnvironment);
// Copy payload
packet->write(receivedPacket.mid(numBytesForPacketHeader(receivedPacket)));
newPacket->write(newPacket->getPayload());
nodeList->eachNode([&](const SharedNodePointer& node){
if (node->getType() == NodeType::Agent && node->getActiveSocket() &&
node->getLinkedData() && node != sendingNode) {
nodeList->sendPacket(std::move(packet), node);
nodeList->sendPacket(std::move(newPacket), node);
}
});
}
@ -680,28 +679,6 @@ void AudioMixer::run() {
_datagramProcessingThread = new QThread(this);
_datagramProcessingThread->setObjectName("Datagram Processor Thread");
// create an AudioMixerDatagramProcessor and move it to that thread
AudioMixerDatagramProcessor* datagramProcessor = new AudioMixerDatagramProcessor(nodeList->getNodeSocket(), thread());
datagramProcessor->moveToThread(_datagramProcessingThread);
// remove the NodeList as the parent of the node socket
nodeList->getNodeSocket().setParent(NULL);
nodeList->getNodeSocket().moveToThread(_datagramProcessingThread);
// let the datagram processor handle readyRead from node socket
connect(&nodeList->getNodeSocket(), &QUdpSocket::readyRead,
datagramProcessor, &AudioMixerDatagramProcessor::readPendingDatagrams);
// connect to the datagram processing thread signal that tells us we have to handle a packet
connect(datagramProcessor, &AudioMixerDatagramProcessor::packetRequiresProcessing, this, &AudioMixer::readPendingDatagram);
// delete the datagram processor and the associated thread when the QThread quits
connect(_datagramProcessingThread, &QThread::finished, datagramProcessor, &QObject::deleteLater);
connect(datagramProcessor, &QObject::destroyed, _datagramProcessingThread, &QThread::deleteLater);
// start the datagram processing thread
_datagramProcessingThread->start();
nodeList->addNodeTypeToInterestSet(NodeType::Agent);
nodeList->linkedDataCreateCallback = [](Node* node) {

2
assignment-client/src/audio/AudioMixer.h
View file

@ -35,8 +35,6 @@ public slots:
/// threaded run of assignment
void run();
void readPendingDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr);
void sendStatsPacket();
static const InboundAudioStream::Settings& getStreamSettings() { return _streamSettings; }

88
assignment-client/src/avatars/AvatarMixer.cpp
View file

@ -46,6 +46,12 @@ AvatarMixer::AvatarMixer(const QByteArray& packet) :
{
// make sure we hear about node kills so we can tell the other nodes
connect(DependencyManager::get<NodeList>().data(), &NodeList::nodeKilled, this, &AvatarMixer::nodeKilled);
auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
packetReceiver.registerPacketListener(PacketType::AvatarData, this, "handleAvatarDataPacket");
packetReceiver.registerPacketListener(PacketType::AvatarIdentity, this, "handleAvatarIdentityPacket");
packetReceiver.registerPacketListener(PacketType::AvatarBillboard, this, "handleAvatarBillboardPacket");
packetReceiver.registerPacketListener(PacketType::KillAvatar, this, "handleKillAvatarPacket");
}
AvatarMixer::~AvatarMixer() {
@ -394,65 +400,43 @@ void AvatarMixer::nodeKilled(SharedNodePointer killedNode) {
}
}
void AvatarMixer::readPendingDatagrams() {
QByteArray receivedPacket;
HifiSockAddr senderSockAddr;
void AvatarMixer::handleAvatarDataPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
auto nodeList = DependencyManager::get<NodeList>();
nodeList->findNodeAndUpdateWithDataFromPacket(packet);
}
while (readAvailableDatagram(receivedPacket, senderSockAddr)) {
if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
switch (packetTypeForPacket(receivedPacket)) {
case PacketType::AvatarData: {
nodeList->findNodeAndUpdateWithDataFromPacket(receivedPacket);
break;
}
case PacketType::AvatarIdentity: {
// check if we have a matching node in our list
SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket);
void AvatarMixer::handleAvatarIdentityPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
if (senderNode->getLinkedData()) {
AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(senderNode->getLinkedData());
AvatarData& avatar = nodeData->getAvatar();
if (avatarNode && avatarNode->getLinkedData()) {
AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(avatarNode->getLinkedData());
AvatarData& avatar = nodeData->getAvatar();
// parse the identity packet and update the change timestamp if appropriate
if (avatar.hasIdentityChangedAfterParsing(receivedPacket)) {
QMutexLocker nodeDataLocker(&nodeData->getMutex());
nodeData->setIdentityChangeTimestamp(QDateTime::currentMSecsSinceEpoch());
}
}
break;
}
case PacketType::AvatarBillboard: {
// check if we have a matching node in our list
SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket);
if (avatarNode && avatarNode->getLinkedData()) {
AvatarMixerClientData* nodeData = static_cast<AvatarMixerClientData*>(avatarNode->getLinkedData());
AvatarData& avatar = nodeData->getAvatar();
// parse the billboard packet and update the change timestamp if appropriate
if (avatar.hasBillboardChangedAfterParsing(receivedPacket)) {
QMutexLocker nodeDataLocker(&nodeData->getMutex());
nodeData->setBillboardChangeTimestamp(QDateTime::currentMSecsSinceEpoch());
}
}
break;
}
case PacketType::KillAvatar: {
nodeList->processKillNode(receivedPacket);
break;
}
default:
// hand this off to the NodeList
nodeList->processNodeData(senderSockAddr, receivedPacket);
break;
}
// parse the identity packet and update the change timestamp if appropriate
if (avatar.hasIdentityChangedAfterParsing(*packet)) {
QMutexLocker nodeDataLocker(&nodeData->getMutex());
nodeData->setIdentityChangeTimestamp(QDateTime::currentMSecsSinceEpoch());
}
}
}
void AvatarMixer::handleAvatarBillboardPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
if (senderNode->getLinkedData()) {
AvatarMixerClientData* nodeData = static_cast<AvatarMixerClientData*>(senderNode->getLinkedData());
AvatarData& avatar = nodeData->getAvatar();
// parse the billboard packet and update the change timestamp if appropriate
if (avatar.hasBillboardChangedAfterParsing(*packet)) {
QMutexLocker nodeDataLocker(&nodeData->getMutex());
nodeData->setBillboardChangeTimestamp(QDateTime::currentMSecsSinceEpoch());
}
}
}
void AvatarMixer::handleKillAvatarPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
auto nodeList = DependencyManager::get<NodeList>();
nodeList->processKillNode(*packet);
}
void AvatarMixer::sendStatsPacket() {
QJsonObject statsObject;
statsObject["average_listeners_last_second"] = (float) _sumListeners / (float) _numStatFrames;

8
assignment-client/src/avatars/AvatarMixer.h
View file

@ -29,9 +29,13 @@ public slots:
void nodeAdded(SharedNodePointer nodeAdded);
void nodeKilled(SharedNodePointer killedNode);
void readPendingDatagrams();
void sendStatsPacket();
private slots:
void handleAvatarDataPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
void handleAvatarIdentityPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
void handleAvatarBillboardPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
void handleKillAvatarPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
private:
void broadcastAvatarData();

6
assignment-client/src/entities/EntityServer.cpp
View file

@ -42,19 +42,19 @@ EntityServer::~EntityServer() {
void EntityServer::handleEntityAddPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
if (_octreeInboundPacketProcessor) {
_octreeInboundPacketProcessor->queueReceivedPacket(senderNode, receivedPacket->getData());
_octreeInboundPacketProcessor->queueReceivedPacket(packet, senderNode);
}
}
void EntityServer::handleEntityEditPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
if (_octreeInboundPacketProcessor) {
_octreeInboundPacketProcessor->queueReceivedPacket(senderNode, receivedPacket->getData());
_octreeInboundPacketProcessor->queueReceivedPacket(packet, senderNode);
}
}
void EntityServer::handleEntityErasePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
if (_octreeInboundPacketProcessor) {
_octreeInboundPacketProcessor->queueReceivedPacket(senderNode, receivedPacket->getData());
_octreeInboundPacketProcessor->queueReceivedPacket(packet, senderNode);
}
}

38
assignment-client/src/octree/OctreeServer.cpp
View file

@ -248,10 +248,10 @@ OctreeServer::OctreeServer(const QByteArray& packet) :
AccountManager::getInstance().setAuthURL(NetworkingConstants::METAVERSE_SERVER_URL);
auto packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
packetReceiver->registerPacketListener(getMyQueryMessageType(), this, "handleOctreeQueryPacket");
packetReceiver->registerPacketListener(PacketType::OctreeDataNack, this, "handleOctreeDataNackPacket");
packetReceiver->registerPacketListener(PacketType::JurisdictionRequest, this, "handleJurisdictionRequestPacket");
auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
packetReceiver.registerPacketListener(getMyQueryMessageType(), this, "handleOctreeQueryPacket");
packetReceiver.registerPacketListener(PacketType::OctreeDataNack, this, "handleOctreeDataNackPacket");
packetReceiver.registerPacketListener(PacketType::JurisdictionRequest, this, "handleJurisdictionRequestPacket");
}
OctreeServer::~OctreeServer() {
@ -860,35 +860,29 @@ void OctreeServer::readPendingDatagram(const QByteArray& receivedPacket, const H
}
}
void handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
void OctreeServer::handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
// If we got a query packet, then we're talking to an agent, and we
// need to make sure we have it in our nodeList.
SharedNodePointer matchingNode = nodeList->nodeWithUUID(packet->getSourceID());
if (matchingNode) {
nodeList->updateNodeWithDataFromPacket(matchingNode, packet->getData());
auto nodeList = DependencyManager::get<NodeList>();
nodeList->updateNodeWithDataFromPacket(senderNode, packet->getData());
OctreeQueryNode* nodeData = (OctreeQueryNode*) matchingNode->getLinkedData();
if (nodeData && !nodeData->isOctreeSendThreadInitalized()) {
nodeData->initializeOctreeSendThread(this, matchingNode);
}
OctreeQueryNode* nodeData = (OctreeQueryNode*)senderNode->getLinkedData();
if (nodeData && !nodeData->isOctreeSendThreadInitalized()) {
nodeData->initializeOctreeSendThread(this, senderNode);
}
}
void handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
void OctreeServer::handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
// If we got a nack packet, then we're talking to an agent, and we
// need to make sure we have it in our nodeList.
SharedNodePointer matchingNode = nodeList->nodeWithUUID(packet->getSourceID());
if (matchingNode) {
OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData();
if (nodeData) {
nodeData->parseNackPacket(packet->getData());
}
OctreeQueryNode* nodeData = (OctreeQueryNode*)senderNode->getLinkedData();
if (nodeData) {
nodeData->parseNackPacket(packet->getData());
}
}
void handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr) {
SharedNodePointer matchingNode = nodeList->nodeWithUUID(packet->getSourceID());
_jurisdictionSender->queueReceivedPacket(matchingNode, packet->getData());
void OctreeServer::handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
_jurisdictionSender->queueReceivedPacket(senderNode, packet->getData());
}
void OctreeServer::setupDatagramProcessingThread() {

6
assignment-client/src/octree/OctreeServer.h
View file

@ -129,9 +129,9 @@ public slots:
void readPendingDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr);
private slots:
void handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr);
void handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr);
void handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, HifiSockAddr senderSockAddr);
void handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
void handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
void handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
protected:
virtual Octree* createTree() = 0;

9
libraries/avatars/src/AvatarData.cpp
View file

@ -867,9 +867,8 @@ void AvatarData::clearJointsData() {
}
}
bool AvatarData::hasIdentityChangedAfterParsing(const QByteArray &packet) {
QDataStream packetStream(packet);
packetStream.skipRawData(numBytesForPacketHeader(packet));
bool AvatarData::hasIdentityChangedAfterParsing(NLPacket& packet) {
QDataStream packetStream(&packet);
QUuid avatarUUID;
QUrl faceModelURL, skeletonModelURL;
@ -911,8 +910,8 @@ QByteArray AvatarData::identityByteArray() {
return identityData;
}
bool AvatarData::hasBillboardChangedAfterParsing(const QByteArray& packet) {
QByteArray newBillboard = packet.mid(numBytesForPacketHeader(packet));
bool AvatarData::hasBillboardChangedAfterParsing(NLPacket& packet) {
QByteArray newBillboard = QByteArray(packet.getPayload());
if (newBillboard == _billboard) {
return false;
}

5
libraries/avatars/src/AvatarData.h
View file

@ -47,6 +47,7 @@ typedef unsigned long long quint64;
#include <QReadWriteLock>
#include <CollisionInfo.h>
#include <NLPacket.h>
#include <Node.h>
#include <RegisteredMetaTypes.h>
#include <SimpleMovingAverage.h>
@ -260,10 +261,10 @@ public:
return false;
}
bool hasIdentityChangedAfterParsing(const QByteArray& packet);
bool hasIdentityChangedAfterParsing(NLPacket& packet);
QByteArray identityByteArray();
bool hasBillboardChangedAfterParsing(const QByteArray& packet);
bool hasBillboardChangedAfterParsing(NLPacket& packet);
const QUrl& getFaceModelURL() const { return _faceModelURL; }
QString getFaceModelURLString() const { return _faceModelURL.toString(); }

4
libraries/networking/src/LimitedNodeList.cpp
View file

@ -301,6 +301,10 @@ void LimitedNodeList::killNodeWithUUID(const QUuid& nodeUUID) {
}
}
void LimitedNodeList::processKillNode(NLPacket& packet) {
processKillNode(QByteArray::fromRawData(packet.getData(), packet.getSizeWithHeader()));
}
void LimitedNodeList::processKillNode(const QByteArray& dataByteArray) {
// read the node id
QUuid nodeUUID = QUuid::fromRfc4122(dataByteArray.mid(numBytesForPacketHeader(dataByteArray), NUM_BYTES_RFC4122_UUID));

1
libraries/networking/src/LimitedNodeList.h
View file

@ -153,6 +153,7 @@ public:
const HifiSockAddr& getLocalSockAddr() const { return _localSockAddr; }
const HifiSockAddr& getSTUNSockAddr() const { return _stunSockAddr; }
void processKillNode(NLPacket& packet);
void processKillNode(const QByteArray& datagram);
int updateNodeWithDataFromPacket(QSharedPointer<NLPacket> packet, SharedNodePointer matchingNode);