re-enable cauterization of meshes for MyAvatar

interface/src/avatar/Avatar.cpp

@@ -1047,6 +1047,7 @@ void Avatar::setModelURLFinished(bool success) {
 static std::shared_ptr<Model> allocateAttachmentModel(bool isSoft, RigPointer rigOverride) {
     if (isSoft) {
         // cast to std::shared_ptr<Model>
+        // TODO: re-enable cauterization for the SoftAttachmentModel when this is MyAvatar
         return std::dynamic_pointer_cast<Model>(std::make_shared<SoftAttachmentModel>(std::make_shared<Rig>(), nullptr, rigOverride));
     } else {
         return std::make_shared<Model>(std::make_shared<Rig>());

interface/src/avatar/CauterizedMeshPartPayload.cpp

@@ -44,6 +44,9 @@ void CauterizedMeshPartPayload::updateTransformForSkinnedCauterizedMesh(const Tr
                 _cauterizedTransform = _transform;
             }
         }
+    } else {
+        _worldBound = _localBound;
+        _worldBound.transform(_drawTransform);
     }
 }
 
@@ -51,10 +54,10 @@ void CauterizedMeshPartPayload::bindTransform(gpu::Batch& batch, const render::S
     // Still relying on the raw data from the model
     const Model::MeshState& state = _model->getMeshState(_meshIndex);
     SkeletonModel* skeleton = static_cast<SkeletonModel*>(_model);
-    bool canCauterize = (renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE);
+    bool useCauterizedMesh = (renderMode != RenderArgs::RenderMode::SHADOW_RENDER_MODE) && skeleton->getEnableCauterization();
 
     if (state.clusterBuffer) {
-        if (canCauterize && skeleton->getCauterizeBones()) {
+        if (useCauterizedMesh) {
             const Model::MeshState& cState = skeleton->getCauterizeMeshState(_meshIndex);
             batch.setUniformBuffer(ShapePipeline::Slot::BUFFER::SKINNING, cState.clusterBuffer);
         } else {
@@ -62,7 +65,7 @@ void CauterizedMeshPartPayload::bindTransform(gpu::Batch& batch, const render::S
         }
         batch.setModelTransform(_transform);
     } else {
-        if (canCauterize && skeleton->getCauterizeBones()) {
+        if (useCauterizedMesh) {
             batch.setModelTransform(_cauterizedTransform);
         } else {
             batch.setModelTransform(_transform);

interface/src/avatar/CauterizedModel.cpp

@@ -9,9 +9,6 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-//#include <glm/gtx/transform.hpp>
-//#include <QMultiMap>
-
 #include "CauterizedModel.h"
 
 #include <AbstractViewStateInterface.h>
@@ -21,7 +18,8 @@
 #include "CauterizedMeshPartPayload.h"
 
 
-CauterizedModel::CauterizedModel(RigPointer rig, QObject* parent) : Model(rig, parent) {
+CauterizedModel::CauterizedModel(RigPointer rig, QObject* parent) :
+        Model(rig, parent) {
 }
 
 CauterizedModel::~CauterizedModel() {
@@ -32,15 +30,64 @@ void CauterizedModel::deleteGeometry() {
 	_cauterizeMeshStates.clear();
 }
 
-// Called within Model::simulate call, below.
+bool CauterizedModel::updateGeometry() {
-void CauterizedModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
+    bool needsFullUpdate = Model::updateGeometry();
-    Model::updateRig(deltaTime, parentTransform);
+    if (_isCauterized && needsFullUpdate) {
-    _needsUpdateClusterMatrices = true;
+        assert(_cauterizeMeshStates.empty());
+        const FBXGeometry& fbxGeometry = getFBXGeometry();
+        foreach (const FBXMesh& mesh, fbxGeometry.meshes) {
+            Model::MeshState state;
+            state.clusterMatrices.resize(mesh.clusters.size());
+            _cauterizeMeshStates.append(state);
+        }
+    }
+	return needsFullUpdate;
 }
 
 void CauterizedModel::createVisibleRenderItemSet() {
-    // Temporary HACK: use base class method for now
+    if (_isCauterized) {
-	Model::createVisibleRenderItemSet();
+        assert(isLoaded());
+        const auto& meshes = _renderGeometry->getMeshes();
+
+        // all of our mesh vectors must match in size
+        if ((int)meshes.size() != _meshStates.size()) {
+            qCDebug(renderlogging) << "WARNING!!!! Mesh Sizes don't match! We will not segregate mesh groups yet.";
+            return;
+        }
+
+        // We should not have any existing renderItems if we enter this section of code
+        Q_ASSERT(_modelMeshRenderItemsSet.isEmpty());
+
+        _modelMeshRenderItemsSet.clear();
+
+        Transform transform;
+        transform.setTranslation(_translation);
+        transform.setRotation(_rotation);
+
+        Transform offset;
+        offset.setScale(_scale);
+        offset.postTranslate(_offset);
+
+        // Run through all of the meshes, and place them into their segregated, but unsorted buckets
+        int shapeID = 0;
+        uint32_t numMeshes = (uint32_t)meshes.size();
+        for (uint32_t i = 0; i < numMeshes; i++) {
+            const auto& mesh = meshes.at(i);
+            if (!mesh) {
+                continue;
+            }
+
+            // Create the render payloads
+            int numParts = (int)mesh->getNumParts();
+            for (int partIndex = 0; partIndex < numParts; partIndex++) {
+                auto ptr = std::make_shared<CauterizedMeshPartPayload>(this, i, partIndex, shapeID, transform, offset);
+                _modelMeshRenderItemsSet << std::static_pointer_cast<ModelMeshPartPayload>(ptr);
+                shapeID++;
+            }
+        }
+    } else {
+	    Model::createVisibleRenderItemSet();
+    }
 }
 
 void CauterizedModel::createCollisionRenderItemSet() {
@@ -48,19 +95,10 @@ void CauterizedModel::createCollisionRenderItemSet() {
 	Model::createCollisionRenderItemSet();
 }
 
-bool CauterizedModel::updateGeometry() {
+// Called within Model::simulate call, below.
-    bool needsFullUpdate = Model::updateGeometry();
+void CauterizedModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
-    if (needsFullUpdate) {
+    Model::updateRig(deltaTime, parentTransform);
-        if (_rig->jointStatesEmpty() && getFBXGeometry().joints.size() > 0) {
+    _needsUpdateClusterMatrices = true;
-            const FBXGeometry& fbxGeometry = getFBXGeometry();
-            foreach (const FBXMesh& mesh, fbxGeometry.meshes) {
-                Model::MeshState state;
-                state.clusterMatrices.resize(mesh.clusters.size());
-                _cauterizeMeshStates.append(state);
-            }
-        }
-    }
-	return needsFullUpdate;
 }
 
 void CauterizedModel::updateClusterMatrices() {
@@ -147,90 +185,71 @@ void CauterizedModel::updateClusterMatrices() {
 }
 
 void CauterizedModel::updateRenderItems() {
-    // Temporary HACK: use base class method for now
+    if (_isCauterized) {
-    Model::updateRenderItems();
+        if (!_addedToScene) {
-}
-
-#ifdef FOO
-// TODO: finish implementing this
-void CauterizedModel::updateRenderItems() {
-    if (!_addedToScene) {
-        return;
-    }
-
-    glm::vec3 scale = getScale();
-    if (_collisionGeometry) {
-        // _collisionGeometry is already scaled
-        scale = glm::vec3(1.0f);
-    }
-    _needsUpdateClusterMatrices = true;
-    _renderItemsNeedUpdate = false;
-
-    // queue up this work for later processing, at the end of update and just before rendering.
-    // the application will ensure only the last lambda is actually invoked.
-    void* key = (void*)this;
-    std::weak_ptr<Model> weakSelf = shared_from_this();
-    AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [weakSelf, scale]() {
-
-        // do nothing, if the model has already been destroyed.
-        auto self = weakSelf.lock();
-        if (!self) {
             return;
         }
 
-        render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
+        glm::vec3 scale = getScale();
-
+        if (_collisionGeometry) {
-        Transform modelTransform;
+            // _collisionGeometry is already scaled
-        modelTransform.setTranslation(self->getTranslation());
+            scale = glm::vec3(1.0f);
-        modelTransform.setRotation(self->getRotation());
-
-        Transform scaledModelTransform(modelTransform);
-        scaledModelTransform.setScale(scale);
-
-        uint32_t deleteGeometryCounter = self->getGeometryCounter();
-
-        // TODO: handle two cases:
-        // (a) our payloads are of type ModelMeshPartPayload
-        // (b) our payloads are of type ModelMeshPartPayload
-        render::PendingChanges pendingChanges;
-        QList<render::ItemID> keys = self->getRenderItems().keys();
-        foreach (auto itemID, keys) {
-            pendingChanges.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, deleteGeometryCounter](CauterizedMeshPartPayload& 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->getGeometryCounter()) {
-                        // 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();
-
-                        // update the model transform and bounding box for this render item.
-                        const Model::MeshState& state = data._model->getMeshState(data._meshIndex);
-                        CauterizedModel* cModel = static_cast<CauterizedModel*>(data._model);
-                        const Model::MeshState& cState = cModel->_cauterizeMeshStates.at(data._meshIndex);
-                        data.updateTransformForSkinnedCauterizedMesh(modelTransform, state.clusterMatrices, cState.clusterMatrices);
-                    }
-                }
-            });
         }
+        _needsUpdateClusterMatrices = true;
+        _renderItemsNeedUpdate = false;
 
-        /*
+        // queue up this work for later processing, at the end of update and just before rendering.
-        // collision mesh does not share the same unit scale as the FBX file's mesh: only apply offset
+        // the application will ensure only the last lambda is actually invoked.
-        Transform collisionMeshOffset;
+        void* key = (void*)this;
-        collisionMeshOffset.setIdentity();
+        std::weak_ptr<Model> weakSelf = shared_from_this();
-        foreach (auto itemID, self->_collisionRenderItems.keys()) {
+        AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [weakSelf, scale]() {
-            pendingChanges.updateItem<MeshPartPayload>(itemID, [scaledModelTransform, collisionMeshOffset](MeshPartPayload& data) {
+            // do nothing, if the model has already been destroyed.
-                // update the model transform for this render item.
+            auto self = weakSelf.lock();
-                data.updateTransform(scaledModelTransform, collisionMeshOffset);
+            if (!self) {
-            });
+                return;
-        }
+            }
-        */
 
-        scene->enqueuePendingChanges(pendingChanges);
+            render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
-    });
+
+            Transform modelTransform;
+            modelTransform.setTranslation(self->getTranslation());
+            modelTransform.setRotation(self->getRotation());
+
+            Transform scaledModelTransform(modelTransform);
+            scaledModelTransform.setScale(scale);
+
+            uint32_t deleteGeometryCounter = self->getGeometryCounter();
+
+            render::PendingChanges pendingChanges;
+            QList<render::ItemID> keys = self->getRenderItems().keys();
+            foreach (auto itemID, keys) {
+                pendingChanges.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, deleteGeometryCounter](CauterizedMeshPartPayload& 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->getGeometryCounter()) {
+                            // 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();
+
+                            // update the model transform and bounding box for this render item.
+                            const Model::MeshState& state = data._model->getMeshState(data._meshIndex);
+                            CauterizedModel* cModel = static_cast<CauterizedModel*>(data._model);
+                            assert(data._meshIndex < cModel->_cauterizeMeshStates.size());
+                            const Model::MeshState& cState = cModel->_cauterizeMeshStates.at(data._meshIndex);
+                            data.updateTransformForSkinnedCauterizedMesh(modelTransform, state.clusterMatrices, cState.clusterMatrices);
+                        }
+                    }
+                });
+            }
+
+            scene->enqueuePendingChanges(pendingChanges);
+        });
+    } else {
+        Model::updateRenderItems();
+    }
 }
-#endif // FOO
 
 const Model::MeshState& CauterizedModel::getCauterizeMeshState(int index) const {
     assert(index < _meshStates.size());

interface/src/avatar/CauterizedModel.h

@@ -22,19 +22,22 @@ public:
     CauterizedModel(RigPointer rig, QObject* parent);
     virtual ~CauterizedModel();
 
-	void deleteGeometry() override;
+    void flagAsCauterized() { _isCauterized = true; }
-    virtual void updateRig(float deltaTime, glm::mat4 parentTransform) override;
+    bool getIsCauterized() const { return _isCauterized; }
 
-    void setCauterizeBones(bool flag) { _cauterizeBones = flag; }
+    void setEnableCauterization(bool flag) { _enableCauterization = flag; }
-    bool getCauterizeBones() const { return _cauterizeBones; }
+    bool getEnableCauterization() const { return _enableCauterization; }
 
     const std::unordered_set<int>& getCauterizeBoneSet() const { return _cauterizeBoneSet; }
     void setCauterizeBoneSet(const std::unordered_set<int>& boneSet) { _cauterizeBoneSet = boneSet; }
 
+	void deleteGeometry() override;
+	bool updateGeometry() override;
+
 	void createVisibleRenderItemSet() override;
     void createCollisionRenderItemSet() override;
 
-	bool updateGeometry() override;
+    virtual void updateRig(float deltaTime, glm::mat4 parentTransform) override;
     virtual void updateClusterMatrices() override;
     void updateRenderItems() override;
 
@@ -43,7 +46,8 @@ public:
 protected:
     std::unordered_set<int> _cauterizeBoneSet;
 	QVector<Model::MeshState> _cauterizeMeshStates;
-    bool _cauterizeBones { false };
+    bool _isCauterized { false };
+    bool _enableCauterization { false };
 };
 
 #endif // hifi_CauterizedModel_h

interface/src/avatar/MyAvatar.cpp

@@ -116,12 +116,12 @@ MyAvatar::MyAvatar(RigPointer rig) :
     _hmdAtRestDetector(glm::vec3(0), glm::quat())
 {
     using namespace recording;
+    _skeletonModel->flagAsCauterized();
 
     for (int i = 0; i < MAX_DRIVE_KEYS; i++) {
         _driveKeys[i] = 0.0f;
     }
 
-
     // Necessary to select the correct slot
     using SlotType = void(MyAvatar::*)(const glm::vec3&, bool, const glm::quat&, bool);
 
@@ -1592,7 +1592,7 @@ void MyAvatar::preDisplaySide(RenderArgs* renderArgs) {
     // toggle using the cauterizedBones depending on where the camera is and the rendering pass type.
     const bool shouldDrawHead = shouldRenderHead(renderArgs);
     if (shouldDrawHead != _prevShouldDrawHead) {
-        _skeletonModel->setCauterizeBones(!shouldDrawHead);
+        _skeletonModel->setEnableCauterization(!shouldDrawHead);
     }
     _prevShouldDrawHead = shouldDrawHead;
 }

interface/src/avatar/SoftAttachmentModel.cpp

@@ -38,7 +38,6 @@ int SoftAttachmentModel::getJointIndexOverride(int i) const {
 // virtual
 // use the _rigOverride matrices instead of the Model::_rig
 void SoftAttachmentModel::updateClusterMatrices() {
-    // adebug TODO: this needs work?
     if (!_needsUpdateClusterMatrices) {
         return;
     }

libraries/render-utils/src/MeshPartPayload.cpp

@@ -370,6 +370,9 @@ void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& transf
             _worldBound += clusterBound;
         }
         _worldBound.transform(transform);
+    } else {
+        _worldBound = _localBound;
+        _worldBound.transform(_drawTransform);
     }
 }