checkpoint

assignment-client/src/avatars/AvatarMixer.cpp

@@ -99,8 +99,6 @@ void AvatarMixer::start() {
 
     auto nodeList = DependencyManager::get<NodeList>();
 
-    //_slavePool.setNumThreads(1); // grins
-
     while (!_isFinished) {
         _numTightLoopFrames++;
         _loopRate.increment();
@@ -122,6 +120,19 @@ void AvatarMixer::start() {
             _processQueuedAvatarDataPacketsElapsedTime += (end - start);
         }
 
+        // process pending display names... this doesn't currently run on multiple threads, because it
+        // side-effects the mixer's data, which is fine because it's a very low cost operation
+        {
+            auto start = usecTimestampNow();
+            nodeList->nestedEach([&](NodeList::const_iterator cbegin, NodeList::const_iterator cend) {
+                std::for_each(cbegin, cend, [&](const SharedNodePointer& node) {
+                    manageDisplayName(node);
+                });
+            });
+            auto end = usecTimestampNow();
+            _displayNameManagementElapsedTime += (end - start);
+        }
+
         // this is where we need to put the real work...
         {
             /*
@@ -152,11 +163,12 @@ void AvatarMixer::start() {
 }
 
 
-void AvatarMixer::manageDisplayName(AvatarMixerClientData* nodeData, const SharedNodePointer& node) {
+// NOTE: nodeData->getAvatar() might be side effected, most be called when access to node/nodeData
-    AvatarData& avatar = nodeData->getAvatar();
+// is guarenteed to not be accessed by other thread
-
+void AvatarMixer::manageDisplayName(const SharedNodePointer& node) {
-    quint64 startDisplayNameManagement = usecTimestampNow();
+    AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData());
-    if (nodeData->getAvatarSessionDisplayNameMustChange()) {
+    if (nodeData && nodeData->getAvatarSessionDisplayNameMustChange()) {
+        AvatarData& avatar = nodeData->getAvatar();
         const QString& existingBaseDisplayName = nodeData->getBaseDisplayName();
         if (--_sessionDisplayNames[existingBaseDisplayName].second <= 0) {
             _sessionDisplayNames.remove(existingBaseDisplayName);
@@ -183,8 +195,6 @@ void AvatarMixer::manageDisplayName(AvatarMixerClientData* nodeData, const Share
         sendIdentityPacket(nodeData, node); // Tell node whose name changed about its new session display name. Others will find out below.
         qDebug() << "Giving session display name" << sessionDisplayName << "to node with ID" << node->getUUID();
     }
-    quint64 endDisplayNameManagement = usecTimestampNow();
-    _displayNameManagementElapsedTime += (endDisplayNameManagement - startDisplayNameManagement);
 }
 
 // NOTE: some additional optimizations to consider.
@@ -367,7 +377,7 @@ void AvatarMixer::broadcastAvatarData() {
             // setup a PacketList for the avatarPackets
             auto avatarPacketList = NLPacketList::create(PacketType::BulkAvatarData);
 
-            manageDisplayName(nodeData, node);
+            //manageDisplayName(node);
 
             // this is an AGENT we have received head data from
             // send back a packet with other active node data to this node
@@ -769,7 +779,6 @@ void AvatarMixer::sendStatsPacket() {
     statsObject["tight_loop_rate"] = _loopRate.rate();
 
     // broadcastAvatarDataElapsed timing details...
-    statsObject["timing_average_a_displayNameManagement"] = (float)_displayNameManagementElapsedTime / (float)_numStatFrames;
     statsObject["timing_average_b_ignoreCalculation"] = (float)_ignoreCalculationElapsedTime / (float)_numStatFrames;
     statsObject["timing_average_c_avatarDataPacking"] = (float)_avatarDataPackingElapsedTime / (float)_numStatFrames;
     statsObject["timing_average_d_packetSending"] = (float)_packetSendingElapsedTime / (float)_numStatFrames;
@@ -782,6 +791,8 @@ void AvatarMixer::sendStatsPacket() {
 
     statsObject["timing_average_y_processEvents"] = TIGHT_LOOP_STAT(_processEventsElapsedTime);
     statsObject["timing_average_y_queueIncomingPacket"] = TIGHT_LOOP_STAT(_queueIncomingPacketElapsedTime);
+
+    statsObject["timing_average_z_displayNameManagement"] = TIGHT_LOOP_STAT(_displayNameManagementElapsedTime);
     statsObject["timing_average_z_handleAvatarDataPacket"] = TIGHT_LOOP_STAT(_handleAvatarDataPacketElapsedTime);
     statsObject["timing_average_z_handleAvatarIdentityPacket"] = TIGHT_LOOP_STAT(_handleAvatarIdentityPacketElapsedTime);
     statsObject["timing_average_z_handleKillAvatarPacket"] = TIGHT_LOOP_STAT(_handleKillAvatarPacketElapsedTime);

assignment-client/src/avatars/AvatarMixer.h

@@ -60,7 +60,7 @@ private:
     void parseDomainServerSettings(const QJsonObject& domainSettings);
     void sendIdentityPacket(AvatarMixerClientData* nodeData, const SharedNodePointer& destinationNode);
 
-    void manageDisplayName(AvatarMixerClientData* nodeData, const SharedNodePointer& node);
+    void manageDisplayName(const SharedNodePointer& node);
 
     QThread _broadcastThread;
 

libraries/avatars/src/AvatarData.cpp

@@ -120,10 +120,6 @@ void AvatarData::nextAttitude(glm::vec3 position, glm::quat orientation) {
     updateAttitude();
 }
 
-float AvatarData::getTargetScale() const {
-    return _targetScale;
-}
-
 void AvatarData::setTargetScale(float targetScale) {
     auto newValue = glm::clamp(targetScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE);
     if (_targetScale != newValue) {
@@ -152,38 +148,6 @@ void AvatarData::lazyInitHeadData() {
 }
 
 
-bool AvatarData::avatarBoundingBoxChangedSince(quint64 time) {
-    return _avatarBoundingBoxChanged >= time;
-}
-
-bool AvatarData::avatarScaleChangedSince(quint64 time) {
-    return _avatarScaleChanged >= time;
-}
-
-bool AvatarData::lookAtPositionChangedSince(quint64 time) {
-    return _headData->lookAtPositionChangedSince(time);
-}
-
-bool AvatarData::audioLoudnessChangedSince(quint64 time) {
-    return _headData->audioLoudnessChangedSince(time);
-}
-
-bool AvatarData::sensorToWorldMatrixChangedSince(quint64 time) {
-    return _sensorToWorldMatrixChanged >= time;
-}
-
-bool AvatarData::additionalFlagsChangedSince(quint64 time) {
-    return _additionalFlagsChanged >= time;
-}
-
-bool AvatarData::parentInfoChangedSince(quint64 time) {
-    return _parentChanged >= time;
-}
-
-bool AvatarData::faceTrackerInfoChangedSince(quint64 time) {
-    return true; // FIXME!
-}
-
 float AvatarData::getDistanceBasedMinRotationDOT(glm::vec3 viewerPosition) {
     auto distance = glm::distance(_globalPosition, viewerPosition);
     float result = ROTATION_CHANGE_179D; // assume worst

libraries/avatars/src/AvatarData.h

@@ -419,7 +419,6 @@ public:
     void setAudioAverageLoudness(float value) { _headData->setAudioAverageLoudness(value); }
 
     //  Scale
-    float getTargetScale() const;
     virtual void setTargetScale(float targetScale);
 
     float getDomainLimitedScale() const { return glm::clamp(_targetScale, _domainMinimumScale, _domainMaximumScale); }
@@ -534,8 +533,8 @@ public:
     QJsonObject toJson() const;
     void fromJson(const QJsonObject& json, bool useFrameSkeleton = true);
 
-    glm::vec3 getClientGlobalPosition() { return _globalPosition; }
+    glm::vec3 getClientGlobalPosition() const { return _globalPosition; }
-    glm::vec3 getGlobalBoundingBoxCorner() { return _globalPosition + _globalBoundingBoxOffset - _globalBoundingBoxDimensions; }
+    glm::vec3 getGlobalBoundingBoxCorner() const { return _globalPosition + _globalBoundingBoxOffset - _globalBoundingBoxDimensions; }
 
     Q_INVOKABLE AvatarEntityMap getAvatarEntityData() const;
     Q_INVOKABLE void setAvatarEntityData(const AvatarEntityMap& avatarEntityData);
@@ -550,7 +549,7 @@ public:
     Q_INVOKABLE float getDataRate(const QString& rateName = QString("")) const;
     Q_INVOKABLE float getUpdateRate(const QString& rateName = QString("")) const;
 
-    int getJointCount() { return _jointData.size(); }
+    int getJointCount() const { return _jointData.size(); }
 
     QVector<JointData> getLastSentJointData() {
         QReadLocker readLock(&_jointDataLock);
@@ -571,7 +570,7 @@ public slots:
     virtual bool setAbsoluteJointRotationInObjectFrame(int index, const glm::quat& rotation) override { return false; }
     virtual bool setAbsoluteJointTranslationInObjectFrame(int index, const glm::vec3& translation) override { return false; }
 
-    float getTargetScale() { return _targetScale; }
+    float getTargetScale() const { return _targetScale; } // why is this a slot?
 
     void resetLastSent() { _lastToByteArray = 0; }
 
@@ -581,18 +580,17 @@ protected:
     float getDistanceBasedMinRotationDOT(glm::vec3 viewerPosition);
     float getDistanceBasedMinTranslationDistance(glm::vec3 viewerPosition);
 
-    bool avatarBoundingBoxChangedSince(quint64 time);
+    bool avatarBoundingBoxChangedSince(quint64 time) const { return _avatarBoundingBoxChanged >= time; }
-    bool avatarScaleChangedSince(quint64 time);
+    bool avatarScaleChangedSince(quint64 time) const { return _avatarScaleChanged >= time; }
-    bool lookAtPositionChangedSince(quint64 time);
+    bool lookAtPositionChangedSince(quint64 time) const { return _headData->lookAtPositionChangedSince(time); }
-    bool audioLoudnessChangedSince(quint64 time);
+    bool audioLoudnessChangedSince(quint64 time) const { return _headData->audioLoudnessChangedSince(time); }
-    bool sensorToWorldMatrixChangedSince(quint64 time);
+    bool sensorToWorldMatrixChangedSince(quint64 time) const { return _sensorToWorldMatrixChanged >= time; }
-    bool additionalFlagsChangedSince(quint64 time);
+    bool additionalFlagsChangedSince(quint64 time) const { return _additionalFlagsChanged >= time; }
+    bool parentInfoChangedSince(quint64 time) const { return _parentChanged >= time; }
+    bool faceTrackerInfoChangedSince(quint64 time) const { return true; } // FIXME
 
-    bool hasParent() { return !getParentID().isNull(); }
+    bool hasParent() const { return !getParentID().isNull(); }
-    bool parentInfoChangedSince(quint64 time);
+    bool hasFaceTracker() const { return _headData ? _headData->_isFaceTrackerConnected : false; }
-
-    bool hasFaceTracker() { return _headData ? _headData->_isFaceTrackerConnected : false; }
-    bool faceTrackerInfoChangedSince(quint64 time);
 
     glm::vec3 _handPosition;
     virtual const QString& getSessionDisplayNameForTransport() const { return _sessionDisplayName; }

libraries/shared/src/SpatiallyNestable.h

@@ -179,9 +179,9 @@ public:
             const glm::vec3& localVelocity,
             const glm::vec3& localAngularVelocity);
 
-    bool scaleChangedSince(quint64 time) { return _scaleChanged > time; }
+    bool scaleChangedSince(quint64 time) const { return _scaleChanged > time; }
-    bool tranlationChangedSince(quint64 time) { return _translationChanged > time; }
+    bool tranlationChangedSince(quint64 time) const { return _translationChanged > time; }
-    bool rotationChangedSince(quint64 time) { return _rotationChanged > time; }
+    bool rotationChangedSince(quint64 time) const { return _rotationChanged > time; }
 
 protected:
     const NestableType _nestableType; // EntityItem or an AvatarData