Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-14 11:46:34 +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)) {
PacketType::Value datagramPacketType = packetTypeForPacket(receivedPacket);
if (datagramPacketType == PacketTypeJurisdiction) {
if (datagramPacketType == PacketType::Jurisdiction) {
int headerBytes = numBytesForPacketHeader(receivedPacket);
SharedNodePointer matchedNode = nodeList->sendingNodeForPacket(receivedPacket);
@ -73,9 +73,9 @@ void Agent::readPendingDatagrams() {
}
}
} else if (datagramPacketType == PacketTypeOctreeStats
|| datagramPacketType == PacketTypeEntityData
|| datagramPacketType == PacketTypeEntityErase
} 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);
@ -84,7 +84,7 @@ void Agent::readPendingDatagrams() {
QByteArray mutablePacket = receivedPacket;
int messageLength = mutablePacket.size();
if (datagramPacketType == PacketTypeOctreeStats) {
if (datagramPacketType == PacketType::OctreeStats) {
int statsMessageLength = OctreeHeadlessViewer::parseOctreeStats(mutablePacket, sourceNode);
if (messageLength > statsMessageLength) {
@ -103,11 +103,11 @@ void Agent::readPendingDatagrams() {
datagramPacketType = packetTypeForPacket(mutablePacket);
} // fall through to piggyback message
if (datagramPacketType == PacketTypeEntityData || datagramPacketType == PacketTypeEntityErase) {
if (datagramPacketType == PacketType::EntityData || datagramPacketType == PacketType::EntityErase) {
_entityViewer.processDatagram(mutablePacket, sourceNode);
}
} else if (datagramPacketType == PacketTypeMixedAudio || datagramPacketType == PacketTypeSilentAudioFrame) {
} else if (datagramPacketType == PacketType::MixedAudio || datagramPacketType == PacketType::SilentAudioFrame) {
_receivedAudioStream.parseData(receivedPacket);
@ -118,10 +118,10 @@ void Agent::readPendingDatagrams() {
// let this continue through to the NodeList so it updates last heard timestamp
// for the sending audio mixer
DependencyManager::get<NodeList>()->processNodeData(senderSockAddr, receivedPacket);
} else if (datagramPacketType == PacketTypeBulkAvatarData
|| datagramPacketType == PacketTypeAvatarIdentity
|| datagramPacketType == PacketTypeAvatarBillboard
|| datagramPacketType == PacketTypeKillAvatar) {
} else if (datagramPacketType == PacketType::BulkAvatarData
|| datagramPacketType == PacketType::AvatarIdentity
|| datagramPacketType == PacketType::AvatarBillboard
|| datagramPacketType == PacketType::KillAvatar) {
// let the avatar hash map process it
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());
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
_currentAssignment = AssignmentFactory::unpackAssignment(receivedPacket);
@ -271,10 +271,10 @@ void AssignmentClient::readPendingDatagrams() {
} else {
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 ||
senderSockAddr.getAddress() == QHostAddress::LocalHostIPv6) {
qDebug() << "AssignmentClientMonitor at" << senderSockAddr << "requested stop via PacketTypeStopNode.";
qDebug() << "AssignmentClientMonitor at" << senderSockAddr << "requested stop via PacketType::StopNode.";
QCoreApplication::quit();
} else {

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

@ -214,7 +214,7 @@ void AssignmentClientMonitor::readPendingDatagrams() {
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
if (packetTypeForPacket(receivedPacket) == PacketTypeNodeJsonStats) {
if (packetTypeForPacket(receivedPacket) == PacketType::NodeJsonStats) {
QUuid packetUUID = uuidFromPacketHeader(receivedPacket);
SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket);
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)) {
// pull any new audio data from nodes off of the network stack
PacketType::Value mixerPacketType = packetTypeForPacket(receivedPacket);
if (mixerPacketType == PacketTypeMicrophoneAudioNoEcho
|| mixerPacketType == PacketTypeMicrophoneAudioWithEcho
|| mixerPacketType == PacketTypeInjectAudio
|| mixerPacketType == PacketTypeSilentAudioFrame
|| mixerPacketType == PacketTypeAudioStreamStats) {
if (mixerPacketType == PacketType::MicrophoneAudioNoEcho
|| mixerPacketType == PacketType::MicrophoneAudioWithEcho
|| mixerPacketType == PacketType::InjectAudio
|| mixerPacketType == PacketType::SilentAudioFrame
|| mixerPacketType == PacketType::AudioStreamStats) {
nodeList->findNodeAndUpdateWithDataFromPacket(receivedPacket);
} else if (mixerPacketType == PacketTypeMuteEnvironment) {
} else if (mixerPacketType == PacketType::MuteEnvironment) {
SharedNodePointer sendingNode = nodeList->sendingNodeForPacket(receivedPacket);
if (sendingNode->getCanAdjustLocks()) {
QByteArray packet = receivedPacket;
nodeList->populatePacketHeader(packet, PacketTypeMuteEnvironment);
nodeList->populatePacketHeader(packet, PacketType::MuteEnvironment);
nodeList->eachNode([&](const SharedNodePointer& node){
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) {
PacketType::Value packetType = packetTypeForPacket(packet);
if (packetType == PacketTypeAudioStreamStats) {
if (packetType == PacketType::AudioStreamStats) {
const char* dataAt = packet.data();
@ -67,9 +67,9 @@ int AudioMixerClientData::parseData(const QByteArray& packet) {
} else {
PositionalAudioStream* matchingStream = NULL;
if (packetType == PacketTypeMicrophoneAudioWithEcho
|| packetType == PacketTypeMicrophoneAudioNoEcho
|| packetType == PacketTypeSilentAudioFrame) {
if (packetType == PacketType::MicrophoneAudioWithEcho
|| packetType == PacketType::MicrophoneAudioNoEcho
|| packetType == PacketType::SilentAudioFrame) {
QUuid nullUUID = QUuid();
if (!_audioStreams.contains(nullUUID)) {
@ -84,7 +84,7 @@ int AudioMixerClientData::parseData(const QByteArray& packet) {
} else {
matchingStream = _audioStreams.value(nullUUID);
}
} else if (packetType == PacketTypeInjectAudio) {
} else if (packetType == PacketType::InjectAudio) {
// this is 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 readBytes = 0;
if (type == PacketTypeSilentAudioFrame) {
if (type == PacketType::SilentAudioFrame) {
const char* dataAt = packetAfterSeqNum.constData();
quint16 numSilentSamples = *(reinterpret_cast<const quint16*>(dataAt));
readBytes += sizeof(quint16);
@ -31,7 +31,7 @@ int AvatarAudioStream::parseStreamProperties(PacketType::Value type, const QByte
readBytes += parsePositionalData(packetAfterSeqNum.mid(readBytes));
} else {
_shouldLoopbackForNode = (type == PacketTypeMicrophoneAudioWithEcho);
_shouldLoopbackForNode = (type == PacketType::MicrophoneAudioWithEcho);
// read the channel flag
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 lastSeqFromSender = otherNode->getLastSequenceNumberForPacketType(PacketType::AvatarData);
PacketSequenceNumber lastSeqFromSender = otherNode->getLastSequenceNumberForPacketType::(PacketType::AvatarData);
if (lastSeqToReceiver > lastSeqFromSender) {
// 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
nodeData->setLastBroadcastSequenceNumber(otherNode->getUUID(),
otherNode->getLastSequenceNumberForPacketType(PacketType::AvatarData));
otherNode->getLastSequenceNumberForPacketType::(PacketType::AvatarData));
// start a new segment in the PacketList for this avatar
avatarPacketList.startSegment();
@ -399,11 +399,11 @@ void AvatarMixer::readPendingDatagrams() {
while (readAvailableDatagram(receivedPacket, senderSockAddr)) {
if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
switch (packetTypeForPacket(receivedPacket)) {
case PacketTypeAvatarData: {
case PacketType::AvatarData: {
nodeList->findNodeAndUpdateWithDataFromPacket(receivedPacket);
break;
}
case PacketTypeAvatarIdentity: {
case PacketType::AvatarIdentity: {
// check if we have a matching node in our list
SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket);
@ -420,7 +420,7 @@ void AvatarMixer::readPendingDatagrams() {
}
break;
}
case PacketTypeAvatarBillboard: {
case PacketType::AvatarBillboard: {
// check if we have a matching node in our list
SharedNodePointer avatarNode = nodeList->sendingNodeForPacket(receivedPacket);
@ -438,7 +438,7 @@ void AvatarMixer::readPendingDatagrams() {
}
break;
}
case PacketTypeKillAvatar: {
case PacketType::KillAvatar: {
nodeList->processKillNode(receivedPacket);
break;
}

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

@ -22,7 +22,7 @@ public:
OctreeQueryNode(),
_lastDeletedEntitiesSentAt(0) { }
virtual PacketType::Value getMyPacketType() const { return PacketTypeEntityData; }
virtual PacketType::Value getMyPacketType() const { return PacketType::EntityData; }
quint64 getLastDeletedEntitiesSentAt() const { return _lastDeletedEntitiesSentAt; }
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
virtual OctreeQueryNode* createOctreeQueryNode();
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* getMyLoggingServerTargetName() const { return MODEL_SERVER_LOGGING_TARGET_NAME; }
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"); }
// 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);
}
}
} else if (packetType == PacketTypeOctreeDataNack) {
} else if (packetType == PacketType::OctreeDataNack) {
// 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.
if (matchingNode) {
@ -884,7 +884,7 @@ void OctreeServer::readPendingDatagram(const QByteArray& receivedPacket, const H
nodeData->parseNackPacket(receivedPacket);
}
}
} else if (packetType == PacketTypeJurisdictionRequest) {
} else if (packetType == PacketType::JurisdictionRequest) {
_jurisdictionSender->queueReceivedPacket(matchingNode, receivedPacket);
} else if (_octreeInboundPacketProcessor && getOctree()->handlesEditPacketType(packetType)) {
_octreeInboundPacketProcessor->queueReceivedPacket(matchingNode, receivedPacket);

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

@ -44,7 +44,7 @@ void OctreeServerDatagramProcessor::readPendingDatagrams() {
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
PacketType::Value packetType = packetTypeForPacket(incomingPacket);
if (packetType == PacketTypePing) {
if (packetType == PacketType::Ping) {
DependencyManager::get<NodeList>()->processNodeData(senderSockAddr, incomingPacket);
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);
// reply back to the user with a PacketTypeDomainList
// reply back to the user with a PacketType::DomainList
sendDomainListToNode(newNode, senderSockAddr, nodeInterestList.toSet());
// send out this node to our other connected nodes
@ -1002,7 +1002,7 @@ void DomainServer::broadcastNewNode(const SharedNodePointer& addedNode) {
auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
// setup the add packet for this new node
QByteArray addNodePacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeDomainServerAddedNode);
QByteArray addNodePacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketType::DomainServerAddedNode);
QDataStream addNodeStream(&addNodePacket, QIODevice::Append);
addNodeStream << *addedNode.data();
@ -1037,14 +1037,14 @@ void DomainServer::readAvailableDatagrams() {
HifiSockAddr senderSockAddr;
QByteArray receivedPacket;
static QByteArray assignmentPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeCreateAssignment);
static QByteArray assignmentPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketType::CreateAssignment);
static int numAssignmentPacketHeaderBytes = assignmentPacket.size();
while (limitedNodeList->getNodeSocket().hasPendingDatagrams()) {
receivedPacket.resize(limitedNodeList->getNodeSocket().pendingDatagramSize());
limitedNodeList->getNodeSocket().readDatagram(receivedPacket.data(), receivedPacket.size(),
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer());
if (packetTypeForPacket(receivedPacket) == PacketTypeRequestAssignment
if (packetTypeForPacket(receivedPacket) == PacketType::RequestAssignment
&& limitedNodeList->packetVersionAndHashMatch(receivedPacket)) {
// construct the requested assignment from the packet data
@ -1108,8 +1108,8 @@ void DomainServer::readAvailableDatagrams() {
processDatagram(receivedPacket, senderSockAddr);
} else {
// we're using DTLS, so tell the sender to get back to us using DTLS
static QByteArray dtlsRequiredPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeDomainServerRequireDTLS);
static int numBytesDTLSHeader = numBytesForPacketHeaderGivenPacketType(PacketTypeDomainServerRequireDTLS);
static QByteArray dtlsRequiredPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketType::DomainServerRequireDTLS);
static int numBytesDTLSHeader = numBytesForPacketHeaderGivenPacketType::(PacketTypeDomainServerRequireDTLS);
if (dtlsRequiredPacket.size() == numBytesDTLSHeader) {
// 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)) {
PacketType::Value requestType = packetTypeForPacket(receivedPacket);
switch (requestType) {
case PacketTypeDomainConnectRequest:
case PacketType::DomainConnectRequest:
handleConnectRequest(receivedPacket, senderSockAddr);
break;
case PacketTypeDomainListRequest: {
case PacketType::DomainListRequest: {
QUuid nodeUUID = uuidFromPacketHeader(receivedPacket);
if (!nodeUUID.isNull() && nodeList->nodeWithUUID(nodeUUID)) {
@ -1422,12 +1422,12 @@ void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiS
break;
}
case PacketTypeDomainServerPathQuery: {
case PacketType::DomainServerPathQuery: {
// have our private method attempt to respond to this path query
respondToPathQuery(receivedPacket, senderSockAddr);
break;
}
case PacketTypeNodeJsonStats: {
case PacketType::NodeJsonStats: {
SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket);
if (matchingNode) {
reinterpret_cast<DomainServerNodeData*>(matchingNode->getLinkedData())->parseJSONStatsPacket(receivedPacket);
@ -1435,16 +1435,16 @@ void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiS
break;
}
case PacketTypeStunResponse:
case PacketType::StunResponse:
nodeList->processSTUNResponse(receivedPacket);
break;
case PacketTypeUnverifiedPing: {
case PacketType::UnverifiedPing: {
QByteArray pingReplyPacket = nodeList->constructPingReplyPacket(receivedPacket);
nodeList->writeUnverifiedDatagram(pingReplyPacket, senderSockAddr);
break;
}
case PacketTypeUnverifiedPingReply: {
case PacketType::UnverifiedPingReply: {
processICEPingReply(receivedPacket, senderSockAddr);
break;
}
@ -2225,7 +2225,7 @@ void DomainServer::respondToPathQuery(const QByteArray& receivedPacket, const Hi
// this is a query for the viewpoint resulting from a path
// first pull the query path from the packet
int numHeaderBytes = numBytesForPacketHeaderGivenPacketType(PacketTypeDomainServerPathQuery);
int numHeaderBytes = numBytesForPacketHeaderGivenPacketType::(PacketTypeDomainServerPathQuery);
const char* packetDataStart = receivedPacket.data() + numHeaderBytes;
// 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();
// 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
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);
if (packetType == PacketTypeIceServerHeartbeat) {
if (packetType == PacketType::IceServerHeartbeat) {
SharedNetworkPeer peer = addOrUpdateHeartbeatingPeer(incomingPacket);
// so that we can send packets to the heartbeating peer when we need, we need to activate a socket now
peer->activateMatchingOrNewSymmetricSocket(sendingSockAddr);
} else if (packetType == PacketTypeIceServerQuery) {
} else if (packetType == PacketType::IceServerQuery) {
QDataStream heartbeatStream(incomingPacket);
// 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;
if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) {
queryOctree(NodeType::EntityServer, PacketTypeEntityQuery, _entityServerJurisdictions);
queryOctree(NodeType::EntityServer, PacketType::EntityQuery, _entityServerJurisdictions);
}
_lastQueriedViewFrustum = _viewFrustum;
}

44
interface/src/DatagramProcessor.cpp
View file

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

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

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

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

@ -1078,7 +1078,7 @@ void AvatarData::setJointMappingsFromNetworkReply() {
void AvatarData::sendAvatarDataPacket() {
auto nodeList = DependencyManager::get<NodeList>();
QByteArray dataPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeAvatarData);
QByteArray dataPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::AvatarData);
dataPacket.append(toByteArray());
nodeList->broadcastToNodes(dataPacket, NodeSet() << NodeType::AvatarMixer);
@ -1087,7 +1087,7 @@ void AvatarData::sendAvatarDataPacket() {
void AvatarData::sendIdentityPacket() {
auto nodeList = DependencyManager::get<NodeList>();
QByteArray identityPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeAvatarIdentity);
QByteArray identityPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::AvatarIdentity);
identityPacket.append(identityByteArray());
nodeList->broadcastToNodes(identityPacket, NodeSet() << NodeType::AvatarMixer);
@ -1097,7 +1097,7 @@ void AvatarData::sendBillboardPacket() {
if (!_billboard.isEmpty()) {
auto nodeList = DependencyManager::get<NodeList>();
QByteArray billboardPacket = nodeList->byteArrayWithPopulatedHeader(PacketTypeAvatarBillboard);
QByteArray billboardPacket = nodeList->byteArrayWithPopulatedHeader(PacketType::AvatarBillboard);
billboardPacket.append(_billboard);
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) {
switch (packetTypeForPacket(datagram)) {
case PacketTypeBulkAvatarData:
case PacketType::BulkAvatarData:
processAvatarDataPacket(datagram, mixerWeakPointer);
break;
case PacketTypeAvatarIdentity:
case PacketType::AvatarIdentity:
processAvatarIdentityPacket(datagram, mixerWeakPointer);
break;
case PacketTypeAvatarBillboard:
case PacketType::AvatarBillboard:
processAvatarBillboardPacket(datagram, mixerWeakPointer);
break;
case PacketTypeKillAvatar:
case PacketType::KillAvatar:
processKillAvatar(datagram);
break;
default:

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

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

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

@ -21,7 +21,7 @@
void EntityEditPacketSender::adjustEditPacketForClockSkew(PacketType::Value type,
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);
}
}
@ -54,6 +54,6 @@ void EntityEditPacketSender::queueEraseEntityMessage(const EntityItemID& entityI
unsigned char bufferOut[MAX_PACKET_SIZE];
size_t sizeOut = 0;
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
if (success) {
queueEntityMessage(PacketTypeEntityAdd, id, propertiesWithSimID);
queueEntityMessage(PacketType::EntityAdd, id, propertiesWithSimID);
}
return id;
@ -175,13 +175,13 @@ QUuid EntityScriptingInterface::editEntity(QUuid id, EntityItemProperties proper
entity->setLastBroadcast(usecTimestampNow());
}
_entityTree->unlock();
queueEntityMessage(PacketTypeEntityEdit, entityID, properties);
queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return id;
}
return QUuid();
}
queueEntityMessage(PacketTypeEntityEdit, entityID, properties);
queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return id;
}
@ -446,7 +446,7 @@ bool EntityScriptingInterface::setVoxels(QUuid entityID,
properties.setVoxelDataDirty();
properties.setLastEdited(now);
queueEntityMessage(PacketTypeEntityEdit, entityID, properties);
queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return true;
}
@ -483,7 +483,7 @@ bool EntityScriptingInterface::setPoints(QUuid entityID, std::function<bool(Line
properties.setLastEdited(now);
queueEntityMessage(PacketTypeEntityEdit, entityID, properties);
queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return success;
}
@ -552,7 +552,7 @@ bool EntityScriptingInterface::actionWorker(const QUuid& entityID,
properties.setActionDataDirty();
auto now = usecTimestampNow();
properties.setLastEdited(now);
queueEntityMessage(PacketTypeEntityEdit, entityID, properties);
queueEntityMessage(PacketType::EntityEdit, entityID, properties);
return success;
}

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

@ -63,12 +63,12 @@ void EntityTree::eraseAllOctreeElements(bool 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
switch (packetType) {
case PacketTypeEntityAdd:
case PacketTypeEntityEdit:
case PacketTypeEntityErase:
case PacketType::EntityAdd:
case PacketType::EntityEdit:
case PacketType::EntityErase:
return true;
default:
return false;
@ -583,14 +583,14 @@ int EntityTree::processEditPacketData(PacketType::Value packetType, const unsign
int processedBytes = 0;
// we handle these types of "edit" packets
switch (packetType) {
case PacketTypeEntityErase: {
case PacketType::EntityErase: {
QByteArray dataByteArray((const char*)editData, maxLength);
processedBytes = processEraseMessageDetails(dataByteArray, senderNode);
break;
}
case PacketTypeEntityAdd:
case PacketTypeEntityEdit: {
case PacketType::EntityAdd:
case PacketType::EntityEdit: {
quint64 startDecode = 0, endDecode = 0;
quint64 startLookup = 0, endLookup = 0;
quint64 startUpdate = 0, endUpdate = 0;
@ -613,7 +613,7 @@ int EntityTree::processEditPacketData(PacketType::Value packetType, const unsign
startLookup = usecTimestampNow();
EntityItemPointer existingEntity = findEntityByEntityItemID(entityItemID);
endLookup = usecTimestampNow();
if (existingEntity && packetType == PacketTypeEntityEdit) {
if (existingEntity && packetType == PacketType::EntityEdit) {
// if the EntityItem exists, then update it
startLogging = usecTimestampNow();
if (wantEditLogging()) {
@ -627,7 +627,7 @@ int EntityTree::processEditPacketData(PacketType::Value packetType, const unsign
existingEntity->markAsChangedOnServer();
endUpdate = usecTimestampNow();
_totalUpdates++;
} else if (packetType == PacketTypeEntityAdd) {
} else if (packetType == PacketType::EntityAdd) {
if (senderNode->getCanRez()) {
// this is a new entity... assign a new entityID
properties.setCreated(properties.getLastEdited());
@ -766,7 +766,7 @@ bool EntityTree::encodeEntitiesDeletedSince(OCTREE_PACKET_SEQUENCE sequenceNumbe
unsigned char* copyAt = outputBuffer;
size_t numBytesPacketHeader = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(outputBuffer),
PacketTypeEntityErase);
PacketType::EntityErase);
copyAt += 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
// 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)
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
// own definition. Implement these to allow your octree based server to support editing
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
{ 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,
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 char getMyNodeType() const { return NodeType::EntityServer; }
virtual PacketType::Value getMyQueryMessageType() const { return PacketTypeEntityQuery; }
virtual PacketType::Value getExpectedPacketType() const { return PacketTypeEntityData; }
virtual PacketType::Value getMyQueryMessageType() const { return PacketType::EntityQuery; }
virtual PacketType::Value getExpectedPacketType() const { return PacketType::EntityData; }
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) {
// 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
// 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
sendPacket(std::move(pathQueryPacket), _domainHandler.getSockAddr());
} 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.";
}
}

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

@ -13,7 +13,7 @@
EditPacketBuffer::EditPacketBuffer() :
_nodeUUID(),
_currentType(PacketTypeUnknown),
_currentType(PacketType::Unknown),
_currentSize(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) {
if (packetTypeForPacket(packet) == PacketTypeJurisdiction && sendingNode) {
if (packetTypeForPacket(packet) == PacketType::Jurisdiction && sendingNode) {
QUuid nodeUUID = sendingNode->getUUID();
JurisdictionMap map;
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"
/// 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
/// 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
/// 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()
class JurisdictionListener : public ReceivedPacketProcessor {
@ -45,7 +45,7 @@ public slots:
void nodeKilled(SharedNodePointer node);
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
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;
int headerLength = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(destinationBuffer),
PacketTypeJurisdiction);
PacketType::Jurisdiction);
destinationBuffer += headerLength;
// Pack the Node Type in first byte
@ -291,7 +291,7 @@ int JurisdictionMap::packIntoMessage(unsigned char* destinationBuffer, int avail
unsigned char* bufferStart = destinationBuffer;
int headerLength = DependencyManager::get<NodeList>()->populatePacketHeader(reinterpret_cast<char*>(destinationBuffer),
PacketTypeJurisdiction);
PacketType::Jurisdiction);
destinationBuffer += headerLength;
// 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) {
if (packetTypeForPacket(packet) == PacketTypeJurisdictionRequest) {
if (packetTypeForPacket(packet) == PacketType::JurisdictionRequest) {
if (sendingNode) {
lockRequestingNodes();
_nodesRequestingJurisdictions.push(sendingNode->getUUID());

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

@ -19,7 +19,7 @@
#include <ReceivedPacketProcessor.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
/// and adding them to the processing queue by calling queueReceivedPacket()
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->ungetChar(firstChar);
if (firstChar == (char) PacketTypeEntityData) {
if (firstChar == (char) PacketType::EntityData) {
qCDebug(octree) << "Reading from SVO Stream length:" << streamLength;
return readSVOFromStream(streamLength, inputStream);
} 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
// own definition. Implement these to allow your octree based server to support editing
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 {
return thisVersion == 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();
bool isMyJurisdiction = true;
if (type == PacketTypeEntityErase) {
if (type == PacketType::EntityErase) {
isMyJurisdiction = true; // send erase messages to all servers
} else if (_serverJurisdictions) {
// we need to get the jurisdiction for this
@ -318,11 +318,11 @@ void OctreeEditPacketSender::releaseQueuedMessages() {
void OctreeEditPacketSender::releaseQueuedPacket(EditPacketBuffer& packetBuffer) {
_releaseQueuedPacketMutex.lock();
if (packetBuffer._currentSize > 0 && packetBuffer._currentType != PacketTypeUnknown) {
if (packetBuffer._currentSize > 0 && packetBuffer._currentType != PacketType::Unknown) {
queuePacketToNode(packetBuffer._nodeUUID, &packetBuffer._currentBuffer[0],
packetBuffer._currentSize, packetBuffer._satoshiCost);
packetBuffer._currentSize = 0;
packetBuffer._currentType = PacketTypeUnknown;
packetBuffer._currentType = PacketType::Unknown;
}
_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()...";
#endif
entityPacketSender->queueEditEntityMessage(PacketTypeEntityEdit, id, properties);
entityPacketSender->queueEditEntityMessage(PacketType::EntityEdit, id, properties);
_entity->setLastBroadcast(usecTimestampNow());
} else {
#ifdef WANT_DEBUG

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

@ -587,7 +587,7 @@ void ScriptEngine::run() {
/ (1000 * 1000)) + 0.5);
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());
nodeList->broadcastToNodes(avatarPacket, NodeSet() << NodeType::AvatarMixer);
@ -629,8 +629,8 @@ void ScriptEngine::run() {
}
QByteArray audioPacket = nodeList->byteArrayWithPopulatedHeader(silentFrame
? PacketTypeSilentAudioFrame
: PacketTypeMicrophoneAudioNoEcho);
? PacketType::SilentAudioFrame
: PacketType::MicrophoneAudioNoEcho);
QDataStream packetStream(&audioPacket, QIODevice::Append);