move face/skeleton model URLs to AvatarData

assignment-client/src/avatars/AvatarMixer.cpp

@@ -102,12 +102,10 @@ void broadcastIdentityPacket() {
     
     foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
         if (node->getLinkedData() && node->getType() == NodeType::Agent) {
-            QByteArray individualData;
-            QDataStream individualDataStream(&individualData, QIODevice::Append);
             
             AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData());
-            
+            QByteArray individualData = nodeData->identityByteArray();
-            individualDataStream << node->getUUID() << nodeData->getFaceModelURL() << nodeData->getSkeletonURL();
+            individualData.replace(0, NUM_BYTES_RFC4122_UUID, node->getUUID().toRfc4122());
             
             if (avatarIdentityPacket.size() + individualData.size() > MAX_PACKET_SIZE) {
                 // we've hit MTU, send out the current packet before appending
@@ -119,7 +117,7 @@ void broadcastIdentityPacket() {
             avatarIdentityPacket.append(individualData);
             
             // re-set the bool in AvatarMixerClientData so a change between key frames gets sent out
-            nodeData->setHasSentPacketBetweenKeyFrames(false);
+            nodeData->setHasSentIdentityBetweenKeyFrames(false);
         }
     }
     
@@ -168,11 +166,12 @@ void AvatarMixer::processDatagram(const QByteArray& dataByteArray, const HifiSoc
             
             if (avatarNode && avatarNode->getLinkedData()) {
                 AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(avatarNode->getLinkedData());
-                if (nodeData->shouldSendIdentityPacketAfterParsing(dataByteArray)) {
+                if (nodeData->hasIdentityChangedAfterParsing(dataByteArray)
+                    && !nodeData->hasSentIdentityBetweenKeyFrames()) {
                     // this avatar changed their identity in some way and we haven't sent a packet in this keyframe
                     QByteArray identityPacket = byteArrayWithPopluatedHeader(PacketTypeAvatarIdentity);
-                    QDataStream identityStream(&identityPacket, QIODevice::Append);
+                    identityPacket.append(nodeData->identityByteArray());
-                    identityStream << avatarNode->getUUID() << nodeData->getFaceModelURL() << nodeData->getSkeletonURL();
+                    nodeList->broadcastToNodes(identityPacket, NodeSet() << NodeType::Agent);
                 }
             }
         }

assignment-client/src/avatars/AvatarMixerClientData.cpp

@@ -9,30 +9,7 @@
 #include "AvatarMixerClientData.h"
 
 AvatarMixerClientData::AvatarMixerClientData() :
-    _faceModelURL(),
+    _hasSentIdentityBetweenKeyFrames(false)
-    _skeletonURL()
 {
     
 }
-
-bool AvatarMixerClientData::shouldSendIdentityPacketAfterParsing(const QByteArray &packet) {
-    QDataStream packetStream(packet);
-    packetStream.skipRawData(numBytesForPacketHeader(packet));
-    
-    QUrl faceModelURL, skeletonURL;
-    packetStream >> faceModelURL >> skeletonURL;
-    
-    bool hasIdentityChanged = false;
-    
-    if (faceModelURL != _faceModelURL) {
-        _faceModelURL = faceModelURL;
-        hasIdentityChanged = true;
-    }
-    
-    if (skeletonURL != _skeletonURL) {
-        _skeletonURL = skeletonURL;
-        hasIdentityChanged = true;
-    }
-    
-    return hasIdentityChanged && !_hasSentPacketBetweenKeyFrames;
-}

assignment-client/src/avatars/AvatarMixerClientData.h

@@ -17,20 +17,12 @@ class AvatarMixerClientData : public AvatarData {
 public:
     AvatarMixerClientData();
     
-    const QUrl& getFaceModelURL() const { return _faceModelURL; }
+    bool hasSentIdentityBetweenKeyFrames() const { return _hasSentIdentityBetweenKeyFrames; }
-    void setFaceModelURL(const QUrl& faceModelURL) { _faceModelURL = faceModelURL; }
+    void setHasSentIdentityBetweenKeyFrames(bool hasSentIdentityBetweenKeyFrames)
-    
+        { _hasSentIdentityBetweenKeyFrames = hasSentIdentityBetweenKeyFrames; }
-    const QUrl& getSkeletonURL() const { return _skeletonURL; }
-    void setSkeletonURL(const QUrl& skeletonURL) { _skeletonURL = skeletonURL; }
-    
-    void setHasSentPacketBetweenKeyFrames(bool hasSentPacketBetweenKeyFrames)
-        { _hasSentPacketBetweenKeyFrames = hasSentPacketBetweenKeyFrames; }
-    
-    bool shouldSendIdentityPacketAfterParsing(const QByteArray& packet);
 private:
-    QUrl _faceModelURL;
+   
-    QUrl _skeletonURL;
+    bool _hasSentIdentityBetweenKeyFrames;
-    bool _hasSentPacketBetweenKeyFrames;
 };
 
 #endif /* defined(__hifi__AvatarMixerClientData__) */

interface/src/avatar/Avatar.cpp

@@ -334,6 +334,16 @@ bool Avatar::findSphereCollision(const glm::vec3& sphereCenter, float sphereRadi
     return false;
 }
 
+void Avatar::setFaceModelURL(const QUrl &faceModelURL) {
+    _faceModelURL = faceModelURL;
+    _head.getFaceModel().setURL(faceModelURL);
+}
+
+void Avatar::setSkeletonURL(const QUrl &skeletonURL) {
+    _skeletonURL = skeletonURL;
+    _skeletonModel.setURL(skeletonURL);
+}
+
 int Avatar::parseData(const QByteArray& packet) {
     // change in position implies movement
     glm::vec3 oldPosition = _position;

interface/src/avatar/Avatar.h

@@ -112,7 +112,10 @@ public:
     virtual bool findSphereCollision(const glm::vec3& sphereCenter, float sphereRadius, CollisionInfo& collision);
     
     virtual bool isMyAvatar() { return false; }
-
+    
+    virtual void setFaceModelURL(const QUrl& faceModelURL);
+    virtual void setSkeletonURL(const QUrl& skeletonURL);
+    
     int parseData(const QByteArray& packet);
 
     static void renderJointConnectingCone(glm::vec3 position1, glm::vec3 position2, float radius1, float radius2);

interface/src/avatar/MyAvatar.cpp

@@ -609,8 +609,8 @@ void MyAvatar::saveData(QSettings* settings) {
     settings->setValue("leanScale", _leanScale);
     settings->setValue("scale", _targetScale);
     
-    settings->setValue("faceModelURL", _head.getFaceModel().getURL());
+    settings->setValue("faceModelURL", _faceModelURL);
-    settings->setValue("skeletonURL", _skeletonModel.getURL());
+    settings->setValue("skeletonURL", _skeletonURL);
 
     settings->endGroup();
 }
@@ -636,8 +636,8 @@ void MyAvatar::loadData(QSettings* settings) {
     setScale(_scale);
     Application::getInstance()->getCamera()->setScale(_scale);
     
-    _head.getFaceModel().setURL(settings->value("faceModelURL").toUrl());
+    setFaceModelURL(settings->value("faceModelURL").toUrl());
-    _skeletonModel.setURL(settings->value("skeletonURL").toUrl());
+    setSkeletonURL(settings->value("skeletonURL").toUrl());
 
     settings->endGroup();
 }
@@ -649,10 +649,7 @@ void MyAvatar::sendKillAvatar() {
 
 void MyAvatar::sendIdentityPacket() {
     QByteArray identityPacket = byteArrayWithPopluatedHeader(PacketTypeAvatarIdentity);
-    QDataStream identityStream(&identityPacket, QIODevice::Append);
+    identityPacket.append(AvatarData::identityByteArray());
-    
-    identityStream << _head.getFaceModel().getURL();
-    identityStream << _skeletonModel.getURL();
     
     NodeList::getInstance()->broadcastToNodes(identityPacket, NodeSet() << NodeType::AvatarMixer);
 }

libraries/avatars/src/AvatarData.cpp

@@ -270,6 +270,38 @@ int AvatarData::parseData(const QByteArray& packet) {
     return sourceBuffer - startPosition;
 }
 
+bool AvatarData::hasIdentityChangedAfterParsing(const QByteArray &packet) {
+    QDataStream packetStream(packet);
+    packetStream.skipRawData(numBytesForPacketHeader(packet));
+    
+    QUuid avatarUUID;
+    QUrl faceModelURL, skeletonURL;
+    packetStream >> avatarUUID >> faceModelURL >> skeletonURL;
+    
+    bool hasIdentityChanged = false;
+    
+    if (faceModelURL != _faceModelURL) {
+        setFaceModelURL(faceModelURL);
+        hasIdentityChanged = true;
+    }
+    
+    if (skeletonURL != _skeletonURL) {
+        setSkeletonURL(skeletonURL);
+        hasIdentityChanged = true;
+    }
+    
+    return hasIdentityChanged;
+}
+
+QByteArray AvatarData::identityByteArray() {
+    QByteArray identityData;
+    QDataStream identityStream(&identityData, QIODevice::Append);
+    
+    identityStream << QUuid() << _faceModelURL << _skeletonURL;
+    
+    return identityData;
+}
+
 void AvatarData::setClampedTargetScale(float targetScale) {
     
     targetScale =  glm::clamp(targetScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE);

libraries/avatars/src/AvatarData.h

@@ -30,6 +30,7 @@ typedef unsigned long long quint64;
 #include <glm/gtc/quaternion.hpp>
 
 #include <QtCore/QObject>
+#include <QtCore/QUrl>
 #include <QtCore/QUuid>
 #include <QtCore/QVariantMap>
 
@@ -142,6 +143,14 @@ public:
         return false;
     }
     
+    bool hasIdentityChangedAfterParsing(const QByteArray& packet);
+    QByteArray identityByteArray();
+    
+    const QUrl& getFaceModelURL() const { return _faceModelURL; }
+    const QUrl& getSkeletonURL() const { return _skeletonURL; }
+    virtual void setFaceModelURL(const QUrl& faceModelURL) { _faceModelURL = faceModelURL; }
+    virtual void setSkeletonURL(const QUrl& skeletonURL) { _skeletonURL = skeletonURL; }
+    
 protected:
     glm::vec3 _position;
     glm::vec3 _handPosition;
@@ -168,6 +177,8 @@ protected:
     HeadData* _headData;
     HandData* _handData;
 
+    QUrl _faceModelURL;
+    QUrl _skeletonURL;
 private:
     // privatize the copy constructor and assignment operator so they cannot be called
     AvatarData(const AvatarData&);