Hold flickering fixed and refactor

interface/src/avatar/AvatarManager.cpp

@@ -79,14 +79,12 @@ AvatarManager::AvatarManager(QObject* parent) :
         }
     });
 
-    const float AVATAR_TRANSIT_TRIGGER_DISTANCE = 1.0f;
-    const int AVATAR_TRANSIT_FRAME_COUNT = 11; // Based on testing
-    const float AVATAR_TRANSIT_FRAMES_PER_METER = 0.5f; // Based on testing
-
     _transitConfig._totalFrames = AVATAR_TRANSIT_FRAME_COUNT;
-    _transitConfig._triggerDistance = AVATAR_TRANSIT_TRIGGER_DISTANCE;
+    _transitConfig._minTriggerDistance = AVATAR_TRANSIT_MIN_TRIGGER_DISTANCE;
+    _transitConfig._maxTriggerDistance = AVATAR_TRANSIT_MAX_TRIGGER_DISTANCE;
     _transitConfig._framesPerMeter = AVATAR_TRANSIT_FRAMES_PER_METER;
-    _transitConfig._isDistanceBased = true;
+    _transitConfig._isDistanceBased = AVATAR_TRANSIT_DISTANCE_BASED;
+    _transitConfig._abortDistance = AVATAR_TRANSIT_ABORT_DISTANCE;
 }
 
 AvatarSharedPointer AvatarManager::addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {
@@ -169,7 +167,7 @@ void AvatarManager::updateMyAvatar(float deltaTime) {
     bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
     PerformanceWarning warn(showWarnings, "AvatarManager::updateMyAvatar()");
 
-    AvatarTransit::Status status = _myAvatar->updateTransit(deltaTime, _myAvatar->getNextPosition(), _transitConfig);
+    AvatarTransit::Status status = _myAvatar->updateTransit(deltaTime, _myAvatar->getNextPosition(), _myAvatar->getSensorToWorldScale(), _transitConfig);
     handleTransitAnimations(status);
 
     _myAvatar->update(deltaTime);
@@ -300,7 +298,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
             if (inView && avatar->hasNewJointData()) {
                 numAvatarsUpdated++;
             }
-            auto transitStatus = avatar->_transit.update(deltaTime, avatar->_lastPosition, _transitConfig);
+            auto transitStatus = avatar->_transit.update(deltaTime, avatar->_serverPosition, _transitConfig);
             if (avatar->getIsNewAvatar() && (transitStatus == AvatarTransit::Status::START_TRANSIT || transitStatus == AvatarTransit::Status::ABORT_TRANSIT)) {
                 avatar->_transit.reset();
                 avatar->setIsNewAvatar(false);

interface/src/avatar/MyAvatar.cpp

@@ -929,7 +929,6 @@ void MyAvatar::updateSensorToWorldMatrix() {
     updateJointFromController(controller::Action::RIGHT_HAND, _controllerRightHandMatrixCache);
     
     if (hasSensorToWorldScaleChanged) {
-        setTransitScale(sensorToWorldScale);
         emit sensorToWorldScaleChanged(sensorToWorldScale);
     }
     

libraries/animation/src/Rig.cpp

@@ -1138,7 +1138,7 @@ void Rig::updateAnimations(float deltaTime, const glm::mat4& rootTransform, cons
                 }
             }
             if (_sendNetworkNode) {
-                for (auto i = 0; i < _networkPoseSet._relativePoses.size(); i++) {
+                for (size_t i = 0; i < _networkPoseSet._relativePoses.size(); i++) {
                     _networkPoseSet._relativePoses[i].blend(_internalPoseSet._relativePoses[i], (alpha > 1.0f ? 1.0f : alpha));
                 }
             }

libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp

@@ -115,10 +115,8 @@ void Avatar::setShowNamesAboveHeads(bool show) {
 
 AvatarTransit::Status AvatarTransit::update(float deltaTime, const glm::vec3& avatarPosition, const AvatarTransit::TransitConfig& config) {
     float oneFrameDistance = _isActive ? glm::length(avatarPosition - _endPosition) : glm::length(avatarPosition - _lastPosition);
-    const float TRANSIT_TRIGGER_MAX_DISTANCE = 30.0f;
+    if (oneFrameDistance > (config._minTriggerDistance * _scale)) {
-    float scaledMaxTransitDistance = TRANSIT_TRIGGER_MAX_DISTANCE * _scale;
+        if (oneFrameDistance < (config._maxTriggerDistance * _scale)) {
-    if (oneFrameDistance > config._triggerDistance) {
-        if (oneFrameDistance < scaledMaxTransitDistance) {
             start(deltaTime, _lastPosition, avatarPosition, config);
         } else {
             _lastPosition = avatarPosition;
@@ -128,9 +126,7 @@ AvatarTransit::Status AvatarTransit::update(float deltaTime, const glm::vec3& av
     _lastPosition = avatarPosition;
     _status = updatePosition(deltaTime);
 
-    const float SETTLE_ABORT_DISTANCE = 0.1f;
+    if (_isActive && oneFrameDistance > (config._abortDistance * _scale) && _status == Status::POST_TRANSIT) {
-    float scaledSettleAbortDistance = SETTLE_ABORT_DISTANCE * _scale;
-    if (_isActive && oneFrameDistance > scaledSettleAbortDistance && _status == Status::POST_TRANSIT) {
         reset();
         _status = Status::ENDED;
     }
@@ -150,14 +146,10 @@ void AvatarTransit::start(float deltaTime, const glm::vec3& startPosition, const
     _totalDistance = glm::length(_transitLine);
     _easeType = config._easeType;
 
-    const float REFERENCE_FRAMES_PER_SECOND = 30.0f;
+    _preTransitTime = AVATAR_PRE_TRANSIT_FRAME_COUNT / AVATAR_TRANSIT_FRAMES_PER_SECOND;
-    const float PRE_TRANSIT_FRAME_COUNT = 10.0f;
+    _postTransitTime = AVATAR_POST_TRANSIT_FRAME_COUNT / AVATAR_TRANSIT_FRAMES_PER_SECOND;
-    const float POST_TRANSIT_FRAME_COUNT = 27.0f;
-
-    _preTransitTime = PRE_TRANSIT_FRAME_COUNT / REFERENCE_FRAMES_PER_SECOND;
-    _postTransitTime = POST_TRANSIT_FRAME_COUNT / REFERENCE_FRAMES_PER_SECOND;
     int transitFrames = (!config._isDistanceBased) ? config._totalFrames : config._framesPerMeter * _totalDistance;
-    _transitTime = (float)transitFrames / REFERENCE_FRAMES_PER_SECOND;
+    _transitTime = (float)transitFrames / AVATAR_TRANSIT_FRAMES_PER_SECOND;
     _totalTime = _transitTime + _preTransitTime + _postTransitTime;
     _currentTime = _isActive ? _preTransitTime : 0.0f;
     _isActive = true;
@@ -555,12 +547,9 @@ void Avatar::relayJointDataToChildren() {
 void Avatar::simulate(float deltaTime, bool inView) {
     PROFILE_RANGE(simulation, "simulate");
 
-    if (_transit.isActive()) {
+    _globalPosition = _transit.isActive() ? _transit.getCurrentPosition() : _serverPosition;
-        _globalPosition = _transit.getCurrentPosition();
-        _globalPositionChanged = usecTimestampNow();
     if (!hasParent()) {
-            setLocalPosition(_transit.getCurrentPosition());
+        setLocalPosition(_globalPosition);
-        }
     }
     
     _simulationRate.increment();
@@ -1994,22 +1983,12 @@ float Avatar::getUnscaledEyeHeightFromSkeleton() const {
     }
 }
 
-AvatarTransit::Status Avatar::updateTransit(float deltaTime, const glm::vec3& avatarPosition, const AvatarTransit::TransitConfig& config) {
+AvatarTransit::Status Avatar::updateTransit(float deltaTime, const glm::vec3& avatarPosition, float avatarScale, const AvatarTransit::TransitConfig& config) {
     std::lock_guard<std::mutex> lock(_transitLock);
+    _transit.setScale(avatarScale);
     return _transit.update(deltaTime, avatarPosition, config);
 }
 
-void Avatar::setTransitScale(float scale) {
-    std::lock_guard<std::mutex> lock(_transitLock);
-    _transit.setScale(scale);
-}
-
-void Avatar::overrideNextPacketPositionData(const glm::vec3& position) {
-    std::lock_guard<std::mutex> lock(_transitLock);
-    _overrideGlobalPosition = true;
-    _globalPositionOverride = position;
-}
-
 void Avatar::addMaterial(graphics::MaterialLayer material, const std::string& parentMaterialName) {
     std::lock_guard<std::mutex> lock(_materialsLock);
     _materials[parentMaterialName].push(material);

libraries/avatars-renderer/src/avatars-renderer/Avatar.h

@@ -76,7 +76,9 @@ public:
         int _totalFrames { 0 };
         float _framesPerMeter { 0.0f };
         bool _isDistanceBased { false };
-        float _triggerDistance { 0 };
+        float _minTriggerDistance { 0.0f };
+        float _maxTriggerDistance { 0.0f };
+        float _abortDistance{ 0.0f };
         EaseType _easeType { EaseType::EASE_OUT };
     };
 
@@ -434,11 +436,7 @@ public:
     virtual scriptable::ScriptableModelBase getScriptableModel() override;
 
     std::shared_ptr<AvatarTransit> getTransit() { return std::make_shared<AvatarTransit>(_transit); };
-
+    AvatarTransit::Status updateTransit(float deltaTime, const glm::vec3& avatarPosition, float avatarScale, const AvatarTransit::TransitConfig& config);
-    AvatarTransit::Status updateTransit(float deltaTime, const glm::vec3& avatarPosition, const AvatarTransit::TransitConfig& config);
-    void setTransitScale(float scale);
-
-    void overrideNextPacketPositionData(const glm::vec3& position);
 
 signals:
     void targetScaleChanged(float targetScale);

libraries/avatars/src/AvatarData.cpp

@@ -371,12 +371,7 @@ QByteArray AvatarData::toByteArray(AvatarDataDetail dataDetail, quint64 lastSent
 
     if (hasAvatarGlobalPosition) {
         auto startSection = destinationBuffer;
-        if (_overrideGlobalPosition) {
-            AVATAR_MEMCPY(_globalPositionOverride);
-        } else {
         AVATAR_MEMCPY(_globalPosition);        
-        }
-        
 
         int numBytes = destinationBuffer - startSection;
 
@@ -894,20 +889,22 @@ int AvatarData::parseDataFromBuffer(const QByteArray& buffer) {
             offset = glm::vec3(row * SPACE_BETWEEN_AVATARS, 0.0f, col * SPACE_BETWEEN_AVATARS);
         }
 
-        auto newValue = glm::vec3(data->globalPosition[0], data->globalPosition[1], data->globalPosition[2]) + offset;
+        _serverPosition = glm::vec3(data->globalPosition[0], data->globalPosition[1], data->globalPosition[2]) + offset;
-        if (_globalPosition != newValue) {
+        auto oneStepDistance = glm::length(_globalPosition - _serverPosition);
-            _lastPosition = _globalPosition = newValue;
+        if (oneStepDistance <= AVATAR_TRANSIT_MIN_TRIGGER_DISTANCE || oneStepDistance >= AVATAR_TRANSIT_MAX_TRIGGER_DISTANCE) {
+            _globalPosition = _serverPosition;
+            // if we don't have a parent, make sure to also set our local position
+            if (!hasParent()) {
+                setLocalPosition(_serverPosition);
+            }
+        }
+        if (_globalPosition != _serverPosition) {
             _globalPositionChanged = now;
         }
         sourceBuffer += sizeof(AvatarDataPacket::AvatarGlobalPosition);
         int numBytesRead = sourceBuffer - startSection;
         _globalPositionRate.increment(numBytesRead);
         _globalPositionUpdateRate.increment();
-
-        // if we don't have a parent, make sure to also set our local position
-        if (!hasParent()) {
-            setLocalPosition(newValue);
-        }
     }
 
     if (hasAvatarBoundingBox) {
@@ -2110,10 +2107,6 @@ void AvatarData::sendAvatarDataPacket(bool sendAll) {
         }
     }
 
-    if (_overrideGlobalPosition) {
-        _overrideGlobalPosition = false;
-    }
-
     doneEncoding(cullSmallData);
 
     static AvatarDataSequenceNumber sequenceNumber = 0;

libraries/avatars/src/AvatarData.h

@@ -327,6 +327,17 @@ const float AVATAR_DISTANCE_LEVEL_5 = 200.0f; // meters
 // This is the start location in the Sandbox (xyz: 6270, 211, 6000).
 const glm::vec3 START_LOCATION(6270, 211, 6000);
 
+// Avatar Transit Constants
+const float AVATAR_TRANSIT_MIN_TRIGGER_DISTANCE = 1.0f;
+const float AVATAR_TRANSIT_MAX_TRIGGER_DISTANCE = 30.0f;
+const int AVATAR_TRANSIT_FRAME_COUNT = 11;
+const float AVATAR_TRANSIT_FRAMES_PER_METER = 0.5f;
+const float AVATAR_TRANSIT_ABORT_DISTANCE = 0.1f;
+const bool AVATAR_TRANSIT_DISTANCE_BASED = true;
+const float AVATAR_TRANSIT_FRAMES_PER_SECOND = 30.0f;
+const float AVATAR_PRE_TRANSIT_FRAME_COUNT = 10.0f;
+const float AVATAR_POST_TRANSIT_FRAME_COUNT = 27.0f;
+
 enum KeyState {
     NO_KEY_DOWN = 0,
     INSERT_KEY_DOWN,
@@ -1378,9 +1389,7 @@ protected:
     // where Entities are located.  This is currently only used by the mixer to decide how often to send
     // updates about one avatar to another.
     glm::vec3 _globalPosition { 0, 0, 0 };
-    glm::vec3 _lastPosition { 0, 0, 0 };
+    glm::vec3 _serverPosition { 0, 0, 0 };
-    glm::vec3 _globalPositionOverride { 0, 0, 0 };
-    bool _overrideGlobalPosition { false };
 
     quint64 _globalPositionChanged { 0 };
     quint64 _avatarBoundingBoxChanged { 0 };