Fix for rendering of tablet ModelEntity in desktop mode.

The Model pendingChanges.updateItem() lambda now directly calls into StaticallyNestable.  This is late enough
in the update loop to have the most up-to-date camera transform used for rendering.

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -495,6 +495,7 @@ ModelPointer RenderableModelEntityItem::getModel(QSharedPointer<EntityTreeRender
         // If we don't have a model, allocate one *immediately*
         if (!_model) {
             _model = _myRenderer->allocateModel(getModelURL(), renderer->getEntityLoadingPriority(*this));
+            _model->setSpatiallyNestableOverride(shared_from_this());
             _needsInitialSimulation = true;
         // If we need to change URLs, update it *after rendering* (to avoid access violations)
         } else if (QUrl(getModelURL()) != _model->getURL()) {
@@ -1173,8 +1174,7 @@ void RenderableModelEntityItem::locationChanged(bool tellPhysics) {
     PerformanceTimer pertTimer("locationChanged");
     EntityItem::locationChanged(tellPhysics);
     if (_model && _model->isActive()) {
-        _model->setRotation(getRotation());
-        _model->setTranslation(getPosition());
+        _model->updateRenderItems();
 
         void* key = (void*)this;
         std::weak_ptr<RenderableModelEntityItem> weakSelf =

libraries/render-utils/src/Model.cpp

@@ -135,6 +135,24 @@ void Model::setRotation(const glm::quat& rotation) {
     updateRenderItems();
 }
 
+void Model::setSpatiallyNestableOverride(SpatiallyNestablePointer override) {
+    _spatiallyNestableOverride = override;
+    updateRenderItems();
+}
+
+Transform Model::getTransform() const {
+    SpatiallyNestablePointer spatiallyNestableOverride = _spatiallyNestableOverride.lock();
+    if (spatiallyNestableOverride) {
+        return spatiallyNestableOverride->getTransform();
+    } else {
+        Transform transform;
+        transform.setScale(getScale());
+        transform.setTranslation(getTranslation());
+        transform.setRotation(getRotation());
+        return transform;
+    }
+}
+
 void Model::setScale(const glm::vec3& scale) {
     setScaleInternal(scale);
     // if anyone sets scale manually, then we are no longer scaled to fit
@@ -216,11 +234,6 @@ void Model::updateRenderItems() {
 
         render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
 
-        Transform modelTransform;
-        modelTransform.setScale(scale);
-        modelTransform.setTranslation(self->_translation);
-        modelTransform.setRotation(self->_rotation);
-
         Transform modelMeshOffset;
         if (self->isLoaded()) {
             // includes model offset and unitScale.
@@ -233,13 +246,15 @@ void Model::updateRenderItems() {
 
         render::PendingChanges pendingChanges;
         foreach (auto itemID, self->_modelMeshRenderItems.keys()) {
-            pendingChanges.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, modelMeshOffset, deleteGeometryCounter](ModelMeshPartPayload& data) {
+            pendingChanges.updateItem<ModelMeshPartPayload>(itemID, [modelMeshOffset, deleteGeometryCounter](ModelMeshPartPayload& data) {
                 if (data._model && data._model->isLoaded()) {
                     if (!data.hasStartedFade() && data._model->getGeometry()->areTexturesLoaded()) {
                         data.startFade();
                     }
                     // Ensure the model geometry was not reset between frames
                     if (deleteGeometryCounter == data._model->_deleteGeometryCounter) {
+                        Transform modelTransform = data._model->getTransform();
+
                         // lazy update of cluster matrices used for rendering.  We need to update them here, so we can correctly update the bounding box.
                         data._model->updateClusterMatrices(modelTransform.getTranslation(), modelTransform.getRotation());
 
@@ -254,6 +269,7 @@ void Model::updateRenderItems() {
         // collision mesh does not share the same unit scale as the FBX file's mesh: only apply offset
         Transform collisionMeshOffset;
         collisionMeshOffset.setIdentity();
+        Transform modelTransform = self->getTransform();
         foreach (auto itemID, self->_collisionRenderItems.keys()) {
             pendingChanges.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
                 // update the model transform for this render item.

libraries/render-utils/src/Model.h

@@ -27,6 +27,7 @@
 #include <gpu/Batch.h>
 #include <render/Scene.h>
 #include <Transform.h>
+#include <SpatiallyNestable.h>
 
 #include "GeometryCache.h"
 #include "TextureCache.h"
@@ -203,10 +204,13 @@ public:
 
     void setTranslation(const glm::vec3& translation);
     void setRotation(const glm::quat& rotation);
+    void setSpatiallyNestableOverride(SpatiallyNestablePointer ptr);
 
     const glm::vec3& getTranslation() const { return _translation; }
     const glm::quat& getRotation() const { return _rotation; }
 
+    Transform getTransform() const;
+
     void setScale(const glm::vec3& scale);
     const glm::vec3& getScale() const { return _scale; }
 
@@ -288,6 +292,9 @@ protected:
     glm::vec3 _translation;
     glm::quat _rotation;
     glm::vec3 _scale;
+
+    SpatiallyNestableWeakPointer _spatiallyNestableOverride;
+
     glm::vec3 _offset;
 
     static float FAKE_DIMENSION_PLACEHOLDER;