Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-04 03:13:09 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

replace lingering PacketTypes in old format

Browse source
This commit is contained in:
Stephen Birarda 2015-07-08 10:18:11 -07:00
parent a489c3558d
commit 74940a2132
39 changed files with 141 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -58,7 +58,7 @@ void Agent::readPendingDatagrams() {
if (nodeList->packetVersionAndHashMatch(receivedPacket)) { if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
PacketType::Value datagramPacketType = packetTypeForPacket(receivedPacket); PacketType::Value datagramPacketType = packetTypeForPacket(receivedPacket);
if (datagramPacketType == PacketTypeJurisdiction) { if (datagramPacketType == PacketType::Jurisdiction) {
int headerBytes = numBytesForPacketHeader(receivedPacket); int headerBytes = numBytesForPacketHeader(receivedPacket);
SharedNodePointer matchedNode = nodeList->sendingNodeForPacket(receivedPacket); SharedNodePointer matchedNode = nodeList->sendingNodeForPacket(receivedPacket);
@ -73,9 +73,9 @@ void Agent::readPendingDatagrams() {
} }
} }
} else if (datagramPacketType == PacketTypeOctreeStats } else if (datagramPacketType == PacketType::OctreeStats
|| datagramPacketType == PacketTypeEntityData || datagramPacketType == PacketType::EntityData
|| datagramPacketType == PacketTypeEntityErase || datagramPacketType == PacketType::EntityErase
) { ) {
// Make sure our Node and NodeList knows we've heard from this node. // Make sure our Node and NodeList knows we've heard from this node.
SharedNodePointer sourceNode = nodeList->sendingNodeForPacket(receivedPacket); SharedNodePointer sourceNode = nodeList->sendingNodeForPacket(receivedPacket);
@ -84,7 +84,7 @@ void Agent::readPendingDatagrams() {
QByteArray mutablePacket = receivedPacket; QByteArray mutablePacket = receivedPacket;
int messageLength = mutablePacket.size(); int messageLength = mutablePacket.size();
if (datagramPacketType == PacketTypeOctreeStats) { if (datagramPacketType == PacketType::OctreeStats) {
int statsMessageLength = OctreeHeadlessViewer::parseOctreeStats(mutablePacket, sourceNode); int statsMessageLength = OctreeHeadlessViewer::parseOctreeStats(mutablePacket, sourceNode);
if (messageLength > statsMessageLength) { if (messageLength > statsMessageLength) {
@ -103,11 +103,11 @@ void Agent::readPendingDatagrams() {
datagramPacketType = packetTypeForPacket(mutablePacket); datagramPacketType = packetTypeForPacket(mutablePacket);
} // fall through to piggyback message } // fall through to piggyback message
if (datagramPacketType == PacketTypeEntityData || datagramPacketType == PacketTypeEntityErase) { if (datagramPacketType == PacketType::EntityData || datagramPacketType == PacketType::EntityErase) {
_entityViewer.processDatagram(mutablePacket, sourceNode); _entityViewer.processDatagram(mutablePacket, sourceNode);
} }
} else if (datagramPacketType == PacketTypeMixedAudio || datagramPacketType == PacketTypeSilentAudioFrame) { } else if (datagramPacketType == PacketType::MixedAudio || datagramPacketType == PacketType::SilentAudioFrame) {
_receivedAudioStream.parseData(receivedPacket); _receivedAudioStream.parseData(receivedPacket);
@ -118,10 +118,10 @@ void Agent::readPendingDatagrams() {
// let this continue through to the NodeList so it updates last heard timestamp // let this continue through to the NodeList so it updates last heard timestamp
// for the sending audio mixer // for the sending audio mixer
DependencyManager::get<NodeList>()->processNodeData(senderSockAddr, receivedPacket); DependencyManager::get<NodeList>()->processNodeData(senderSockAddr, receivedPacket);
} else if (datagramPacketType == PacketTypeBulkAvatarData } else if (datagramPacketType == PacketType::BulkAvatarData
|| datagramPacketType == PacketTypeAvatarIdentity || datagramPacketType == PacketType::AvatarIdentity
|| datagramPacketType == PacketTypeAvatarBillboard || datagramPacketType == PacketType::AvatarBillboard
|| datagramPacketType == PacketTypeKillAvatar) { || datagramPacketType == PacketType::KillAvatar) {
// let the avatar hash map process it // let the avatar hash map process it
DependencyManager::get<AvatarHashMap>()->processAvatarMixerDatagram(receivedPacket, nodeList->sendingNodeForPacket(receivedPacket)); DependencyManager::get<AvatarHashMap>()->processAvatarMixerDatagram(receivedPacket, nodeList->sendingNodeForPacket(receivedPacket));

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

@ -218,9 +218,9 @@ void AssignmentClient::readPendingDatagrams() {
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer()); senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
if (nodeList->packetVersionAndHashMatch(receivedPacket)) { if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
if (packetTypeForPacket(receivedPacket) == PacketTypeCreateAssignment) { if (packetTypeForPacket(receivedPacket) == PacketType::CreateAssignment) {
qDebug() << "Received a PacketTypeCreateAssignment - attempting to unpack."; qDebug() << "Received a PacketType::CreateAssignment - attempting to unpack.";
// construct the deployed assignment from the packet data // construct the deployed assignment from the packet data
_currentAssignment = AssignmentFactory::unpackAssignment(receivedPacket); _currentAssignment = AssignmentFactory::unpackAssignment(receivedPacket);
@ -271,10 +271,10 @@ void AssignmentClient::readPendingDatagrams() {
} else { } else {
qDebug() << "Received an assignment that could not be unpacked. Re-requesting."; qDebug() << "Received an assignment that could not be unpacked. Re-requesting.";
} }
} else if (packetTypeForPacket(receivedPacket) == PacketTypeStopNode) { } else if (packetTypeForPacket(receivedPacket) == PacketType::StopNode) {
if (senderSockAddr.getAddress() == QHostAddress::LocalHost || if (senderSockAddr.getAddress() == QHostAddress::LocalHost ||
senderSockAddr.getAddress() == QHostAddress::LocalHostIPv6) { senderSockAddr.getAddress() == QHostAddress::LocalHostIPv6) {
qDebug() << "AssignmentClientMonitor at" << senderSockAddr << "requested stop via PacketTypeStopNode."; qDebug() << "AssignmentClientMonitor at" << senderSockAddr << "requested stop via PacketType::StopNode.";
QCoreApplication::quit(); QCoreApplication::quit();
} else { } else {

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

@ -214,7 +214,7 @@ void AssignmentClientMonitor::readPendingDatagrams() {
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer()); senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
if (nodeList->packetVersionAndHashMatch(receivedPacket)) { if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
if (packetTypeForPacket(receivedPacket) == PacketTypeNodeJsonStats) { if (packetTypeForPacket(receivedPacket) == PacketType::NodeJsonStats) {
QUuid packetUUID = uuidFromPacketHeader(receivedPacket); QUuid packetUUID = uuidFromPacketHeader(receivedPacket);
SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket); SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket);
if (!matchingNode) { if (!matchingNode) {

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

@ -540,18 +540,18 @@ void AudioMixer::readPendingDatagram(const QByteArray& receivedPacket, const Hif
if (nodeList->packetVersionAndHashMatch(receivedPacket)) { if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
// pull any new audio data from nodes off of the network stack // pull any new audio data from nodes off of the network stack
PacketType::Value mixerPacketType = packetTypeForPacket(receivedPacket); PacketType::Value mixerPacketType = packetTypeForPacket(receivedPacket);
if (mixerPacketType == PacketTypeMicrophoneAudioNoEcho if (mixerPacketType == PacketType::MicrophoneAudioNoEcho
|| mixerPacketType == PacketTypeMicrophoneAudioWithEcho || mixerPacketType == PacketType::MicrophoneAudioWithEcho
|| mixerPacketType == PacketTypeInjectAudio || mixerPacketType == PacketType::InjectAudio
|| mixerPacketType == PacketTypeSilentAudioFrame || mixerPacketType == PacketType::SilentAudioFrame
|| mixerPacketType == PacketTypeAudioStreamStats) { || mixerPacketType == PacketType::AudioStreamStats) {
nodeList->findNodeAndUpdateWithDataFromPacket(receivedPacket); nodeList->findNodeAndUpdateWithDataFromPacket(receivedPacket);
} else if (mixerPacketType == PacketTypeMuteEnvironment) { } else if (mixerPacketType == PacketType::MuteEnvironment) {
SharedNodePointer sendingNode = nodeList->sendingNodeForPacket(receivedPacket); SharedNodePointer sendingNode = nodeList->sendingNodeForPacket(receivedPacket);
if (sendingNode->getCanAdjustLocks()) { if (sendingNode->getCanAdjustLocks()) {
QByteArray packet = receivedPacket; QByteArray packet = receivedPacket;
nodeList->populatePacketHeader(packet, PacketTypeMuteEnvironment); nodeList->populatePacketHeader(packet, PacketType::MuteEnvironment);
nodeList->eachNode([&](const SharedNodePointer& node){ nodeList->eachNode([&](const SharedNodePointer& node){
if (node->getType() == NodeType::Agent && node->getActiveSocket() && if (node->getType() == NodeType::Agent && node->getActiveSocket() &&

10
assignment-client/src/audio/AudioMixerClientData.cpp
View file

@ -51,7 +51,7 @@ AvatarAudioStream* AudioMixerClientData::getAvatarAudioStream() const {
int AudioMixerClientData::parseData(const QByteArray& packet) { int AudioMixerClientData::parseData(const QByteArray& packet) {
PacketType::Value packetType = packetTypeForPacket(packet); PacketType::Value packetType = packetTypeForPacket(packet);
if (packetType == PacketTypeAudioStreamStats) { if (packetType == PacketType::AudioStreamStats) {
const char* dataAt = packet.data(); const char* dataAt = packet.data();
@ -67,9 +67,9 @@ int AudioMixerClientData::parseData(const QByteArray& packet) {
} else { } else {
PositionalAudioStream* matchingStream = NULL; PositionalAudioStream* matchingStream = NULL;
if (packetType == PacketTypeMicrophoneAudioWithEcho if (packetType == PacketType::MicrophoneAudioWithEcho
|| packetType == PacketTypeMicrophoneAudioNoEcho || packetType == PacketType::MicrophoneAudioNoEcho
|| packetType == PacketTypeSilentAudioFrame) { || packetType == PacketType::SilentAudioFrame) {
QUuid nullUUID = QUuid(); QUuid nullUUID = QUuid();
if (!_audioStreams.contains(nullUUID)) { if (!_audioStreams.contains(nullUUID)) {
@ -84,7 +84,7 @@ int AudioMixerClientData::parseData(const QByteArray& packet) {
} else { } else {
matchingStream = _audioStreams.value(nullUUID); matchingStream = _audioStreams.value(nullUUID);
} }
} else if (packetType == PacketTypeInjectAudio) { } else if (packetType == PacketType::InjectAudio) {
// this is injected audio // this is injected audio
// grab the stream identifier for this injected audio // grab the stream identifier for this injected audio

4
assignment-client/src/audio/AvatarAudioStream.cpp
View file

@ -21,7 +21,7 @@ AvatarAudioStream::AvatarAudioStream(bool isStereo, const InboundAudioStream::Se
int AvatarAudioStream::parseStreamProperties(PacketType::Value type, const QByteArray& packetAfterSeqNum, int& numAudioSamples) { int AvatarAudioStream::parseStreamProperties(PacketType::Value type, const QByteArray& packetAfterSeqNum, int& numAudioSamples) {
int readBytes = 0; int readBytes = 0;
if (type == PacketTypeSilentAudioFrame) { if (type == PacketType::SilentAudioFrame) {
const char* dataAt = packetAfterSeqNum.constData(); const char* dataAt = packetAfterSeqNum.constData();
quint16 numSilentSamples = *(reinterpret_cast<const quint16*>(dataAt)); quint16 numSilentSamples = *(reinterpret_cast<const quint16*>(dataAt));
readBytes += sizeof(quint16); readBytes += sizeof(quint16);
@ -31,7 +31,7 @@ int AvatarAudioStream::parseStreamProperties(PacketType::Value type, const QByte
readBytes += parsePositionalData(packetAfterSeqNum.mid(readBytes)); readBytes += parsePositionalData(packetAfterSeqNum.mid(readBytes));
} else { } else {
_shouldLoopbackForNode = (type == PacketTypeMicrophoneAudioWithEcho); _shouldLoopbackForNode = (type == PacketType::MicrophoneAudioWithEcho);
// read the channel flag // read the channel flag
quint8 channelFlag = packetAfterSeqNum.at(readBytes); quint8 channelFlag = packetAfterSeqNum.at(readBytes);

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

@ -254,7 +254,7 @@ void AvatarMixer::broadcastAvatarData() {
} }
PacketSequenceNumber lastSeqToReceiver = nodeData->getLastBroadcastSequenceNumber(otherNode->getUUID()); PacketSequenceNumber lastSeqToReceiver = nodeData->getLastBroadcastSequenceNumber(otherNode->getUUID());
PacketSequenceNumber lastSeqFromSender = otherNode->getLastSequenceNumberForPacketType(PacketType::AvatarData); PacketSequenceNumber lastSeqFromSender = otherNode->getLastSequenceNumberForPacketType::(PacketType::AvatarData);
if (lastSeqToReceiver > lastSeqFromSender) { if (lastSeqToReceiver > lastSeqFromSender) {
// Did we somehow get out of order packets from the sender? // Did we somehow get out of order packets from the sender?
@ -283,7 +283,7 @@ void AvatarMixer::broadcastAvatarData() {
// set the last sent sequence number for this sender on the receiver // set the last sent sequence number for this sender on the receiver
nodeData->setLastBroadcastSequenceNumber(otherNode->getUUID(), nodeData->setLastBroadcastSequenceNumber(otherNode->getUUID(),
otherNode->getLastSequenceNumberForPacketType(PacketType::AvatarData)); otherNode->getLastSequenceNumberForPacketType::(PacketType::AvatarData));
// start a new segment in the PacketList for this avatar // start a new segment in the PacketList for this avatar
avatarPacketList.startSegment(); avatarPacketList.startSegment();
@ -399,11 +399,11 @@ void AvatarMixer::readPendingDatagrams() {
while (readAvailableDatagram(receivedPacket, senderSockAddr)) { while (readAvailableDatagram(receivedPacket, senderSockAddr)) {
if (nodeList->packetVersionAndHashMatch(receivedPacket)) { if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
switch (packetTypeForPacket(receivedPacket)) { switch (packetTypeForPacket(receivedPacket)) {
case PacketTypeAvatarData: { case PacketType::AvatarData: {
nodeList->findNodeAndUpdateWithDataFromPacket(receivedPacket); nodeList->findNodeAndUpdateWithDataFromPacket(receivedPacket);
break; break;
} }
case PacketTypeAvatarIdentity: { case PacketType::AvatarIdentity: {
// check if we have a matching node in our list // check if we have a matching node in our list
SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket); SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket);
@ -420,7 +420,7 @@ void AvatarMixer::readPendingDatagrams() {
} }
break; break;
} }
case PacketTypeAvatarBillboard: { case PacketType::AvatarBillboard: {
// check if we have a matching node in our list // check if we have a matching node in our list
SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket); SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket);
@ -438,7 +438,7 @@ void AvatarMixer::readPendingDatagrams() {
} }
break; break;
} }
case PacketTypeKillAvatar: { case PacketType::KillAvatar: {
nodeList->processKillNode(receivedPacket); nodeList->processKillNode(receivedPacket);
break; break;
} }

2
assignment-client/src/entities/EntityNodeData.h
View file

@ -22,7 +22,7 @@ public:
OctreeQueryNode(), OctreeQueryNode(),
_lastDeletedEntitiesSentAt(0) { } _lastDeletedEntitiesSentAt(0) { }
virtual PacketType::Value getMyPacketType() const { return PacketTypeEntityData; } virtual PacketType::Value getMyPacketType() const { return PacketType::EntityData; }
quint64 getLastDeletedEntitiesSentAt() const { return _lastDeletedEntitiesSentAt; } quint64 getLastDeletedEntitiesSentAt() const { return _lastDeletedEntitiesSentAt; }
void setLastDeletedEntitiesSentAt(quint64 sentAt) { _lastDeletedEntitiesSentAt = sentAt; } void setLastDeletedEntitiesSentAt(quint64 sentAt) { _lastDeletedEntitiesSentAt = sentAt; }

4
assignment-client/src/entities/EntityServer.h
View file

@ -28,11 +28,11 @@ public:
// Subclasses must implement these methods // Subclasses must implement these methods
virtual OctreeQueryNode* createOctreeQueryNode(); virtual OctreeQueryNode* createOctreeQueryNode();
virtual char getMyNodeType() const { return NodeType::EntityServer; } virtual char getMyNodeType() const { return NodeType::EntityServer; }
virtual PacketType::Value getMyQueryMessageType() const { return PacketTypeEntityQuery; } virtual PacketType::Value getMyQueryMessageType() const { return PacketType::EntityQuery; }
virtual const char* getMyServerName() const { return MODEL_SERVER_NAME; } virtual const char* getMyServerName() const { return MODEL_SERVER_NAME; }
virtual const char* getMyLoggingServerTargetName() const { return MODEL_SERVER_LOGGING_TARGET_NAME; } virtual const char* getMyLoggingServerTargetName() const { return MODEL_SERVER_LOGGING_TARGET_NAME; }
virtual const char* getMyDefaultPersistFilename() const { return LOCAL_MODELS_PERSIST_FILE; } virtual const char* getMyDefaultPersistFilename() const { return LOCAL_MODELS_PERSIST_FILE; }
virtual PacketType::Value getMyEditNackType() const { return PacketTypeEntityEditNack; } virtual PacketType::Value getMyEditNackType() const { return PacketType::EntityEditNack; }
virtual QString getMyDomainSettingsKey() const { return QString("entity_server_settings"); } virtual QString getMyDomainSettingsKey() const { return QString("entity_server_settings"); }
// subclass may implement these method // subclass may implement these method

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

@ -875,7 +875,7 @@ void OctreeServer::readPendingDatagram(const QByteArray& receivedPacket, const H
nodeData->initializeOctreeSendThread(this, matchingNode); nodeData->initializeOctreeSendThread(this, matchingNode);
} }
} }
} else if (packetType == PacketTypeOctreeDataNack) { } else if (packetType == PacketType::OctreeDataNack) {
// If we got a nack packet, then we're talking to an agent, and we // 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. // need to make sure we have it in our nodeList.
if (matchingNode) { if (matchingNode) {
@ -884,7 +884,7 @@ void OctreeServer::readPendingDatagram(const QByteArray& receivedPacket, const H
nodeData->parseNackPacket(receivedPacket); nodeData->parseNackPacket(receivedPacket);
} }
} }
} else if (packetType == PacketTypeJurisdictionRequest) { } else if (packetType == PacketType::JurisdictionRequest) {
_jurisdictionSender->queueReceivedPacket(matchingNode, receivedPacket); _jurisdictionSender->queueReceivedPacket(matchingNode, receivedPacket);
} else if (_octreeInboundPacketProcessor && getOctree()->handlesEditPacketType(packetType)) { } else if (_octreeInboundPacketProcessor && getOctree()->handlesEditPacketType(packetType)) {
_octreeInboundPacketProcessor->queueReceivedPacket(matchingNode, receivedPacket); _octreeInboundPacketProcessor->queueReceivedPacket(matchingNode, receivedPacket);

2
assignment-client/src/octree/OctreeServerDatagramProcessor.cpp
View file

@ -44,7 +44,7 @@ void OctreeServerDatagramProcessor::readPendingDatagrams() {
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer()); senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
PacketType::Value packetType = packetTypeForPacket(incomingPacket); PacketType::Value packetType = packetTypeForPacket(incomingPacket);
if (packetType == PacketTypePing) { if (packetType == PacketType::Ping) {
DependencyManager::get<NodeList>()->processNodeData(senderSockAddr, incomingPacket); DependencyManager::get<NodeList>()->processNodeData(senderSockAddr, incomingPacket);
return; // don't emit return; // don't emit
} }

30
domain-server/src/DomainServer.cpp
View file

@ -706,7 +706,7 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
nodeData->setSendingSockAddr(senderSockAddr); nodeData->setSendingSockAddr(senderSockAddr);
// reply back to the user with a PacketTypeDomainList // reply back to the user with a PacketType::DomainList
sendDomainListToNode(newNode, senderSockAddr, nodeInterestList.toSet()); sendDomainListToNode(newNode, senderSockAddr, nodeInterestList.toSet());
// send out this node to our other connected nodes // send out this node to our other connected nodes
@ -1002,7 +1002,7 @@ void DomainServer::broadcastNewNode(const SharedNodePointer& addedNode) {
auto limitedNodeList = DependencyManager::get<LimitedNodeList>(); auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
// setup the add packet for this new node // setup the add packet for this new node
QByteArray addNodePacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeDomainServerAddedNode); QByteArray addNodePacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketType::DomainServerAddedNode);
QDataStream addNodeStream(&addNodePacket, QIODevice::Append); QDataStream addNodeStream(&addNodePacket, QIODevice::Append);
addNodeStream << *addedNode.data(); addNodeStream << *addedNode.data();
@ -1037,14 +1037,14 @@ void DomainServer::readAvailableDatagrams() {
HifiSockAddr senderSockAddr; HifiSockAddr senderSockAddr;
QByteArray receivedPacket; QByteArray receivedPacket;
static QByteArray assignmentPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeCreateAssignment); static QByteArray assignmentPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketType::CreateAssignment);
static int numAssignmentPacketHeaderBytes = assignmentPacket.size(); static int numAssignmentPacketHeaderBytes = assignmentPacket.size();
while (limitedNodeList->getNodeSocket().hasPendingDatagrams()) { while (limitedNodeList->getNodeSocket().hasPendingDatagrams()) {
receivedPacket.resize(limitedNodeList->getNodeSocket().pendingDatagramSize()); receivedPacket.resize(limitedNodeList->getNodeSocket().pendingDatagramSize());
limitedNodeList->getNodeSocket().readDatagram(receivedPacket.data(), receivedPacket.size(), limitedNodeList->getNodeSocket().readDatagram(receivedPacket.data(), receivedPacket.size(),
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer()); senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
if (packetTypeForPacket(receivedPacket) == PacketTypeRequestAssignment if (packetTypeForPacket(receivedPacket) == PacketType::RequestAssignment
&& limitedNodeList->packetVersionAndHashMatch(receivedPacket)) { && limitedNodeList->packetVersionAndHashMatch(receivedPacket)) {
// construct the requested assignment from the packet data // construct the requested assignment from the packet data
@ -1108,8 +1108,8 @@ void DomainServer::readAvailableDatagrams() {
processDatagram(receivedPacket, senderSockAddr); processDatagram(receivedPacket, senderSockAddr);
} else { } else {
// we're using DTLS, so tell the sender to get back to us using DTLS // we're using DTLS, so tell the sender to get back to us using DTLS
static QByteArray dtlsRequiredPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeDomainServerRequireDTLS); static QByteArray dtlsRequiredPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketType::DomainServerRequireDTLS);
static int numBytesDTLSHeader = numBytesForPacketHeaderGivenPacketType(PacketTypeDomainServerRequireDTLS); static int numBytesDTLSHeader = numBytesForPacketHeaderGivenPacketType::(PacketTypeDomainServerRequireDTLS);
if (dtlsRequiredPacket.size() == numBytesDTLSHeader) { if (dtlsRequiredPacket.size() == numBytesDTLSHeader) {
// pack the port that we accept DTLS traffic on // pack the port that we accept DTLS traffic on
@ -1390,10 +1390,10 @@ void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiS
if (nodeList->packetVersionAndHashMatch(receivedPacket)) { if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
PacketType::Value requestType = packetTypeForPacket(receivedPacket); PacketType::Value requestType = packetTypeForPacket(receivedPacket);
switch (requestType) { switch (requestType) {
case PacketTypeDomainConnectRequest: case PacketType::DomainConnectRequest:
handleConnectRequest(receivedPacket, senderSockAddr); handleConnectRequest(receivedPacket, senderSockAddr);
break; break;
case PacketTypeDomainListRequest: { case PacketType::DomainListRequest: {
QUuid nodeUUID = uuidFromPacketHeader(receivedPacket); QUuid nodeUUID = uuidFromPacketHeader(receivedPacket);
if (!nodeUUID.isNull() && nodeList->nodeWithUUID(nodeUUID)) { if (!nodeUUID.isNull() && nodeList->nodeWithUUID(nodeUUID)) {
@ -1422,12 +1422,12 @@ void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiS
break; break;
} }
case PacketTypeDomainServerPathQuery: { case PacketType::DomainServerPathQuery: {
// have our private method attempt to respond to this path query // have our private method attempt to respond to this path query
respondToPathQuery(receivedPacket, senderSockAddr); respondToPathQuery(receivedPacket, senderSockAddr);
break; break;
} }
case PacketTypeNodeJsonStats: { case PacketType::NodeJsonStats: {
SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket); SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket);
if (matchingNode) { if (matchingNode) {
reinterpret_cast<DomainServerNodeData*>(matchingNode->getLinkedData())->parseJSONStatsPacket(receivedPacket); reinterpret_cast<DomainServerNodeData*>(matchingNode->getLinkedData())->parseJSONStatsPacket(receivedPacket);
@ -1435,16 +1435,16 @@ void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiS
break; break;
} }
case PacketTypeStunResponse: case PacketType::StunResponse:
nodeList->processSTUNResponse(receivedPacket); nodeList->processSTUNResponse(receivedPacket);
break; break;
case PacketTypeUnverifiedPing: { case PacketType::UnverifiedPing: {
QByteArray pingReplyPacket = nodeList->constructPingReplyPacket(receivedPacket); QByteArray pingReplyPacket = nodeList->constructPingReplyPacket(receivedPacket);
nodeList->writeUnverifiedDatagram(pingReplyPacket, senderSockAddr); nodeList->writeUnverifiedDatagram(pingReplyPacket, senderSockAddr);
break; break;
} }
case PacketTypeUnverifiedPingReply: { case PacketType::UnverifiedPingReply: {
processICEPingReply(receivedPacket, senderSockAddr); processICEPingReply(receivedPacket, senderSockAddr);
break; break;
} }
@ -2225,7 +2225,7 @@ void DomainServer::respondToPathQuery(const QByteArray& receivedPacket, const Hi
// this is a query for the viewpoint resulting from a path // this is a query for the viewpoint resulting from a path
// first pull the query path from the packet // first pull the query path from the packet
int numHeaderBytes = numBytesForPacketHeaderGivenPacketType(PacketTypeDomainServerPathQuery); int numHeaderBytes = numBytesForPacketHeaderGivenPacketType::(PacketTypeDomainServerPathQuery);
const char* packetDataStart = receivedPacket.data() + numHeaderBytes; const char* packetDataStart = receivedPacket.data() + numHeaderBytes;
// figure out how many bytes the sender said this path is // figure out how many bytes the sender said this path is
@ -2257,7 +2257,7 @@ void DomainServer::respondToPathQuery(const QByteArray& receivedPacket, const Hi
QByteArray viewpointUTF8 = responseViewpoint.toUtf8(); QByteArray viewpointUTF8 = responseViewpoint.toUtf8();
// prepare a packet for the response // prepare a packet for the response
QByteArray pathResponsePacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeDomainServerPathResponse); QByteArray pathResponsePacket = nodeList->byteArrayWithPopulatedHeader(PacketType::DomainServerPathResponse);
// check the number of bytes the viewpoint is // check the number of bytes the viewpoint is
quint16 numViewpointBytes = responseViewpoint.toUtf8().size(); quint16 numViewpointBytes = responseViewpoint.toUtf8().size();

4
ice-server/src/IceServer.cpp
View file

@ -56,12 +56,12 @@ void IceServer::processDatagrams() {
PacketType::Value packetType = packetTypeForPacket(incomingPacket); PacketType::Value packetType = packetTypeForPacket(incomingPacket);
if (packetType == PacketTypeIceServerHeartbeat) { if (packetType == PacketType::IceServerHeartbeat) {
SharedNetworkPeer peer = addOrUpdateHeartbeatingPeer(incomingPacket); SharedNetworkPeer peer = addOrUpdateHeartbeatingPeer(incomingPacket);
// so that we can send packets to the heartbeating peer when we need, we need to activate a socket now // so that we can send packets to the heartbeating peer when we need, we need to activate a socket now
peer->activateMatchingOrNewSymmetricSocket(sendingSockAddr); peer->activateMatchingOrNewSymmetricSocket(sendingSockAddr);
} else if (packetType == PacketTypeIceServerQuery) { } else if (packetType == PacketType::IceServerQuery) {
QDataStream heartbeatStream(incomingPacket); QDataStream heartbeatStream(incomingPacket);
// this is a node hoping to connect to a heartbeating peer - do we have the heartbeating peer? // this is a node hoping to connect to a heartbeating peer - do we have the heartbeating peer?

2
interface/src/Application.cpp
View file

@ -2627,7 +2627,7 @@ void Application::update(float deltaTime) {
_lastQueriedTime = now; _lastQueriedTime = now;
if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) { if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) {
queryOctree(NodeType::EntityServer, PacketTypeEntityQuery, _entityServerJurisdictions); queryOctree(NodeType::EntityServer, PacketType::EntityQuery, _entityServerJurisdictions);
} }
_lastQueriedViewFrustum = _viewFrustum; _lastQueriedViewFrustum = _viewFrustum;
} }

44
interface/src/DatagramProcessor.cpp
View file

@ -55,15 +55,15 @@ void DatagramProcessor::processDatagrams() {
PacketType::Value incomingType = packetTypeForPacket(incomingPacket); PacketType::Value incomingType = packetTypeForPacket(incomingPacket);
// only process this packet if we have a match on the packet version // only process this packet if we have a match on the packet version
switch (incomingType) { switch (incomingType) {
case PacketTypeAudioEnvironment: case PacketType::AudioEnvironment:
case PacketTypeAudioStreamStats: case PacketType::AudioStreamStats:
case PacketTypeMixedAudio: case PacketType::MixedAudio:
case PacketTypeSilentAudioFrame: { case PacketType::SilentAudioFrame: {
if (incomingType == PacketTypeAudioStreamStats) { if (incomingType == PacketType::AudioStreamStats) {
QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "parseAudioStreamStatsPacket", QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "parseAudioStreamStatsPacket",
Qt::QueuedConnection, Qt::QueuedConnection,
Q_ARG(QByteArray, incomingPacket)); Q_ARG(QByteArray, incomingPacket));
} else if (incomingType == PacketTypeAudioEnvironment) { } else if (incomingType == PacketType::AudioEnvironment) {
QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "parseAudioEnvironmentData", QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "parseAudioEnvironmentData",
Qt::QueuedConnection, Qt::QueuedConnection,
Q_ARG(QByteArray, incomingPacket)); Q_ARG(QByteArray, incomingPacket));
@ -82,10 +82,10 @@ void DatagramProcessor::processDatagrams() {
break; break;
} }
case PacketTypeEntityData: case PacketType::EntityData:
case PacketTypeEntityErase: case PacketType::EntityErase:
case PacketTypeOctreeStats: case PacketType::OctreeStats:
case PacketTypeEnvironmentData: { case PacketType::EnvironmentData: {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
"Application::networkReceive()... _octreeProcessor.queueReceivedPacket()"); "Application::networkReceive()... _octreeProcessor.queueReceivedPacket()");
SharedNodePointer matchedNode = DependencyManager::get<NodeList>()->sendingNodeForPacket(incomingPacket); SharedNodePointer matchedNode = DependencyManager::get<NodeList>()->sendingNodeForPacket(incomingPacket);
@ -96,10 +96,10 @@ void DatagramProcessor::processDatagrams() {
} }
break; break;
} }
case PacketTypeBulkAvatarData: case PacketType::BulkAvatarData:
case PacketTypeKillAvatar: case PacketType::KillAvatar:
case PacketTypeAvatarIdentity: case PacketType::AvatarIdentity:
case PacketTypeAvatarBillboard: { case PacketType::AvatarBillboard: {
// update having heard from the avatar-mixer and record the bytes received // update having heard from the avatar-mixer and record the bytes received
SharedNodePointer avatarMixer = nodeList->sendingNodeForPacket(incomingPacket); SharedNodePointer avatarMixer = nodeList->sendingNodeForPacket(incomingPacket);
@ -112,8 +112,8 @@ void DatagramProcessor::processDatagrams() {
} }
break; break;
} }
case PacketTypeDomainConnectionDenied: { case PacketType::DomainConnectionDenied: {
int headerSize = numBytesForPacketHeaderGivenPacketType(PacketTypeDomainConnectionDenied); int headerSize = numBytesForPacketHeaderGivenPacketType::(PacketTypeDomainConnectionDenied);
QDataStream packetStream(QByteArray(incomingPacket.constData() + headerSize, QDataStream packetStream(QByteArray(incomingPacket.constData() + headerSize,
incomingPacket.size() - headerSize)); incomingPacket.size() - headerSize));
QString reason; QString reason;
@ -127,15 +127,15 @@ void DatagramProcessor::processDatagrams() {
AccountManager::getInstance().checkAndSignalForAccessToken(); AccountManager::getInstance().checkAndSignalForAccessToken();
break; break;
} }
case PacketTypeNoisyMute: case PacketType::NoisyMute:
case PacketTypeMuteEnvironment: { case PacketType::MuteEnvironment: {
bool mute = !DependencyManager::get<AudioClient>()->isMuted(); bool mute = !DependencyManager::get<AudioClient>()->isMuted();
if (incomingType == PacketTypeMuteEnvironment) { if (incomingType == PacketType::MuteEnvironment) {
glm::vec3 position; glm::vec3 position;
float radius; float radius;
int headerSize = numBytesForPacketHeaderGivenPacketType(PacketTypeMuteEnvironment); int headerSize = numBytesForPacketHeaderGivenPacketType::(PacketTypeMuteEnvironment);
memcpy(&position, incomingPacket.constData() + headerSize, sizeof(glm::vec3)); memcpy(&position, incomingPacket.constData() + headerSize, sizeof(glm::vec3));
memcpy(&radius, incomingPacket.constData() + headerSize + sizeof(glm::vec3), sizeof(float)); memcpy(&radius, incomingPacket.constData() + headerSize + sizeof(glm::vec3), sizeof(float));
float distance = glm::distance(DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition(), float distance = glm::distance(DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition(),
@ -146,7 +146,7 @@ void DatagramProcessor::processDatagrams() {
if (mute) { if (mute) {
DependencyManager::get<AudioClient>()->toggleMute(); DependencyManager::get<AudioClient>()->toggleMute();
if (incomingType == PacketTypeMuteEnvironment) { if (incomingType == PacketType::MuteEnvironment) {
AudioScriptingInterface::getInstance().environmentMuted(); AudioScriptingInterface::getInstance().environmentMuted();
} else { } else {
AudioScriptingInterface::getInstance().mutedByMixer(); AudioScriptingInterface::getInstance().mutedByMixer();
@ -154,7 +154,7 @@ void DatagramProcessor::processDatagrams() {
} }
break; break;
} }
case PacketTypeEntityEditNack: case PacketType::EntityEditNack:
if (!Menu::getInstance()->isOptionChecked(MenuOption::DisableNackPackets)) { if (!Menu::getInstance()->isOptionChecked(MenuOption::DisableNackPackets)) {
application->_entityEditSender.processNackPacket(incomingPacket); application->_entityEditSender.processNackPacket(incomingPacket);
} }

2
interface/src/avatar/MyAvatar.cpp
View file

@ -866,7 +866,7 @@ int MyAvatar::parseDataAtOffset(const QByteArray& packet, int offset) {
void MyAvatar::sendKillAvatar() { void MyAvatar::sendKillAvatar() {
auto nodeList = DependencyManager::get<NodeList>(); auto nodeList = DependencyManager::get<NodeList>();
QByteArray killPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeKillAvatar); QByteArray killPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::KillAvatar);
nodeList->broadcastToNodes(killPacket, NodeSet() << NodeType::AvatarMixer); nodeList->broadcastToNodes(killPacket, NodeSet() << NodeType::AvatarMixer);
} }

8
interface/src/octree/OctreePacketProcessor.cpp
View file

@ -38,7 +38,7 @@ void OctreePacketProcessor::processPacket(const SharedNodePointer& sendingNode,
// note: PacketType_OCTREE_STATS can have PacketType_VOXEL_DATA // note: PacketType_OCTREE_STATS can have PacketType_VOXEL_DATA
// immediately following them inside the same packet. So, we process the PacketType_OCTREE_STATS first // immediately following them inside the same packet. So, we process the PacketType_OCTREE_STATS first
// then process any remaining bytes as if it was another packet // then process any remaining bytes as if it was another packet
if (voxelPacketType == PacketTypeOctreeStats) { if (voxelPacketType == PacketType::OctreeStats) {
int statsMessageLength = app->parseOctreeStats(mutablePacket, sendingNode); int statsMessageLength = app->parseOctreeStats(mutablePacket, sendingNode);
wasStatsPacket = true; wasStatsPacket = true;
if (messageLength > statsMessageLength) { if (messageLength > statsMessageLength) {
@ -81,19 +81,19 @@ void OctreePacketProcessor::processPacket(const SharedNodePointer& sendingNode,
if (sendingNode) { if (sendingNode) {
switch(voxelPacketType) { switch(voxelPacketType) {
case PacketTypeEntityErase: { case PacketType::EntityErase: {
if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) { if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) {
app->_entities.processEraseMessage(mutablePacket, sendingNode); app->_entities.processEraseMessage(mutablePacket, sendingNode);
} }
} break; } break;
case PacketTypeEntityData: { case PacketType::EntityData: {
if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) { if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) {
app->_entities.processDatagram(mutablePacket, sendingNode); app->_entities.processDatagram(mutablePacket, sendingNode);
} }
} break; } break;
case PacketTypeEnvironmentData: { case PacketType::EnvironmentData: {
app->_environment.parseData(*sendingNode->getActiveSocket(), mutablePacket); app->_environment.parseData(*sendingNode->getActiveSocket(), mutablePacket);
} break; } break;

4
libraries/audio/src/InboundAudioStream.cpp
View file

@ -132,7 +132,7 @@ int InboundAudioStream::parseData(const QByteArray& packet) {
} }
case SequenceNumberStats::OnTime: { case SequenceNumberStats::OnTime: {
// Packet is on time; parse its data to the ringbuffer // Packet is on time; parse its data to the ringbuffer
if (packetType == PacketTypeSilentAudioFrame) { if (packetType == PacketType::SilentAudioFrame) {
writeDroppableSilentSamples(networkSamples); writeDroppableSilentSamples(networkSamples);
} else { } else {
readBytes += parseAudioData(packetType, packet.mid(readBytes), networkSamples); readBytes += parseAudioData(packetType, packet.mid(readBytes), networkSamples);
@ -169,7 +169,7 @@ int InboundAudioStream::parseData(const QByteArray& packet) {
} }
int InboundAudioStream::parseStreamProperties(PacketType::Value type, const QByteArray& packetAfterSeqNum, int& numAudioSamples) { int InboundAudioStream::parseStreamProperties(PacketType::Value type, const QByteArray& packetAfterSeqNum, int& numAudioSamples) {
if (type == PacketTypeSilentAudioFrame) { if (type == PacketType::SilentAudioFrame) {
quint16 numSilentSamples = 0; quint16 numSilentSamples = 0;
memcpy(&numSilentSamples, packetAfterSeqNum.constData(), sizeof(quint16)); memcpy(&numSilentSamples, packetAfterSeqNum.constData(), sizeof(quint16));
numAudioSamples = numSilentSamples; numAudioSamples = numSilentSamples;

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

@ -1078,7 +1078,7 @@ void AvatarData::setJointMappingsFromNetworkReply() {
void AvatarData::sendAvatarDataPacket() { void AvatarData::sendAvatarDataPacket() {
auto nodeList = DependencyManager::get<NodeList>(); auto nodeList = DependencyManager::get<NodeList>();
QByteArray dataPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeAvatarData); QByteArray dataPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::AvatarData);
dataPacket.append(toByteArray()); dataPacket.append(toByteArray());
nodeList->broadcastToNodes(dataPacket, NodeSet() << NodeType::AvatarMixer); nodeList->broadcastToNodes(dataPacket, NodeSet() << NodeType::AvatarMixer);
@ -1087,7 +1087,7 @@ void AvatarData::sendAvatarDataPacket() {
void AvatarData::sendIdentityPacket() { void AvatarData::sendIdentityPacket() {
auto nodeList = DependencyManager::get<NodeList>(); auto nodeList = DependencyManager::get<NodeList>();
QByteArray identityPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeAvatarIdentity); QByteArray identityPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::AvatarIdentity);
identityPacket.append(identityByteArray()); identityPacket.append(identityByteArray());
nodeList->broadcastToNodes(identityPacket, NodeSet() << NodeType::AvatarMixer); nodeList->broadcastToNodes(identityPacket, NodeSet() << NodeType::AvatarMixer);
@ -1097,7 +1097,7 @@ void AvatarData::sendBillboardPacket() {
if (!_billboard.isEmpty()) { if (!_billboard.isEmpty()) {
auto nodeList = DependencyManager::get<NodeList>(); auto nodeList = DependencyManager::get<NodeList>();
QByteArray billboardPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeAvatarBillboard); QByteArray billboardPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::AvatarBillboard);
billboardPacket.append(_billboard); billboardPacket.append(_billboard);
nodeList->broadcastToNodes(billboardPacket, NodeSet() << NodeType::AvatarMixer); nodeList->broadcastToNodes(billboardPacket, NodeSet() << NodeType::AvatarMixer);

8
libraries/avatars/src/AvatarHashMap.cpp
View file

@ -22,16 +22,16 @@ AvatarHashMap::AvatarHashMap() {
void AvatarHashMap::processAvatarMixerDatagram(const QByteArray& datagram, const QWeakPointer<Node>& mixerWeakPointer) { void AvatarHashMap::processAvatarMixerDatagram(const QByteArray& datagram, const QWeakPointer<Node>& mixerWeakPointer) {
switch (packetTypeForPacket(datagram)) { switch (packetTypeForPacket(datagram)) {
case PacketTypeBulkAvatarData: case PacketType::BulkAvatarData:
processAvatarDataPacket(datagram, mixerWeakPointer); processAvatarDataPacket(datagram, mixerWeakPointer);
break; break;
case PacketTypeAvatarIdentity: case PacketType::AvatarIdentity:
processAvatarIdentityPacket(datagram, mixerWeakPointer); processAvatarIdentityPacket(datagram, mixerWeakPointer);
break; break;
case PacketTypeAvatarBillboard: case PacketType::AvatarBillboard:
processAvatarBillboardPacket(datagram, mixerWeakPointer); processAvatarBillboardPacket(datagram, mixerWeakPointer);
break; break;
case PacketTypeKillAvatar: case PacketType::KillAvatar:
processKillAvatar(datagram); processKillAvatar(datagram);
break; break;
default: default:

4
libraries/entities-renderer/src/EntityTreeRenderer.h
View file

@ -43,8 +43,8 @@ public:
virtual ~EntityTreeRenderer(); virtual ~EntityTreeRenderer();
virtual char getMyNodeType() const { return NodeType::EntityServer; } virtual char getMyNodeType() const { return NodeType::EntityServer; }
virtual PacketType::Value getMyQueryMessageType() const { return PacketTypeEntityQuery; } virtual PacketType::Value getMyQueryMessageType() const { return PacketType::EntityQuery; }
virtual PacketType::Value getExpectedPacketType() const { return PacketTypeEntityData; } virtual PacketType::Value getExpectedPacketType() const { return PacketType::EntityData; }
virtual void renderElement(OctreeElement* element, RenderArgs* args); virtual void renderElement(OctreeElement* element, RenderArgs* args);
virtual float getSizeScale() const; virtual float getSizeScale() const;
virtual int getBoundaryLevelAdjust() const; virtual int getBoundaryLevelAdjust() const;

4
libraries/entities/src/EntityEditPacketSender.cpp
View file

@ -21,7 +21,7 @@
void EntityEditPacketSender::adjustEditPacketForClockSkew(PacketType::Value type, void EntityEditPacketSender::adjustEditPacketForClockSkew(PacketType::Value type,
unsigned char* editBuffer, size_t length, int clockSkew) { unsigned char* editBuffer, size_t length, int clockSkew) {
if (type == PacketTypeEntityAdd || type == PacketTypeEntityEdit) { if (type == PacketType::EntityAdd || type == PacketType::EntityEdit) {
EntityItem::adjustEditPacketForClockSkew(editBuffer, length, clockSkew); EntityItem::adjustEditPacketForClockSkew(editBuffer, length, clockSkew);
} }
} }
@ -54,6 +54,6 @@ void EntityEditPacketSender::queueEraseEntityMessage(const EntityItemID& entityI
unsigned char bufferOut[MAX_PACKET_SIZE]; unsigned char bufferOut[MAX_PACKET_SIZE];
size_t sizeOut = 0; size_t sizeOut = 0;
if (EntityItemProperties::encodeEraseEntityMessage(entityItemID, &bufferOut[0], _maxPacketSize, sizeOut)) { if (EntityItemProperties::encodeEraseEntityMessage(entityItemID, &bufferOut[0], _maxPacketSize, sizeOut)) {
queueOctreeEditMessage(PacketTypeEntityErase, bufferOut, sizeOut); queueOctreeEditMessage(PacketType::EntityErase, bufferOut, sizeOut);
} }
} }

12
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -93,7 +93,7 @@ QUuid EntityScriptingInterface::addEntity(const EntityItemProperties& properties
// queue the packet // queue the packet
if (success) { if (success) {
queueEntityMessage(PacketTypeEntityAdd, id, propertiesWithSimID); queueEntityMessage(PacketType::EntityAdd, id, propertiesWithSimID);
} }
return id; return id;
@ -175,13 +175,13 @@ QUuid EntityScriptingInterface::editEntity(QUuid id, EntityItemProperties proper
entity->setLastBroadcast(usecTimestampNow()); entity->setLastBroadcast(usecTimestampNow());
} }
_entityTree->unlock(); _entityTree->unlock();
queueEntityMessage(PacketTypeEntityEdit, entityID, properties); queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return id; return id;
} }
return QUuid(); return QUuid();
} }
queueEntityMessage(PacketTypeEntityEdit, entityID, properties); queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return id; return id;
} }
@ -446,7 +446,7 @@ bool EntityScriptingInterface::setVoxels(QUuid entityID,
properties.setVoxelDataDirty(); properties.setVoxelDataDirty();
properties.setLastEdited(now); properties.setLastEdited(now);
queueEntityMessage(PacketTypeEntityEdit, entityID, properties); queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return true; return true;
} }
@ -483,7 +483,7 @@ bool EntityScriptingInterface::setPoints(QUuid entityID, std::function<bool(Line
properties.setLastEdited(now); properties.setLastEdited(now);
queueEntityMessage(PacketTypeEntityEdit, entityID, properties); queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return success; return success;
} }
@ -552,7 +552,7 @@ bool EntityScriptingInterface::actionWorker(const QUuid& entityID,
properties.setActionDataDirty(); properties.setActionDataDirty();
auto now = usecTimestampNow(); auto now = usecTimestampNow();
properties.setLastEdited(now); properties.setLastEdited(now);
queueEntityMessage(PacketTypeEntityEdit, entityID, properties); queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return success; return success;
} }

22
libraries/entities/src/EntityTree.cpp
View file

@ -63,12 +63,12 @@ void EntityTree::eraseAllOctreeElements(bool createNewRoot) {
Octree::eraseAllOctreeElements(createNewRoot); Octree::eraseAllOctreeElements(createNewRoot);
} }
bool EntityTree::handlesEditPacketType(PacketType::Value packetType) const { bool EntityTree::handlesEditPacketType::(PacketType::Value packetType) const {
// we handle these types of "edit" packets // we handle these types of "edit" packets
switch (packetType) { switch (packetType) {
case PacketTypeEntityAdd: case PacketType::EntityAdd:
case PacketTypeEntityEdit: case PacketType::EntityEdit:
case PacketTypeEntityErase: case PacketType::EntityErase:
return true; return true;
default: default:
return false; return false;
@ -583,14 +583,14 @@ int EntityTree::processEditPacketData(PacketType::Value packetType, const unsign
int processedBytes = 0; int processedBytes = 0;
// we handle these types of "edit" packets // we handle these types of "edit" packets
switch (packetType) { switch (packetType) {
case PacketTypeEntityErase: { case PacketType::EntityErase: {
QByteArray dataByteArray((const char*)editData, maxLength); QByteArray dataByteArray((const char*)editData, maxLength);
processedBytes = processEraseMessageDetails(dataByteArray, senderNode); processedBytes = processEraseMessageDetails(dataByteArray, senderNode);
break; break;
} }
case PacketTypeEntityAdd: case PacketType::EntityAdd:
case PacketTypeEntityEdit: { case PacketType::EntityEdit: {
quint64 startDecode = 0, endDecode = 0; quint64 startDecode = 0, endDecode = 0;
quint64 startLookup = 0, endLookup = 0; quint64 startLookup = 0, endLookup = 0;
quint64 startUpdate = 0, endUpdate = 0; quint64 startUpdate = 0, endUpdate = 0;
@ -613,7 +613,7 @@ int EntityTree::processEditPacketData(PacketType::Value packetType, const unsign
startLookup = usecTimestampNow(); startLookup = usecTimestampNow();
EntityItemPointer existingEntity = findEntityByEntityItemID(entityItemID); EntityItemPointer existingEntity = findEntityByEntityItemID(entityItemID);
endLookup = usecTimestampNow(); endLookup = usecTimestampNow();
if (existingEntity && packetType == PacketTypeEntityEdit) { if (existingEntity && packetType == PacketType::EntityEdit) {
// if the EntityItem exists, then update it // if the EntityItem exists, then update it
startLogging = usecTimestampNow(); startLogging = usecTimestampNow();
if (wantEditLogging()) { if (wantEditLogging()) {
@ -627,7 +627,7 @@ int EntityTree::processEditPacketData(PacketType::Value packetType, const unsign
existingEntity->markAsChangedOnServer(); existingEntity->markAsChangedOnServer();
endUpdate = usecTimestampNow(); endUpdate = usecTimestampNow();
_totalUpdates++; _totalUpdates++;
} else if (packetType == PacketTypeEntityAdd) { } else if (packetType == PacketType::EntityAdd) {
if (senderNode->getCanRez()) { if (senderNode->getCanRez()) {
// this is a new entity... assign a new entityID // this is a new entity... assign a new entityID
properties.setCreated(properties.getLastEdited()); properties.setCreated(properties.getLastEdited());
@ -766,7 +766,7 @@ bool EntityTree::encodeEntitiesDeletedSince(OCTREE_PACKET_SEQUENCE sequenceNumbe
unsigned char* copyAt = outputBuffer; unsigned char* copyAt = outputBuffer;
size_t numBytesPacketHeader = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(outputBuffer), size_t numBytesPacketHeader = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(outputBuffer),
PacketTypeEntityErase); PacketType::EntityErase);
copyAt += numBytesPacketHeader; copyAt += numBytesPacketHeader;
outputLength = numBytesPacketHeader; outputLength = numBytesPacketHeader;
@ -1072,7 +1072,7 @@ bool EntityTree::sendEntitiesOperation(OctreeElement* element, void* extraData)
properties.markAllChanged(); // so the entire property set is considered new, since we're making a new entity properties.markAllChanged(); // so the entire property set is considered new, since we're making a new entity
// queue the packet to send to the server // queue the packet to send to the server
args->packetSender->queueEditEntityMessage(PacketTypeEntityAdd, newID, properties); args->packetSender->queueEditEntityMessage(PacketType::EntityAdd, newID, properties);
// also update the local tree instantly (note: this is not our tree, but an alternate tree) // also update the local tree instantly (note: this is not our tree, but an alternate tree)
if (args->localTree) { if (args->localTree) {

4
libraries/entities/src/EntityTree.h
View file

@ -62,10 +62,10 @@ public:
// These methods will allow the OctreeServer to send your tree inbound edit packets of your // These methods will allow the OctreeServer to send your tree inbound edit packets of your
// own definition. Implement these to allow your octree based server to support editing // own definition. Implement these to allow your octree based server to support editing
virtual bool getWantSVOfileVersions() const { return true; } virtual bool getWantSVOfileVersions() const { return true; }
virtual PacketType::Value expectedDataPacketType() const { return PacketTypeEntityData; } virtual PacketType::Value expectedDataPacketType() const { return PacketType::EntityData; }
virtual bool canProcessVersion(PacketVersion thisVersion) const virtual bool canProcessVersion(PacketVersion thisVersion) const
{ return thisVersion >= VERSION_ENTITIES_USE_METERS_AND_RADIANS; } { return thisVersion >= VERSION_ENTITIES_USE_METERS_AND_RADIANS; }
virtual bool handlesEditPacketType(PacketType::Value packetType) const; virtual bool handlesEditPacketType::(PacketType::Value packetType) const;
virtual int processEditPacketData(PacketType::Value packetType, const unsigned char* packetData, int packetLength, virtual int processEditPacketData(PacketType::Value packetType, const unsigned char* packetData, int packetLength,
const unsigned char* editData, int maxLength, const SharedNodePointer& senderNode); const unsigned char* editData, int maxLength, const SharedNodePointer& senderNode);

4
libraries/entities/src/EntityTreeHeadlessViewer.h
View file

@ -31,8 +31,8 @@ public:
virtual ~EntityTreeHeadlessViewer(); virtual ~EntityTreeHeadlessViewer();
virtual char getMyNodeType() const { return NodeType::EntityServer; } virtual char getMyNodeType() const { return NodeType::EntityServer; }
virtual PacketType::Value getMyQueryMessageType() const { return PacketTypeEntityQuery; } virtual PacketType::Value getMyQueryMessageType() const { return PacketType::EntityQuery; }
virtual PacketType::Value getExpectedPacketType() const { return PacketTypeEntityData; } virtual PacketType::Value getExpectedPacketType() const { return PacketType::EntityData; }
void update(); void update();

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

@ -353,7 +353,7 @@ qint64 LimitedNodeList::writeDatagram(const QByteArray& datagram, const HifiSock
PacketSequenceNumber LimitedNodeList::getNextSequenceNumberForPacket(const QUuid& nodeUUID, PacketType::Value packetType) { PacketSequenceNumber LimitedNodeList::getNextSequenceNumberForPacket(const QUuid& nodeUUID, PacketType::Value packetType) {
// Thanks to std::map and std::unordered_map this line either default constructs the // Thanks to std::map and std::unordered_map this line either default constructs the
// PacketTypeSequenceMap and the PacketSequenceNumber or returns the existing value. // PacketType::SequenceMap and the PacketSequenceNumber or returns the existing value.
// We use the postfix increment so that the stored value is incremented and the next // We use the postfix increment so that the stored value is incremented and the next
// return gives the correct value. // return gives the correct value.

2
libraries/networking/src/NodeList.cpp
View file

@ -413,7 +413,7 @@ void NodeList::sendDSPathQuery(const QString& newPath) {
// send off the path query // send off the path query
sendPacket(std::move(pathQueryPacket), _domainHandler.getSockAddr()); sendPacket(std::move(pathQueryPacket), _domainHandler.getSockAddr());
} else { } else {
qCDebug(networking) << "Path" << newPath << "would make PacketTypeDomainServerPathQuery packet > MAX_PACKET_SIZE." << qCDebug(networking) << "Path" << newPath << "would make PacketType::DomainServerPathQuery packet > MAX_PACKET_SIZE." <<
"Will not send query."; "Will not send query.";
} }
} }

2
libraries/octree/src/EditPacketBuffer.cpp
View file

@ -13,7 +13,7 @@
EditPacketBuffer::EditPacketBuffer() : EditPacketBuffer::EditPacketBuffer() :
_nodeUUID(), _nodeUUID(),
_currentType(PacketTypeUnknown), _currentType(PacketType::Unknown),
_currentSize(0), _currentSize(0),
_satoshiCost(0) _satoshiCost(0)
{ {

2
libraries/octree/src/JurisdictionListener.cpp
View file

@ -57,7 +57,7 @@ bool JurisdictionListener::queueJurisdictionRequest() {
} }
void JurisdictionListener::processPacket(const SharedNodePointer& sendingNode, const QByteArray& packet) { void JurisdictionListener::processPacket(const SharedNodePointer& sendingNode, const QByteArray& packet) {
if (packetTypeForPacket(packet) == PacketTypeJurisdiction && sendingNode) { if (packetTypeForPacket(packet) == PacketType::Jurisdiction && sendingNode) {
QUuid nodeUUID = sendingNode->getUUID(); QUuid nodeUUID = sendingNode->getUUID();
JurisdictionMap map; JurisdictionMap map;
map.unpackFromMessage(reinterpret_cast<const unsigned char*>(packet.data()), packet.size()); map.unpackFromMessage(reinterpret_cast<const unsigned char*>(packet.data()), packet.size());

6
libraries/octree/src/JurisdictionListener.h
View file

@ -20,8 +20,8 @@
#include "JurisdictionMap.h" #include "JurisdictionMap.h"
/// Sends out PacketType_JURISDICTION_REQUEST packets to all voxel servers and then listens for and processes /// Sends out PacketType::_JURISDICTION_REQUEST packets to all voxel servers and then listens for and processes
/// the PacketType_JURISDICTION packets it receives in order to maintain an accurate state of all jurisidictions /// the PacketType::_JURISDICTION packets it receives in order to maintain an accurate state of all jurisidictions
/// within the domain. As with other ReceivedPacketProcessor classes the user is responsible for reading inbound packets /// within the domain. As with other ReceivedPacketProcessor classes the user is responsible for reading inbound packets
/// and adding them to the processing queue by calling queueReceivedPacket() /// and adding them to the processing queue by calling queueReceivedPacket()
class JurisdictionListener : public ReceivedPacketProcessor { class JurisdictionListener : public ReceivedPacketProcessor {
@ -45,7 +45,7 @@ public slots:
void nodeKilled(SharedNodePointer node); void nodeKilled(SharedNodePointer node);
protected: protected:
/// Callback for processing of received packets. Will process any queued PacketType_JURISDICTION and update the /// Callback for processing of received packets. Will process any queued PacketType::_JURISDICTION and update the
/// jurisdiction map member variable /// jurisdiction map member variable
virtual void processPacket(const SharedNodePointer& sendingNode, const QByteArray& packet); virtual void processPacket(const SharedNodePointer& sendingNode, const QByteArray& packet);

4
libraries/octree/src/JurisdictionMap.cpp
View file

@ -272,7 +272,7 @@ int JurisdictionMap::packEmptyJurisdictionIntoMessage(NodeType_t type, unsigned
unsigned char* bufferStart = destinationBuffer; unsigned char* bufferStart = destinationBuffer;
int headerLength = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(destinationBuffer), int headerLength = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(destinationBuffer),
PacketTypeJurisdiction); PacketType::Jurisdiction);
destinationBuffer += headerLength; destinationBuffer += headerLength;
// Pack the Node Type in first byte // Pack the Node Type in first byte
@ -291,7 +291,7 @@ int JurisdictionMap::packIntoMessage(unsigned char* destinationBuffer, int avail
unsigned char* bufferStart = destinationBuffer; unsigned char* bufferStart = destinationBuffer;
int headerLength = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(destinationBuffer), int headerLength = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(destinationBuffer),
PacketTypeJurisdiction); PacketType::Jurisdiction);
destinationBuffer += headerLength; destinationBuffer += headerLength;
// Pack the Node Type in first byte // Pack the Node Type in first byte

2
libraries/octree/src/JurisdictionSender.cpp
View file

@ -30,7 +30,7 @@ JurisdictionSender::~JurisdictionSender() {
void JurisdictionSender::processPacket(const SharedNodePointer& sendingNode, const QByteArray& packet) { void JurisdictionSender::processPacket(const SharedNodePointer& sendingNode, const QByteArray& packet) {
if (packetTypeForPacket(packet) == PacketTypeJurisdictionRequest) { if (packetTypeForPacket(packet) == PacketType::JurisdictionRequest) {
if (sendingNode) { if (sendingNode) {
lockRequestingNodes(); lockRequestingNodes();
_nodesRequestingJurisdictions.push(sendingNode->getUUID()); _nodesRequestingJurisdictions.push(sendingNode->getUUID());

2
libraries/octree/src/JurisdictionSender.h
View file

@ -19,7 +19,7 @@
#include <ReceivedPacketProcessor.h> #include <ReceivedPacketProcessor.h>
#include "JurisdictionMap.h" #include "JurisdictionMap.h"
/// Will process PacketType_JURISDICTION_REQUEST packets and send out PacketType_JURISDICTION packets /// Will process PacketType::_JURISDICTION_REQUEST packets and send out PacketType::_JURISDICTION packets
/// to requesting parties. As with other ReceivedPacketProcessor classes the user is responsible for reading inbound packets /// to requesting parties. As with other ReceivedPacketProcessor classes the user is responsible for reading inbound packets
/// and adding them to the processing queue by calling queueReceivedPacket() /// and adding them to the processing queue by calling queueReceivedPacket()
class JurisdictionSender : public ReceivedPacketProcessor { class JurisdictionSender : public ReceivedPacketProcessor {

2
libraries/octree/src/Octree.cpp
View file

@ -1916,7 +1916,7 @@ bool Octree::readFromStream(unsigned long streamLength, QDataStream& inputStream
device->getChar(&firstChar); device->getChar(&firstChar);
device->ungetChar(firstChar); device->ungetChar(firstChar);
if (firstChar == (char) PacketTypeEntityData) { if (firstChar == (char) PacketType::EntityData) {
qCDebug(octree) << "Reading from SVO Stream length:" << streamLength; qCDebug(octree) << "Reading from SVO Stream length:" << streamLength;
return readSVOFromStream(streamLength, inputStream); return readSVOFromStream(streamLength, inputStream);
} else { } else {

2
libraries/octree/src/Octree.h
View file

@ -226,7 +226,7 @@ public:
// These methods will allow the OctreeServer to send your tree inbound edit packets of your // These methods will allow the OctreeServer to send your tree inbound edit packets of your
// own definition. Implement these to allow your octree based server to support editing // own definition. Implement these to allow your octree based server to support editing
virtual bool getWantSVOfileVersions() const { return false; } virtual bool getWantSVOfileVersions() const { return false; }
virtual PacketType::Value expectedDataPacketType() const { return PacketTypeUnknown; } virtual PacketType::Value expectedDataPacketType() const { return PacketType::Unknown; }
virtual bool canProcessVersion(PacketVersion thisVersion) const { virtual bool canProcessVersion(PacketVersion thisVersion) const {
return thisVersion == versionForPacketType(expectedDataPacketType()); } return thisVersion == versionForPacketType(expectedDataPacketType()); }
virtual PacketVersion expectedVersion() const { return versionForPacketType(expectedDataPacketType()); } virtual PacketVersion expectedVersion() const { return versionForPacketType(expectedDataPacketType()); }

6
libraries/octree/src/OctreeEditPacketSender.cpp
View file

@ -252,7 +252,7 @@ void OctreeEditPacketSender::queueOctreeEditMessage(PacketType::Value type, unsi
QUuid nodeUUID = node->getUUID(); QUuid nodeUUID = node->getUUID();
bool isMyJurisdiction = true; bool isMyJurisdiction = true;
if (type == PacketTypeEntityErase) { if (type == PacketType::EntityErase) {
isMyJurisdiction = true; // send erase messages to all servers isMyJurisdiction = true; // send erase messages to all servers
} else if (_serverJurisdictions) { } else if (_serverJurisdictions) {
// we need to get the jurisdiction for this // we need to get the jurisdiction for this
@ -318,11 +318,11 @@ void OctreeEditPacketSender::releaseQueuedMessages() {
void OctreeEditPacketSender::releaseQueuedPacket(EditPacketBuffer& packetBuffer) { void OctreeEditPacketSender::releaseQueuedPacket(EditPacketBuffer& packetBuffer) {
_releaseQueuedPacketMutex.lock(); _releaseQueuedPacketMutex.lock();
if (packetBuffer._currentSize > 0 && packetBuffer._currentType != PacketTypeUnknown) { if (packetBuffer._currentSize > 0 && packetBuffer._currentType != PacketType::Unknown) {
queuePacketToNode(packetBuffer._nodeUUID, &packetBuffer._currentBuffer[0], queuePacketToNode(packetBuffer._nodeUUID, &packetBuffer._currentBuffer[0],
packetBuffer._currentSize, packetBuffer._satoshiCost); packetBuffer._currentSize, packetBuffer._satoshiCost);
packetBuffer._currentSize = 0; packetBuffer._currentSize = 0;
packetBuffer._currentType = PacketTypeUnknown; packetBuffer._currentType = PacketType::Unknown;
} }
_releaseQueuedPacketMutex.unlock(); _releaseQueuedPacketMutex.unlock();
} }

2
libraries/physics/src/EntityMotionState.cpp
View file

@ -481,7 +481,7 @@ void EntityMotionState::sendUpdate(OctreeEditPacketSender* packetSender, const Q
qCDebug(physics) << "EntityMotionState::sendUpdate()... calling queueEditEntityMessage()..."; qCDebug(physics) << "EntityMotionState::sendUpdate()... calling queueEditEntityMessage()...";
#endif #endif
entityPacketSender->queueEditEntityMessage(PacketTypeEntityEdit, id, properties); entityPacketSender->queueEditEntityMessage(PacketType::EntityEdit, id, properties);
_entity->setLastBroadcast(usecTimestampNow()); _entity->setLastBroadcast(usecTimestampNow());
} else { } else {
#ifdef WANT_DEBUG #ifdef WANT_DEBUG

6
libraries/script-engine/src/ScriptEngine.cpp
View file

@ -587,7 +587,7 @@ void ScriptEngine::run() {
/ (1000 * 1000)) + 0.5); / (1000 * 1000)) + 0.5);
const int SCRIPT_AUDIO_BUFFER_BYTES = SCRIPT_AUDIO_BUFFER_SAMPLES * sizeof(int16_t); const int SCRIPT_AUDIO_BUFFER_BYTES = SCRIPT_AUDIO_BUFFER_SAMPLES * sizeof(int16_t);
QByteArray avatarPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeAvatarData); QByteArray avatarPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::AvatarData);
avatarPacket.append(_avatarData->toByteArray()); avatarPacket.append(_avatarData->toByteArray());
nodeList->broadcastToNodes(avatarPacket, NodeSet() << NodeType::AvatarMixer); nodeList->broadcastToNodes(avatarPacket, NodeSet() << NodeType::AvatarMixer);
@ -629,8 +629,8 @@ void ScriptEngine::run() {
} }
QByteArray audioPacket = nodeList->byteArrayWithPopulatedHeader(silentFrame QByteArray audioPacket = nodeList->byteArrayWithPopulatedHeader(silentFrame
? PacketTypeSilentAudioFrame ? PacketType::SilentAudioFrame
: PacketTypeMicrophoneAudioNoEcho); : PacketType::MicrophoneAudioNoEcho);
QDataStream packetStream(&audioPacket, QIODevice::Append); QDataStream packetStream(&audioPacket, QIODevice::Append);