handle replicated bulk avatar data packets

assignment-client/src/avatars/AvatarMixer.cpp

@@ -59,6 +59,8 @@ AvatarMixer::AvatarMixer(ReceivedMessage& message) :
         PacketType::ReplicatedKillAvatar
     }, this, "handleReplicatedPackets");
 
+    packetReceiver.registerListener(PacketType::ReplicatedBulkAvatarData, this, "handleReplicatedBulkAvatarPacket");
+
     auto nodeList = DependencyManager::get<NodeList>();
     connect(nodeList.data(), &NodeList::packetVersionMismatch, this, &AvatarMixer::handlePacketVersionMismatch);
 }
@@ -91,6 +93,41 @@ void AvatarMixer::handleReplicatedPackets(QSharedPointer<ReceivedMessage> messag
 
 }
 
+void AvatarMixer::handleReplicatedBulkAvatarPacket(QSharedPointer<ReceivedMessage> message) {
+    auto nodeList = DependencyManager::get<NodeList>();
+
+    while (message->getBytesLeftToRead()) {
+        // first, grab the node ID for this replicated avatar
+        auto nodeID = QUuid::fromRfc4122(message->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
+
+        // make sure we have an upstream replicated node that matches
+        auto replicatedNode = nodeList->addOrUpdateNode(nodeID, NodeType::Agent,
+                                                        message->getSenderSockAddr(), message->getSenderSockAddr(),
+                                                        DEFAULT_AGENT_PERMISSIONS, true);
+
+        replicatedNode->setLastHeardMicrostamp(usecTimestampNow());
+        replicatedNode->setIsUpstream(true);
+
+        // grab the size of the avatar byte array so we know how much to read
+        quint16 avatarByteArraySize;
+        message->readPrimitive(&avatarByteArraySize);
+
+        // read the avatar byte array
+        auto avatarByteArray = message->read(avatarByteArraySize);
+
+        // construct a "fake" avatar data received message from the byte array and packet list information
+        auto replicatedMessage = QSharedPointer<ReceivedMessage>::create(avatarByteArray, PacketType::AvatarData,
+                                                                         versionForPacketType(PacketType::AvatarData),
+                                                                         message->getSenderSockAddr(), nodeID);
+
+        // queue up the replicated avatar data with the client data for the replicated node
+        auto start = usecTimestampNow();
+        getOrCreateClientData(replicatedNode)->queuePacket(replicatedMessage, replicatedNode);
+        auto end = usecTimestampNow();
+        _queueIncomingPacketElapsedTime += (end - start);
+    }
+}
+
 void AvatarMixer::optionallyReplicatePacket(ReceivedMessage& message, const Node& node) {
     // first, make sure that this is a packet from a node we are supposed to replicate
     if (node.isReplicated()

assignment-client/src/avatars/AvatarMixer.h

@@ -47,6 +47,7 @@ private slots:
     void handleRadiusIgnoreRequestPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode);
     void handleRequestsDomainListDataPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleReplicatedPackets(QSharedPointer<ReceivedMessage> message);
+    void handleReplicatedBulkAvatarPacket(QSharedPointer<ReceivedMessage> message);
     void domainSettingsRequestComplete();
     void handlePacketVersionMismatch(PacketType type, const HifiSockAddr& senderSockAddr, const QUuid& senderUUID);
     void start();

assignment-client/src/avatars/AvatarMixerSlave.cpp

@@ -452,9 +452,11 @@ void AvatarMixerSlave::broadcastAvatarDataToDownstreamMixer(const SharedNodePoin
             // so we always send a full update for this avatar
             quint64 start = usecTimestampNow();
             AvatarDataPacket::HasFlags flagsOut;
-            QByteArray avatarByteArray = otherAvatar->toByteArray(AvatarData::SendAllData, 0, {},
+
-                                                                  flagsOut, false, false,
+            QVector<JointData> emptyLastJointSendData { otherAvatar->getJointCount() };
-                                                                  glm::vec3(0), nullptr);
+
+            QByteArray avatarByteArray = otherAvatar->toByteArray(AvatarData::SendAllData, 0, emptyLastJointSendData,
+                                                                  flagsOut, false, false, glm::vec3(0), nullptr);
             quint64 end = usecTimestampNow();
             _stats.toByteArrayElapsedTime += (end - start);
 
@@ -477,17 +479,15 @@ void AvatarMixerSlave::broadcastAvatarDataToDownstreamMixer(const SharedNodePoin
                 qCWarning(avatars) << "Replicated avatar data too large for" << otherAvatar->getSessionUUID()
                     << "-" << avatarByteArray.size() << "bytes";
 
-                avatarByteArray = otherAvatar->toByteArray(AvatarData::SendAllData, 0, {},
+                avatarByteArray = otherAvatar->toByteArray(AvatarData::SendAllData, 0, emptyLastJointSendData,
-                                                           flagsOut, true, false,
+                                                           flagsOut, true, false, glm::vec3(0), nullptr);
-                                                           glm::vec3(0), nullptr);
 
                 if (avatarByteArray.size() > maxAvatarByteArraySize) {
                     qCWarning(avatars) << "Replicated avatar data without facial data still too large for"
                         << otherAvatar->getSessionUUID() << "-" << avatarByteArray.size() << "bytes";
 
-                    avatarByteArray = otherAvatar->toByteArray(AvatarData::MinimumData, 0, {},
+                    avatarByteArray = otherAvatar->toByteArray(AvatarData::MinimumData, 0, emptyLastJointSendData,
-                                                               flagsOut, true, false,
+                                                               flagsOut, true, false, glm::vec3(0), nullptr);
-                                                               glm::vec3(0), nullptr);
                 }
             }
 

libraries/networking/src/ReceivedMessage.cpp

@@ -42,6 +42,20 @@ ReceivedMessage::ReceivedMessage(NLPacket& packet)
 {
 }
 
+ReceivedMessage::ReceivedMessage(QByteArray byteArray, PacketType packetType, PacketVersion packetVersion,
+                const HifiSockAddr& senderSockAddr, QUuid sourceID) :
+    _data(byteArray),
+    _headData(_data.mid(0, HEAD_DATA_SIZE)),
+    _numPackets(1),
+    _sourceID(sourceID),
+    _packetType(packetType),
+    _packetVersion(packetVersion),
+    _senderSockAddr(senderSockAddr),
+    _isComplete(true)
+{
+
+}
+
 void ReceivedMessage::setFailed() {
     _failed = true;
     _isComplete = true;

libraries/networking/src/ReceivedMessage.h

@@ -24,6 +24,8 @@ class ReceivedMessage : public QObject {
 public:
     ReceivedMessage(const NLPacketList& packetList);
     ReceivedMessage(NLPacket& packet);
+    ReceivedMessage(QByteArray byteArray, PacketType packetType, PacketVersion packetVersion,
+                    const HifiSockAddr& senderSockAddr, QUuid sourceID = QUuid());
 
     QByteArray getMessage() const { return _data; }
     const char* getRawMessage() const { return _data.constData(); }