Merge pull request #13429 from danteruiz/fix-entity-lag-2

Fix entities rendering a frame ahead or behind when parented to my avatar.

libraries/entities-renderer/src/RenderableEntityItem.cpp

@@ -363,6 +363,14 @@ bool EntityRenderer::needsRenderUpdateFromEntity(const EntityItemPointer& entity
     return false;
 }
 
+void EntityRenderer::updateModelTransform() {
+    bool success = false;
+    auto newModelTransform = _entity->getTransformToCenter(success);
+    if (success) {
+        _modelTransform = newModelTransform;
+    }
+}
+
 void EntityRenderer::doRenderUpdateSynchronous(const ScenePointer& scene, Transaction& transaction, const EntityItemPointer& entity) {
     DETAILED_PROFILE_RANGE(simulation_physics, __FUNCTION__);
     withWriteLock([&] {

libraries/entities-renderer/src/RenderableEntityItem.h

@@ -97,6 +97,7 @@ protected:
     virtual void doRender(RenderArgs* args) = 0;
 
     bool isFading() const { return _isFading; }
+    void updateModelTransform();
     virtual bool isTransparent() const { return _isFading ? Interpolate::calculateFadeRatio(_fadeStartTime) < 1.0f : false; }
     inline bool isValidRenderItem() const { return _renderItemID != Item::INVALID_ITEM_ID; }
 
@@ -140,6 +141,7 @@ protected:
     bool _needsRenderUpdate { false };
     // Only touched on the rendering thread
     bool _renderUpdateQueued{ false };
+    Transform _renderTransform;
 
     std::unordered_map<std::string, graphics::MultiMaterial> _materials;
     std::mutex _materialsLock;

libraries/entities-renderer/src/RenderableMaterialEntityItem.h

@@ -35,7 +35,6 @@ private:
     glm::vec2 _materialMappingPos;
     glm::vec2 _materialMappingScale;
     float _materialMappingRot;
-    Transform _renderTransform;
 
     std::shared_ptr<NetworkMaterial> _drawMaterial;
 };

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp

@@ -122,6 +122,14 @@ void ParticleEffectEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePoi
             });
         }
     }
+
+    void* key = (void*)this;
+    AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [this] () {
+        withWriteLock([&] {
+            updateModelTransform();
+            _renderTransform = getModelTransform();
+        });
+    });
 }
 
 void ParticleEffectEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
@@ -319,7 +327,10 @@ void ParticleEffectEntityRenderer::doRender(RenderArgs* args) {
     // In trail mode, the particles are created in world space.
     // so we only set a transform if they're not in trail mode
     if (!_particleProperties.emission.shouldTrail) {
-        transform = getModelTransform();
+
+        withReadLock([&] {
+            transform = _renderTransform;
+        });
         transform.setScale(vec3(1));
     }
     batch.setModelTransform(transform);

libraries/entities-renderer/src/RenderableShapeEntityItem.cpp

@@ -97,16 +97,25 @@ void ShapeEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
         addMaterial(graphics::MaterialLayer(_material, 0), "0");
 
         _shape = entity->getShape();
-        _position = entity->getWorldPosition();
+    });
-        _dimensions = entity->getScaledDimensions();
-        _orientation = entity->getWorldOrientation();
-        _renderTransform = getModelTransform();
 
-        if (_shape == entity::Sphere) {
+    void* key = (void*)this;
-            _renderTransform.postScale(SPHERE_ENTITY_SCALE);
+    AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [this] () {
-        }
+        withWriteLock([&] {
+            auto entity = getEntity();
+            _position = entity->getWorldPosition();
+            _dimensions = entity->getScaledDimensions();
+            _orientation = entity->getWorldOrientation();
+            bool success = false;
+            auto newModelTransform = entity->getTransformToCenter(success);
+            _renderTransform = success ? newModelTransform : getModelTransform();
 
-        _renderTransform.postScale(_dimensions);
+            if (_shape == entity::Sphere) {
+                _renderTransform.postScale(SPHERE_ENTITY_SCALE);
+            }
+
+            _renderTransform.postScale(_dimensions);
+        });;
     });
 }
 

libraries/entities-renderer/src/RenderableShapeEntityItem.h

@@ -40,7 +40,6 @@ private:
 
     Procedural _procedural;
     QString _lastUserData;
-    Transform _renderTransform;
     entity::Shape _shape { entity::Sphere };
     std::shared_ptr<graphics::Material> _material;
     glm::vec3 _position;

libraries/entities-renderer/src/RenderableTextEntityItem.cpp

@@ -20,6 +20,7 @@
 
 #include "GLMHelpers.h"
 
+using namespace render;
 using namespace render::entities;
 
 static const int FIXED_FONT_POINT_SIZE = 40;
@@ -64,10 +65,20 @@ bool TextEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoint
     return false;
 }
 
+void TextEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) {
+    void* key = (void*)this;
+    AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [this, entity] () {
+        withWriteLock([&] {
+            _dimensions = entity->getScaledDimensions();
+            updateModelTransform();
+            _renderTransform = getModelTransform();
+        });
+    });
+}
+
 void TextEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
     _textColor = toGlm(entity->getTextColorX());
     _backgroundColor = toGlm(entity->getBackgroundColorX());
-    _dimensions = entity->getScaledDimensions();
     _faceCamera = entity->getFaceCamera();
     _lineHeight = entity->getLineHeight();
     _text = entity->getText();
@@ -77,12 +88,17 @@ void TextEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointe
 void TextEntityRenderer::doRender(RenderArgs* args) {
     PerformanceTimer perfTimer("RenderableTextEntityItem::render");
 
+    Transform modelTransform;
+    glm::vec3 dimensions;
+    withReadLock([&] {
+        modelTransform = _renderTransform;
+        dimensions = _dimensions;
+    });
     static const float SLIGHTLY_BEHIND = -0.005f;
     float fadeRatio = _isFading ? Interpolate::calculateFadeRatio(_fadeStartTime) : 1.0f;
     bool transparent = fadeRatio < 1.0f;
     glm::vec4 textColor = glm::vec4(_textColor, fadeRatio);
     glm::vec4 backgroundColor = glm::vec4(_backgroundColor, fadeRatio);
-    const glm::vec3& dimensions = _dimensions;
 
     // Render background
     glm::vec3 minCorner = glm::vec3(0.0f, -dimensions.y, SLIGHTLY_BEHIND);
@@ -93,7 +109,6 @@ void TextEntityRenderer::doRender(RenderArgs* args) {
     Q_ASSERT(args->_batch);
     gpu::Batch& batch = *args->_batch;
 
-    const auto& modelTransform = getModelTransform();
     auto transformToTopLeft = modelTransform;
     if (_faceCamera) {
         //rotate about vertical to face the camera

libraries/entities-renderer/src/RenderableTextEntityItem.h

@@ -27,6 +27,7 @@ public:
     ~TextEntityRenderer();
 private:
     virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override;
+    virtual void doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) override;
     virtual void doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) override;
     virtual void doRender(RenderArgs* args) override;
     int _geometryID{ 0 };

libraries/entities-renderer/src/RenderableWebEntityItem.cpp

@@ -192,19 +192,25 @@ void WebEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene
             _webSurface->getRootItem()->setProperty(URL_PROPERTY, _lastSourceUrl);
         }
 
-        if (_contextPosition != entity->getWorldPosition()) {
+        void* key = (void*)this;
-            // update globalPosition
+        AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [this, entity] () {
-            _contextPosition = entity->getWorldPosition();
+            withWriteLock([&] {
-            _webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3toVariant(_contextPosition));
+                if (_contextPosition != entity->getWorldPosition()) {
-        }
+                    // update globalPosition
+                    _contextPosition = entity->getWorldPosition();
+                    _webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3toVariant(_contextPosition));
+                }
 
-        _lastDPI = entity->getDPI();
+                _lastDPI = entity->getDPI();
-        _lastLocked = entity->getLocked();
+                _lastLocked = entity->getLocked();
 
-        glm::vec2 windowSize = getWindowSize(entity);
+                glm::vec2 windowSize = getWindowSize(entity);
-        _webSurface->resize(QSize(windowSize.x, windowSize.y));
+                _webSurface->resize(QSize(windowSize.x, windowSize.y));
-        _renderTransform = getModelTransform();
+                updateModelTransform();
-        _renderTransform.postScale(entity->getScaledDimensions());
+                _renderTransform = getModelTransform();
+                _renderTransform.postScale(entity->getScaledDimensions());
+            });
+        });
     });
 }
 

libraries/entities-renderer/src/RenderableWebEntityItem.h

@@ -68,7 +68,6 @@ private:
     bool _lastLocked;
     QTimer _timer;
     uint64_t _lastRenderTime { 0 };
-    Transform _renderTransform;
 };
 
 } } // namespace 

libraries/entities-renderer/src/RenderableZoneEntityItem.h

@@ -123,7 +123,6 @@ private:
     bool _pendingSkyboxTexture{ false };
 
     QString _proceduralUserData;
-    Transform _renderTransform;
 };
 
 } } // namespace