cleaning up modelmeshpartpayload

interface/src/ui/overlays/ModelOverlay.cpp

@@ -24,7 +24,6 @@ ModelOverlay::ModelOverlay()
     : _model(std::make_shared<Model>(nullptr, this)),
       _modelTextures(QVariantMap())
 {
-    _model->init();
     _model->setLoadingPriority(_loadPriority);
     _isLoaded = false;
 }
@@ -38,7 +37,6 @@ ModelOverlay::ModelOverlay(const ModelOverlay* modelOverlay) :
     _scaleToFit(modelOverlay->_scaleToFit),
     _loadPriority(modelOverlay->_loadPriority)
 {
-    _model->init();
     _model->setLoadingPriority(_loadPriority);
     if (_url.isValid()) {
         _updateModel = true;

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

@@ -138,7 +138,6 @@ Avatar::~Avatar() {
 
 void Avatar::init() {
     getHead()->init();
-    _skeletonModel->init();
     _initialized = true;
 }
 

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -1213,7 +1213,6 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
         connect(model.get(), &Model::requestRenderUpdate, this, &ModelEntityRenderer::requestRenderUpdate);
         connect(entity.get(), &RenderableModelEntityItem::requestCollisionGeometryUpdate, this, &ModelEntityRenderer::flagForCollisionGeometryUpdate);
         model->setLoadingPriority(EntityTreeRenderer::getEntityLoadingPriority(*entity));
-        model->init();
         entity->setModel(model);
         withWriteLock([&] { _model = model; });
     }

libraries/render-utils/src/CauterizedModel.cpp

@@ -178,6 +178,11 @@ void CauterizedModel::updateRenderItems() {
             modelTransform.setTranslation(self->getTranslation());
             modelTransform.setRotation(self->getRotation());
 
+            bool isWireframe = self->isWireframe();
+            bool isVisible = self->isVisible();
+            bool isLayeredInFront = self->isLayeredInFront();
+            bool isLayeredInHUD = self->isLayeredInHUD();
+
             render::Transaction transaction;
             for (int i = 0; i < (int)self->_modelMeshRenderItemIDs.size(); i++) {
 
@@ -186,7 +191,10 @@ void CauterizedModel::updateRenderItems() {
                 auto clusterMatrices(self->getMeshState(meshIndex).clusterMatrices);
                 auto clusterMatricesCauterized(self->getCauterizeMeshState(meshIndex).clusterMatrices);
 
-                transaction.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, clusterMatrices, clusterMatricesCauterized](CauterizedMeshPartPayload& data) {
+                bool invalidatePayloadShapeKey = self->shouldInvalidatePayloadShapeKey(meshIndex);
+
+                transaction.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, clusterMatrices, clusterMatricesCauterized, invalidatePayloadShapeKey,
+                        isWireframe, isVisible, isLayeredInFront, isLayeredInHUD](CauterizedMeshPartPayload& data) {
                     data.updateClusterBuffer(clusterMatrices, clusterMatricesCauterized);
 
                     Transform renderTransform = modelTransform;
@@ -200,6 +208,10 @@ void CauterizedModel::updateRenderItems() {
                         renderTransform = modelTransform.worldTransform(Transform(clusterMatricesCauterized[0]));
                     }
                     data.updateTransformForCauterizedMesh(renderTransform);
+
+                    data.setKey(data.evalKey(isVisible, isLayeredInFront, isLayeredInHUD));
+                    data.setLayer(data.evalLayer(isLayeredInFront, isLayeredInHUD));
+                    data.setShapeKey(invalidatePayloadShapeKey ? render::ShapeKey::Builder::invalid() : data.evalShapeKey(isWireframe));
                 });
             }
 

libraries/render-utils/src/MeshPartPayload.cpp

@@ -339,13 +339,10 @@ ModelMeshPartPayload::ModelMeshPartPayload(ModelPointer model, int meshIndex, in
     }
     updateTransformForSkinnedMesh(renderTransform, transform);
 
-    initCache();
+    initCache(model);
 }
 
-void ModelMeshPartPayload::initCache() {
+void ModelMeshPartPayload::initCache(const ModelPointer& model) {
-    ModelPointer model = _model.lock();
-    assert(model && model->isLoaded());
-
     if (_drawMesh) {
         auto vertexFormat = _drawMesh->getVertexFormat();
         _hasColorAttrib = vertexFormat->hasAttribute(gpu::Stream::COLOR);
@@ -355,6 +352,7 @@ void ModelMeshPartPayload::initCache() {
         const FBXMesh& mesh = geometry.meshes.at(_meshIndex);
 
         _isBlendShaped = !mesh.blendshapes.isEmpty();
+        _hasTangents = !mesh.tangents.isEmpty();
     }
 
     auto networkMaterial = model->getGeometry()->getShapeMaterial(_shapeID);
@@ -388,94 +386,65 @@ void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& render
     _worldBound.transform(boundTransform);
 }
 
-ItemKey ModelMeshPartPayload::getKey() const {
+render::ItemKey ModelMeshPartPayload::evalKey(bool isVisible, bool isLayeredInFront, bool isLayeredInHUD) const {
     ItemKey::Builder builder;
     builder.withTypeShape();
 
-    ModelPointer model = _model.lock();
+    if (!isVisible) {
-    if (model) {
+        builder.withInvisible();
-        if (!model->isVisible()) {
+    }
-            builder.withInvisible();
-        }
 
-        if (model->isLayeredInFront() || model->isLayeredInHUD()) {
+    if (isLayeredInFront || isLayeredInHUD) {
-            builder.withLayered();
+        builder.withLayered();
-        }
+    }
 
-        if (_isBlendShaped || _isSkinned) {
+    if (_isBlendShaped || _isSkinned) {
-            builder.withDeformed();
+        builder.withDeformed();
-        }
+    }
 
-        if (_drawMaterial) {
+    if (_drawMaterial) {
-            auto matKey = _drawMaterial->getKey();
+        auto matKey = _drawMaterial->getKey();
-            if (matKey.isTranslucent()) {
+        if (matKey.isTranslucent()) {
-                builder.withTransparent();
+            builder.withTransparent();
-            }
         }
     }
+
     return builder.build();
 }
 
-int ModelMeshPartPayload::getLayer() const {
+ItemKey ModelMeshPartPayload::getKey() const {
-    ModelPointer model = _model.lock();
+    return _itemKey;
-    if (model) {
-        if (model->isLayeredInFront()) {
-            return Item::LAYER_3D_FRONT;
-        } else if (model->isLayeredInHUD()) {
-            return Item::LAYER_3D_HUD;
-        }
-    }
-    return Item::LAYER_3D;
 }
 
-ShapeKey ModelMeshPartPayload::getShapeKey() const {
+int ModelMeshPartPayload::evalLayer(bool isLayeredInFront, bool isLayeredInHUD) const {
-    // guard against partially loaded meshes
+    if (isLayeredInFront) {
-    ModelPointer model = _model.lock();
+        return Item::LAYER_3D_FRONT;
-    if (!model || !model->isLoaded() || !model->getGeometry()) {
+    } else if (isLayeredInHUD) {
-        return ShapeKey::Builder::invalid();
+        return Item::LAYER_3D_HUD;
-    }
+    } else {
-
+        return Item::LAYER_3D;
-    const FBXGeometry& geometry = model->getFBXGeometry();
-    const auto& networkMeshes = model->getGeometry()->getMeshes();
-
-    // guard against partially loaded meshes
-    if (_meshIndex >= (int)networkMeshes.size() || _meshIndex >= (int)geometry.meshes.size() || _meshIndex >= (int)model->_meshStates.size()) {
-        return ShapeKey::Builder::invalid();
-    }
-
-    const FBXMesh& mesh = geometry.meshes.at(_meshIndex);
-
-    // if our index is ever out of range for either meshes or networkMeshes, then skip it, and set our _meshGroupsKnown
-    // to false to rebuild out mesh groups.
-    if (_meshIndex < 0 || _meshIndex >= (int)networkMeshes.size() || _meshIndex > geometry.meshes.size()) {
-        model->_needsFixupInScene = true; // trigger remove/add cycle
-        model->invalidCalculatedMeshBoxes(); // if we have to reload, we need to assume our mesh boxes are all invalid
-        return ShapeKey::Builder::invalid();
-    }
-
-
-    int vertexCount = mesh.vertices.size();
-    if (vertexCount == 0) {
-        // sanity check
-        return ShapeKey::Builder::invalid(); // FIXME
     }
+}
 
+int ModelMeshPartPayload::getLayer() const {
+    return _layer;
+}
 
+ShapeKey ModelMeshPartPayload::evalShapeKey(bool isWireframe) const {
     model::MaterialKey drawMaterialKey;
     if (_drawMaterial) {
         drawMaterialKey = _drawMaterial->getKey();
     }
 
     bool isTranslucent = drawMaterialKey.isTranslucent();
-    bool hasTangents = drawMaterialKey.isNormalMap() && !mesh.tangents.isEmpty();
+    bool hasTangents = drawMaterialKey.isNormalMap() && _hasTangents;
     bool hasSpecular = drawMaterialKey.isMetallicMap();
     bool hasLightmap = drawMaterialKey.isLightmapMap();
     bool isUnlit = drawMaterialKey.isUnlit();
 
     bool isSkinned = _isSkinned;
-    bool wireframe = model->isWireframe();
 
-    if (wireframe) {
+    if (isWireframe) {
         isTranslucent = hasTangents = hasSpecular = hasLightmap = isSkinned = false;
     }
 
@@ -500,12 +469,16 @@ ShapeKey ModelMeshPartPayload::getShapeKey() const {
     if (isSkinned) {
         builder.withSkinned();
     }
-    if (wireframe) {
+    if (isWireframe) {
         builder.withWireframe();
     }
     return builder.build();
 }
 
+ShapeKey ModelMeshPartPayload::getShapeKey() const {
+    return _shapeKey;
+}
+
 void ModelMeshPartPayload::bindMesh(gpu::Batch& batch) {
     if (!_isBlendShaped) {
         batch.setIndexBuffer(gpu::UINT32, (_drawMesh->getIndexBuffer()._buffer), 0);
@@ -549,26 +522,9 @@ void ModelMeshPartPayload::render(RenderArgs* args) {
         return; // bail asap
     }
 
-    if (_state == WAITING_TO_START) {
-        if (model->isLoaded()) {
-            _state = STARTED;
-            model->setRenderItemsNeedUpdate();
-        } else {
-            return;
-        }
-    }
-
-    if (_materialNeedsUpdate && model->getGeometry()->areTexturesLoaded()) {
-        model->setRenderItemsNeedUpdate();
-        _materialNeedsUpdate = false;
-    }
-
     if (!args) {
         return;
     }
-    if (!getShapeKey().isValid()) {
-        return;
-    }
 
     gpu::Batch& batch = *(args->_batch);
     auto locations =  args->_shapePipeline->locations;

libraries/render-utils/src/MeshPartPayload.h

@@ -96,12 +96,17 @@ public:
     render::ShapeKey getShapeKey() const override; // shape interface
     void render(RenderArgs* args) override;
 
+    render::ItemKey evalKey(bool isVisible, bool isLayeredInFront, bool isLayeredInHUD) const;
+    void setKey(const render::ItemKey& itemKey) { _itemKey = itemKey; }
+    int evalLayer(bool isLayeredInFront, bool isLayeredInHUD) const;
+    void setLayer(int layer) { _layer = layer; }
+    render::ShapeKey evalShapeKey(bool isWireframe) const;
+    void setShapeKey(const render::ShapeKey& shapeKey) { _shapeKey = shapeKey; };
+
     // ModelMeshPartPayload functions to perform render
     void bindMesh(gpu::Batch& batch) override;
     void bindTransform(gpu::Batch& batch, const render::ShapePipeline::LocationsPointer locations, RenderArgs::RenderMode renderMode) const override;
 
-    void initCache();
-
     void computeAdjustedLocalBound(const std::vector<glm::mat4>& clusterMatrices);
 
     gpu::BufferPointer _clusterBuffer;
@@ -112,16 +117,14 @@ public:
 
     bool _isSkinned{ false };
     bool _isBlendShaped { false };
-    bool _materialNeedsUpdate { true };
+    bool _hasTangents { false };
 
 private:
+    void initCache(const ModelPointer& model);
 
-    enum State : uint8_t {
+    render::ItemKey _itemKey { render::ItemKey::Builder::opaqueShape().build() };
-        WAITING_TO_START = 0,
+    int _layer { render::Item::LAYER_3D };
-        STARTED = 1,
+    render::ShapeKey _shapeKey { render::ShapeKey::Builder::invalid() };
-    };
-
-    mutable State _state { WAITING_TO_START } ;
 };
 
 namespace render {

libraries/render-utils/src/Model.cpp

@@ -210,6 +210,24 @@ int Model::getRenderInfoTextureCount() {
     return _renderInfoTextureCount;
 }
 
+bool Model::shouldInvalidatePayloadShapeKey(int meshIndex) {
+    if (!getGeometry()) {
+        return true;
+    }
+
+    const FBXGeometry& geometry = getFBXGeometry();
+    const auto& networkMeshes = getGeometry()->getMeshes();
+    // if our index is ever out of range for either meshes or networkMeshes, then skip it, and set our _meshGroupsKnown
+    // to false to rebuild out mesh groups.
+    if (meshIndex < 0 || meshIndex >= (int)networkMeshes.size() || meshIndex >= (int)geometry.meshes.size() || meshIndex >= (int)_meshStates.size()) {
+        _needsFixupInScene = true;     // trigger remove/add cycle
+        invalidCalculatedMeshBoxes();  // if we have to reload, we need to assume our mesh boxes are all invalid
+        return true;
+    }
+
+    return false;
+}
+
 void Model::updateRenderItems() {
     if (!_addedToScene) {
         return;
@@ -237,6 +255,11 @@ void Model::updateRenderItems() {
         Transform modelTransform = self->getTransform();
         modelTransform.setScale(glm::vec3(1.0f));
 
+        bool isWireframe = self->isWireframe();
+        bool isVisible = self->isVisible();
+        bool isLayeredInFront = self->isLayeredInFront();
+        bool isLayeredInHUD = self->isLayeredInHUD();
+
         render::Transaction transaction;
         for (int i = 0; i < (int) self->_modelMeshRenderItemIDs.size(); i++) {
 
@@ -244,13 +267,20 @@ void Model::updateRenderItems() {
             auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
             auto clusterMatrices(self->getMeshState(meshIndex).clusterMatrices);
 
-            transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, clusterMatrices](ModelMeshPartPayload& data) {
+            bool invalidatePayloadShapeKey = self->shouldInvalidatePayloadShapeKey(meshIndex);
+
+            transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, clusterMatrices, invalidatePayloadShapeKey,
+                    isWireframe, isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
                 data.updateClusterBuffer(clusterMatrices);
                 Transform renderTransform = modelTransform;
                 if (clusterMatrices.size() == 1) {
                     renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
                 }
                 data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
+
+                data.setKey(data.evalKey(isVisible, isLayeredInFront, isLayeredInHUD));
+                data.setLayer(data.evalLayer(isLayeredInFront, isLayeredInHUD));
+                data.setShapeKey(invalidatePayloadShapeKey ? render::ShapeKey::Builder::invalid() : data.evalShapeKey(isWireframe));
             });
         }
 
@@ -272,16 +302,6 @@ void Model::setRenderItemsNeedUpdate() {
     emit requestRenderUpdate();
 }
 
-void Model::initJointTransforms() {
-    if (isLoaded()) {
-        glm::mat4 modelOffset = glm::scale(_scale) * glm::translate(_offset);
-        _rig.setModelOffset(modelOffset);
-    }
-}
-
-void Model::init() {
-}
-
 void Model::reset() {
     if (isLoaded()) {
         const FBXGeometry& geometry = getFBXGeometry();

libraries/render-utils/src/Model.h

@@ -122,7 +122,6 @@ public:
     void setIsWireframe(bool isWireframe) { _isWireframe = isWireframe; }
     bool isWireframe() const { return _isWireframe; }
 
-    void init();
     void reset();
 
     void setSnapModelToRegistrationPoint(bool snapModelToRegistrationPoint, const glm::vec3& registrationPoint);
@@ -346,11 +345,7 @@ protected:
     // hook for derived classes to be notified when setUrl invalidates the current model.
     virtual void onInvalidate() {};
 
-
-protected:
-
     virtual void deleteGeometry();
-    void initJointTransforms();
 
     QVector<float> _blendshapeCoefficients;
 
@@ -419,6 +414,8 @@ protected:
     bool _isLayeredInFront { false };
     bool _isLayeredInHUD { false };
 
+    bool shouldInvalidatePayloadShapeKey(int meshIndex);
+
 private:
     float _loadingPriority { 0.0f };