From 455f2ad2776d50d84c83ac5e1f92ccd271e39ca9 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Wed, 1 Nov 2017 18:14:36 -0700
Subject: [PATCH 01/13] trying to change the root transorm update

---
 libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
index 142e57c9e5..f9f2fd868a 100644
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
+++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
@@ -728,8 +728,9 @@ void Avatar::simulateAttachments(float deltaTime) {
         glm::quat jointRotation;
         if (attachment.isSoft) {
             // soft attachments do not have transform offsets
-            model->setTranslation(getPosition());
-            model->setRotation(getOrientation() * Quaternions::Y_180);
+        //    model->setTranslation(getPosition());
+        //    model->setRotation(getOrientation() * Quaternions::Y_180);
+            model->setTransformNoUpdateRenderItems(Transform(getOrientation() * Quaternions::Y_180, glm::vec3(1.0), getPosition());
             model->simulate(deltaTime);
         } else {
             if (_skeletonModel->getJointPositionInWorldFrame(jointIndex, jointPosition) &&

From 56510abd1ebadf399ffb58a5aec1dba6622b1fcd Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Thu, 2 Nov 2017 03:45:27 -0700
Subject: [PATCH 02/13] Trying to set the ClusterBuffer in the render loop
 instead of the game loop

---
 .../src/avatars-renderer/Avatar.cpp           |  3 +-
 .../src/CauterizedMeshPartPayload.cpp         | 27 +++++++++-
 .../src/CauterizedMeshPartPayload.h           |  2 +
 .../render-utils/src/CauterizedModel.cpp      | 49 ++++++++++++++-----
 .../render-utils/src/MeshPartPayload.cpp      | 17 ++++++-
 libraries/render-utils/src/MeshPartPayload.h  |  1 +
 libraries/render-utils/src/Model.cpp          | 35 +++++++++----
 .../render-utils/src/SoftAttachmentModel.cpp  |  4 +-
 8 files changed, 112 insertions(+), 26 deletions(-)

diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
index f9f2fd868a..bbd0110c11 100644
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
+++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
@@ -730,8 +730,9 @@ void Avatar::simulateAttachments(float deltaTime) {
             // soft attachments do not have transform offsets
         //    model->setTranslation(getPosition());
         //    model->setRotation(getOrientation() * Quaternions::Y_180);
-            model->setTransformNoUpdateRenderItems(Transform(getOrientation() * Quaternions::Y_180, glm::vec3(1.0), getPosition());
+            model->setTransformNoUpdateRenderItems(Transform(getOrientation() * Quaternions::Y_180, glm::vec3(1.0), getPosition()));
             model->simulate(deltaTime);
+            model->updateRenderItems();
         } else {
             if (_skeletonModel->getJointPositionInWorldFrame(jointIndex, jointPosition) &&
                 _skeletonModel->getJointRotationInWorldFrame(jointIndex, jointRotation)) {
diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
index 07628904f1..068eb03378 100644
--- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
+++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
@@ -20,11 +20,36 @@ using namespace render;
 CauterizedMeshPartPayload::CauterizedMeshPartPayload(ModelPointer model, int meshIndex, int partIndex, int shapeIndex, const Transform& transform, const Transform& offsetTransform)
     : ModelMeshPartPayload(model, meshIndex, partIndex, shapeIndex, transform, offsetTransform) {}
 
+void CauterizedMeshPartPayload::updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices, const QVector<glm::mat4>& cauterizedClusterMatrices) {
+
+    // Once computed the cluster matrices, update the buffer(s)
+    if (clusterMatrices.size() > 1) {
+        if (!_clusterBuffer) {
+            _clusterBuffer = std::make_shared<gpu::Buffer>(clusterMatrices.size() * sizeof(glm::mat4),
+            (const gpu::Byte*) clusterMatrices.constData());
+        } else {
+            _clusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
+            (const gpu::Byte*) clusterMatrices.constData());
+        }
+    }
+
+    if (cauterizedClusterMatrices.size() > 1) {
+        if (!_cauterizedClusterBuffer) {
+            _cauterizedClusterBuffer = std::make_shared<gpu::Buffer>(cauterizedClusterMatrices.size() * sizeof(glm::mat4),
+                (const gpu::Byte*) cauterizedClusterMatrices.constData());
+        }
+        else {
+            _cauterizedClusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
+                (const gpu::Byte*) clusterMatrices.constData());
+        }
+    }
+}
+
 void CauterizedMeshPartPayload::updateTransformForCauterizedMesh(
         const Transform& renderTransform,
         const gpu::BufferPointer& buffer) {
     _cauterizedTransform = renderTransform;
-    _cauterizedClusterBuffer = buffer;
+  //  _cauterizedClusterBuffer = buffer;
 }
 
 void CauterizedMeshPartPayload::bindTransform(gpu::Batch& batch, const render::ShapePipeline::LocationsPointer locations, RenderArgs::RenderMode renderMode) const {
diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.h b/libraries/render-utils/src/CauterizedMeshPartPayload.h
index 5e3135ea84..4bd20461eb 100644
--- a/libraries/render-utils/src/CauterizedMeshPartPayload.h
+++ b/libraries/render-utils/src/CauterizedMeshPartPayload.h
@@ -15,6 +15,8 @@ class CauterizedMeshPartPayload : public ModelMeshPartPayload {
 public:
     CauterizedMeshPartPayload(ModelPointer model, int meshIndex, int partIndex, int shapeIndex, const Transform& transform, const Transform& offsetTransform);
 
+    void updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices, const QVector<glm::mat4>& cauterizedClusterMatrices);
+
     void updateTransformForCauterizedMesh(const Transform& renderTransform, const gpu::BufferPointer& buffer);
 
     void bindTransform(gpu::Batch& batch, const render::ShapePipeline::LocationsPointer locations, RenderArgs::RenderMode renderMode) const override;
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 47ada457a0..28993dd4f0 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -111,6 +111,7 @@ void CauterizedModel::updateClusterMatrices() {
             glm_mat4u_mul(jointMatrix, cluster.inverseBindMatrix, state.clusterMatrices[j]);
         }
 
+        /*
         // Once computed the cluster matrices, update the buffer(s)
         if (mesh.clusters.size() > 1) {
             if (!state.clusterBuffer) {
@@ -121,6 +122,7 @@ void CauterizedModel::updateClusterMatrices() {
                                                 (const gpu::Byte*) state.clusterMatrices.constData());
             }
         }
+        */
     }
 
     // as an optimization, don't build cautrizedClusterMatrices if the boneSet is empty.
@@ -143,7 +145,7 @@ void CauterizedModel::updateClusterMatrices() {
                 }
                 glm_mat4u_mul(jointMatrix, cluster.inverseBindMatrix, state.clusterMatrices[j]);
             }
-
+/*
             if (!_cauterizeBoneSet.empty() && (state.clusterMatrices.size() > 1)) {
                 if (!state.clusterBuffer) {
                     state.clusterBuffer =
@@ -153,7 +155,7 @@ void CauterizedModel::updateClusterMatrices() {
                     state.clusterBuffer->setSubData(0, state.clusterMatrices.size() * sizeof(glm::mat4),
                                                               (const gpu::Byte*) state.clusterMatrices.constData());
                 }
-            }
+            }*/
         }
     }
 
@@ -181,7 +183,7 @@ void CauterizedModel::updateRenderItems() {
         // 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();
+        std::weak_ptr<CauterizedModel> weakSelf = std::dynamic_pointer_cast<CauterizedModel>(shared_from_this());
         AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [weakSelf, scale]() {
             // do nothing, if the model has already been destroyed.
             auto self = weakSelf.lock();
@@ -203,33 +205,58 @@ void CauterizedModel::updateRenderItems() {
 
             uint32_t deleteGeometryCounter = self->getGeometryCounter();
 
+            if (!self->isLoaded()) {
+                return;
+            }
             render::Transaction transaction;
             QList<render::ItemID> keys = self->getRenderItems().keys();
+            int meshIndex{ 0 };
             foreach (auto itemID, keys) {
-                transaction.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, deleteGeometryCounter](CauterizedMeshPartPayload& data) {
-                    ModelPointer model = data._model.lock();
-                    if (model && model->isLoaded()) {
+                const Model::MeshState& state = self->getMeshState(meshIndex);
+                auto clusterMatrices(state.clusterMatrices);
+                const Model::MeshState& cState = self->getCauterizeMeshState(meshIndex);
+                auto clusterMatricesCauterized(cState.clusterMatrices);
+
+                transaction.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, deleteGeometryCounter, clusterMatrices, clusterMatricesCauterized](CauterizedMeshPartPayload& data) {
+                 //   ModelPointer model = data._model.lock();
+                 //   if (model && model->isLoaded()) {
                         // Ensure the model geometry was not reset between frames
-                        if (deleteGeometryCounter == model->getGeometryCounter()) {
+                  //      if (deleteGeometryCounter == model->getGeometryCounter()) {
+                            data.updateClusterBuffer(clusterMatrices, clusterMatricesCauterized);
+
                             // this stuff identical to what happens in regular Model
-                            const Model::MeshState& state = model->getMeshState(data._meshIndex);
+                            /*const Model::MeshState& state = model->getMeshState(data._meshIndex);
                             Transform renderTransform = modelTransform;
                             if (state.clusterMatrices.size() == 1) {
                                 renderTransform = modelTransform.worldTransform(Transform(state.clusterMatrices[0]));
                             }
                             data.updateTransformForSkinnedMesh(renderTransform, modelTransform, state.clusterBuffer);
+                            */
+                            Transform renderTransform = modelTransform;
+                            if (clusterMatrices.size() == 1) {
+                                renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
+                            }
+                            data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
+
 
                             // this stuff for cauterized mesh
-                            CauterizedModel* cModel = static_cast<CauterizedModel*>(model.get());
+                            /*CauterizedModel* cModel = static_cast<CauterizedModel*>(model.get());
                             const Model::MeshState& cState = cModel->getCauterizeMeshState(data._meshIndex);
                             renderTransform = modelTransform;
                             if (cState.clusterMatrices.size() == 1) {
                                 renderTransform = modelTransform.worldTransform(Transform(cState.clusterMatrices[0]));
                             }
                             data.updateTransformForCauterizedMesh(renderTransform, cState.clusterBuffer);
-                        }
-                    }
+                            */
+                            renderTransform = modelTransform;
+                            if (clusterMatricesCauterized.size() == 1) {
+                                renderTransform = modelTransform.worldTransform(Transform(clusterMatricesCauterized[0]));
+                            }
+                            data.updateTransformForCauterizedMesh(renderTransform, nullptr);
+                   //     }
+                   // }
                 });
+                meshIndex++;
             }
 
             scene->enqueueTransaction(transaction);
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index 8b65c9f7ce..abb0d299e1 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -367,12 +367,27 @@ void ModelMeshPartPayload::notifyLocationChanged() {
 
 }
 
+
+void ModelMeshPartPayload::updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices) {
+    // Once computed the cluster matrices, update the buffer(s)
+    if (clusterMatrices.size() > 1) {
+        if (!_clusterBuffer) {
+            _clusterBuffer = std::make_shared<gpu::Buffer>(clusterMatrices.size() * sizeof(glm::mat4),
+                (const gpu::Byte*) clusterMatrices.constData());
+        }
+        else {
+            _clusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
+                (const gpu::Byte*) clusterMatrices.constData());
+        }
+    }
+}
+
 void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& renderTransform, const Transform& boundTransform,
         const gpu::BufferPointer& buffer) {
     _transform = renderTransform;
     _worldBound = _adjustedLocalBound;
     _worldBound.transform(boundTransform);
-    _clusterBuffer = buffer;
+ //   _clusterBuffer = buffer;
 }
 
 ItemKey ModelMeshPartPayload::getKey() const {
diff --git a/libraries/render-utils/src/MeshPartPayload.h b/libraries/render-utils/src/MeshPartPayload.h
index 99c14510b5..0e8464f873 100644
--- a/libraries/render-utils/src/MeshPartPayload.h
+++ b/libraries/render-utils/src/MeshPartPayload.h
@@ -87,6 +87,7 @@ public:
     typedef Payload::DataPointer Pointer;
 
     void notifyLocationChanged() override;
+    void updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices);
     void updateTransformForSkinnedMesh(const Transform& renderTransform,
             const Transform& boundTransform,
             const gpu::BufferPointer& buffer);
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 97f62a3ce0..cbb27f0498 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -240,22 +240,37 @@ void Model::updateRenderItems() {
         uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
 
         render::Transaction transaction;
+        int meshIndex{ 0 };
         foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter, modelTransform](ModelMeshPartPayload& data) {
-                ModelPointer model = data._model.lock();
-                if (model && model->isLoaded()) {
-                    // Ensure the model geometry was not reset between frames
-                    if (deleteGeometryCounter == model->_deleteGeometryCounter) {
+            const Model::MeshState& state = self->getMeshState(meshIndex);
+            auto clusterMatrices(state.clusterMatrices);
 
-                        const Model::MeshState& state = model->getMeshState(data._meshIndex);
+            transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter, modelTransform, clusterMatrices](ModelMeshPartPayload& data) {
+              //  ModelPointer model = data._model.lock();
+             //   if (model && model->isLoaded()) {
+                    // Ensure the model geometry was not reset between frames
+               //     if (deleteGeometryCounter == model->_deleteGeometryCounter) {
+
+                        /*const Model::MeshState& state = model->getMeshState(data._meshIndex);
                         Transform renderTransform = modelTransform;
                         if (state.clusterMatrices.size() == 1) {
                             renderTransform = modelTransform.worldTransform(Transform(state.clusterMatrices[0]));
                         }
                         data.updateTransformForSkinnedMesh(renderTransform, modelTransform, state.clusterBuffer);
-                    }
-                }
+                        */
+                        
+                        data.updateClusterBuffer(clusterMatrices);
+
+                        Transform renderTransform = modelTransform;
+                        if (clusterMatrices.size() == 1) {
+                            renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
+                        }
+                        data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
+
+                  //  }
+               // }
             });
+            meshIndex++;
         }
 
         Transform collisionMeshOffset;
@@ -1136,7 +1151,7 @@ void Model::updateClusterMatrices() {
             glm_mat4u_mul(jointMatrix, cluster.inverseBindMatrix, state.clusterMatrices[j]);
         }
 
-        // Once computed the cluster matrices, update the buffer(s)
+      /*  // Once computed the cluster matrices, update the buffer(s)
         if (mesh.clusters.size() > 1) {
             if (!state.clusterBuffer) {
                 state.clusterBuffer = std::make_shared<gpu::Buffer>(state.clusterMatrices.size() * sizeof(glm::mat4),
@@ -1145,7 +1160,7 @@ void Model::updateClusterMatrices() {
                 state.clusterBuffer->setSubData(0, state.clusterMatrices.size() * sizeof(glm::mat4),
                                                 (const gpu::Byte*) state.clusterMatrices.constData());
             }
-        }
+        }*/
     }
 
     // post the blender if we're not currently waiting for one to finish
diff --git a/libraries/render-utils/src/SoftAttachmentModel.cpp b/libraries/render-utils/src/SoftAttachmentModel.cpp
index 63b18d49b8..975d099ac3 100644
--- a/libraries/render-utils/src/SoftAttachmentModel.cpp
+++ b/libraries/render-utils/src/SoftAttachmentModel.cpp
@@ -62,7 +62,7 @@ void SoftAttachmentModel::updateClusterMatrices() {
         }
 
         // Once computed the cluster matrices, update the buffer(s)
-        if (mesh.clusters.size() > 1) {
+     /*   if (mesh.clusters.size() > 1) {
             if (!state.clusterBuffer) {
                 state.clusterBuffer = std::make_shared<gpu::Buffer>(state.clusterMatrices.size() * sizeof(glm::mat4),
                                                                     (const gpu::Byte*) state.clusterMatrices.constData());
@@ -70,7 +70,7 @@ void SoftAttachmentModel::updateClusterMatrices() {
                 state.clusterBuffer->setSubData(0, state.clusterMatrices.size() * sizeof(glm::mat4),
                                                 (const gpu::Byte*) state.clusterMatrices.constData());
             }
-        }
+        }*/
     }
 
     // post the blender if we're not currently waiting for one to finish

From 83bfa1c5f26805291bdd60bdf61ea07d1f3307b1 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Thu, 2 Nov 2017 17:57:46 -0700
Subject: [PATCH 03/13] Progressing on the cluster updates

---
 .../render-utils/src/CauterizedModel.cpp      |  3 +-
 libraries/render-utils/src/Model.cpp          | 58 ++++++++++---------
 libraries/render-utils/src/Model.h            |  1 -
 3 files changed, 34 insertions(+), 28 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 28993dd4f0..71f161038c 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -211,7 +211,8 @@ void CauterizedModel::updateRenderItems() {
             render::Transaction transaction;
             QList<render::ItemID> keys = self->getRenderItems().keys();
             int meshIndex{ 0 };
-            foreach (auto itemID, keys) {
+            //foreach (auto itemID, keys) {
+            for (auto itemID : self->_modelMeshRenderItemIDs) {
                 const Model::MeshState& state = self->getMeshState(meshIndex);
                 auto clusterMatrices(state.clusterMatrices);
                 const Model::MeshState& cState = self->getCauterizeMeshState(meshIndex);
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index cbb27f0498..b999283fad 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -218,6 +218,10 @@ void Model::updateRenderItems() {
     _needsUpdateClusterMatrices = true;
     _renderItemsNeedUpdate = false;
 
+    if (_modelMeshRenderItemIDs.size() != _meshStates.size()) {
+        return;
+    }
+
     // 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;
@@ -240,37 +244,39 @@ void Model::updateRenderItems() {
         uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
 
         render::Transaction transaction;
-        int meshIndex{ 0 };
         foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
-            const Model::MeshState& state = self->getMeshState(meshIndex);
-            auto clusterMatrices(state.clusterMatrices);
+      //  for (auto itemID : self->_modelMeshRenderItemIDs) {
+            if (self && self->isLoaded()) {
+                int meshIndex = std::dynamic_pointer_cast<ModelMeshPartPayload>(self->_modelMeshRenderItemsMap[itemID])->_meshIndex;
+                const Model::MeshState& state = self->getMeshState(meshIndex);
+                auto clusterMatrices(state.clusterMatrices);
 
-            transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter, modelTransform, clusterMatrices](ModelMeshPartPayload& data) {
-              //  ModelPointer model = data._model.lock();
-             //   if (model && model->isLoaded()) {
-                    // Ensure the model geometry was not reset between frames
-               //     if (deleteGeometryCounter == model->_deleteGeometryCounter) {
+                transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter, modelTransform, clusterMatrices](ModelMeshPartPayload& data) {
+                    //  ModelPointer model = data._model.lock();
+                   //   if (model && model->isLoaded()) {
+                          // Ensure the model geometry was not reset between frames
+                     //     if (deleteGeometryCounter == model->_deleteGeometryCounter) {
 
-                        /*const Model::MeshState& state = model->getMeshState(data._meshIndex);
-                        Transform renderTransform = modelTransform;
-                        if (state.clusterMatrices.size() == 1) {
-                            renderTransform = modelTransform.worldTransform(Transform(state.clusterMatrices[0]));
-                        }
-                        data.updateTransformForSkinnedMesh(renderTransform, modelTransform, state.clusterBuffer);
-                        */
-                        
-                        data.updateClusterBuffer(clusterMatrices);
+                              /*const Model::MeshState& state = model->getMeshState(data._meshIndex);
+                              Transform renderTransform = modelTransform;
+                              if (state.clusterMatrices.size() == 1) {
+                                  renderTransform = modelTransform.worldTransform(Transform(state.clusterMatrices[0]));
+                              }
+                              data.updateTransformForSkinnedMesh(renderTransform, modelTransform, state.clusterBuffer);
+                              */
 
-                        Transform renderTransform = modelTransform;
-                        if (clusterMatrices.size() == 1) {
-                            renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
-                        }
-                        data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
+                    data.updateClusterBuffer(clusterMatrices);
 
-                  //  }
-               // }
-            });
-            meshIndex++;
+                    Transform renderTransform = modelTransform;
+                    if (clusterMatrices.size() == 1) {
+                        renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
+                    }
+                    data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
+
+                    //  }
+                 // }
+                });
+            }
         }
 
         Transform collisionMeshOffset;
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index 8bce976b4e..2854f1b1b0 100644
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@@ -387,7 +387,6 @@ protected:
 
     QVector<std::shared_ptr<ModelMeshPartPayload>> _modelMeshRenderItems;
     QMap<render::ItemID, render::PayloadPointer> _modelMeshRenderItemsMap;
-
     render::ItemIDs _modelMeshRenderItemIDs;
 
     bool _addedToScene { false }; // has been added to scene

From d33c75865eb24af29ccb1dccf01cacf332debb90 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Thu, 2 Nov 2017 18:11:13 -0700
Subject: [PATCH 04/13] Removing unecessary test

---
 libraries/render-utils/src/Model.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index b999283fad..1f53ed731a 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -218,9 +218,6 @@ void Model::updateRenderItems() {
     _needsUpdateClusterMatrices = true;
     _renderItemsNeedUpdate = false;
 
-    if (_modelMeshRenderItemIDs.size() != _meshStates.size()) {
-        return;
-    }
 
     // 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.

From f097d66721f971b8c71c9eeda4b1c9e1da977f8a Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Thu, 2 Nov 2017 19:49:01 -0700
Subject: [PATCH 05/13] YEp it s working

---
 libraries/render-utils/src/CauterizedModel.cpp |  8 +++++++-
 libraries/render-utils/src/Model.cpp           | 11 +++++++++--
 libraries/render-utils/src/Model.h             |  2 ++
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 71f161038c..01e6a830eb 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -57,6 +57,7 @@ void CauterizedModel::createVisibleRenderItemSet() {
         Q_ASSERT(_modelMeshRenderItems.isEmpty());
 
         _modelMeshRenderItems.clear();
+        _modelMeshRenderItemShapes.clear();
 
         Transform transform;
         transform.setTranslation(_translation);
@@ -80,6 +81,7 @@ void CauterizedModel::createVisibleRenderItemSet() {
             for (int partIndex = 0; partIndex < numParts; partIndex++) {
                 auto ptr = std::make_shared<CauterizedMeshPartPayload>(shared_from_this(), i, partIndex, shapeID, transform, offset);
                 _modelMeshRenderItems << std::static_pointer_cast<ModelMeshPartPayload>(ptr);
+                _modelMeshRenderItemShapes.emplace_back(ShapeInfo{ (int)i });
                 shapeID++;
             }
         }
@@ -212,7 +214,11 @@ void CauterizedModel::updateRenderItems() {
             QList<render::ItemID> keys = self->getRenderItems().keys();
             int meshIndex{ 0 };
             //foreach (auto itemID, keys) {
-            for (auto itemID : self->_modelMeshRenderItemIDs) {
+          //  for (auto itemID : self->_modelMeshRenderItemIDs) {
+            for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
+                auto itemID = self->_modelMeshRenderItemIDs[i];
+                auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
+
                 const Model::MeshState& state = self->getMeshState(meshIndex);
                 auto clusterMatrices(state.clusterMatrices);
                 const Model::MeshState& cState = self->getCauterizeMeshState(meshIndex);
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 1f53ed731a..9b337b3662 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -241,10 +241,14 @@ void Model::updateRenderItems() {
         uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
 
         render::Transaction transaction;
-        foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
+      //  foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
       //  for (auto itemID : self->_modelMeshRenderItemIDs) {
+        for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
+            auto itemID = self->_modelMeshRenderItemIDs[i];
+            auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
             if (self && self->isLoaded()) {
-                int meshIndex = std::dynamic_pointer_cast<ModelMeshPartPayload>(self->_modelMeshRenderItemsMap[itemID])->_meshIndex;
+                //int meshIndex = std::dynamic_pointer_cast<ModelMeshPartPayload>(self->_modelMeshRenderItemsMap[itemID])->_meshIndex;
+             //   int meshIndex = std::dynamic_pointer_cast<ModelMeshPartPayload>(self->_modelMeshRenderItemsMap[itemID])->_meshIndex;
                 const Model::MeshState& state = self->getMeshState(meshIndex);
                 auto clusterMatrices(state.clusterMatrices);
 
@@ -704,6 +708,7 @@ void Model::removeFromScene(const render::ScenePointer& scene, render::Transacti
     _modelMeshRenderItemIDs.clear();
     _modelMeshRenderItemsMap.clear();
     _modelMeshRenderItems.clear();
+    _modelMeshRenderItemShapes.clear();
 
     foreach(auto item, _collisionRenderItemsMap.keys()) {
         transaction.removeItem(item);
@@ -1282,6 +1287,7 @@ void Model::createVisibleRenderItemSet() {
     Q_ASSERT(_modelMeshRenderItems.isEmpty());
 
     _modelMeshRenderItems.clear();
+    _modelMeshRenderItemShapes.clear();
 
     Transform transform;
     transform.setTranslation(_translation);
@@ -1304,6 +1310,7 @@ void Model::createVisibleRenderItemSet() {
         int numParts = (int)mesh->getNumParts();
         for (int partIndex = 0; partIndex < numParts; partIndex++) {
             _modelMeshRenderItems << std::make_shared<ModelMeshPartPayload>(shared_from_this(), i, partIndex, shapeID, transform, offset);
+            _modelMeshRenderItemShapes.emplace_back(ShapeInfo{ (int)i });
             shapeID++;
         }
     }
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index 2854f1b1b0..aed647e714 100644
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@@ -388,6 +388,8 @@ protected:
     QVector<std::shared_ptr<ModelMeshPartPayload>> _modelMeshRenderItems;
     QMap<render::ItemID, render::PayloadPointer> _modelMeshRenderItemsMap;
     render::ItemIDs _modelMeshRenderItemIDs;
+    using ShapeInfo = struct { int meshIndex; };
+    std::vector<ShapeInfo> _modelMeshRenderItemShapes;
 
     bool _addedToScene { false }; // has been added to scene
     bool _needsFixupInScene { true }; // needs to be removed/re-added to scene

From 421aacd8ebb96e0125fa3837cce6c26263fef030 Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Thu, 2 Nov 2017 22:45:19 -0700
Subject: [PATCH 06/13] Yes

---
 .../render-utils/src/CauterizedModel.cpp      | 63 +++++--------------
 libraries/render-utils/src/Model.cpp          | 20 ------
 .../render-utils/src/SoftAttachmentModel.cpp  | 11 ----
 3 files changed, 16 insertions(+), 78 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 01e6a830eb..b2cf5093d5 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -186,7 +186,7 @@ void CauterizedModel::updateRenderItems() {
         // the application will ensure only the last lambda is actually invoked.
         void* key = (void*)this;
         std::weak_ptr<CauterizedModel> weakSelf = std::dynamic_pointer_cast<CauterizedModel>(shared_from_this());
-        AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [weakSelf, scale]() {
+        AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [weakSelf]() {
             // do nothing, if the model has already been destroyed.
             auto self = weakSelf.lock();
             if (!self) {
@@ -202,19 +202,12 @@ void CauterizedModel::updateRenderItems() {
             modelTransform.setTranslation(self->getTranslation());
             modelTransform.setRotation(self->getRotation());
 
-            Transform scaledModelTransform(modelTransform);
-            scaledModelTransform.setScale(scale);
-
-            uint32_t deleteGeometryCounter = self->getGeometryCounter();
-
-            if (!self->isLoaded()) {
+       /*     if (!self->isLoaded()) {
                 return;
-            }
+            }*/
             render::Transaction transaction;
             QList<render::ItemID> keys = self->getRenderItems().keys();
             int meshIndex{ 0 };
-            //foreach (auto itemID, keys) {
-          //  for (auto itemID : self->_modelMeshRenderItemIDs) {
             for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
                 auto itemID = self->_modelMeshRenderItemIDs[i];
                 auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
@@ -224,46 +217,22 @@ void CauterizedModel::updateRenderItems() {
                 const Model::MeshState& cState = self->getCauterizeMeshState(meshIndex);
                 auto clusterMatricesCauterized(cState.clusterMatrices);
 
-                transaction.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, deleteGeometryCounter, clusterMatrices, clusterMatricesCauterized](CauterizedMeshPartPayload& data) {
-                 //   ModelPointer model = data._model.lock();
-                 //   if (model && model->isLoaded()) {
-                        // Ensure the model geometry was not reset between frames
-                  //      if (deleteGeometryCounter == model->getGeometryCounter()) {
-                            data.updateClusterBuffer(clusterMatrices, clusterMatricesCauterized);
+                transaction.updateItem<CauterizedMeshPartPayload>(itemID, 
+                    [modelTransform, clusterMatrices, clusterMatricesCauterized](CauterizedMeshPartPayload& data) {
+                        data.updateClusterBuffer(clusterMatrices, clusterMatricesCauterized);
 
-                            // this stuff identical to what happens in regular Model
-                            /*const Model::MeshState& state = model->getMeshState(data._meshIndex);
-                            Transform renderTransform = modelTransform;
-                            if (state.clusterMatrices.size() == 1) {
-                                renderTransform = modelTransform.worldTransform(Transform(state.clusterMatrices[0]));
-                            }
-                            data.updateTransformForSkinnedMesh(renderTransform, modelTransform, state.clusterBuffer);
-                            */
-                            Transform renderTransform = modelTransform;
-                            if (clusterMatrices.size() == 1) {
-                                renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
-                            }
-                            data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
+                        Transform renderTransform = modelTransform;
+                        if (clusterMatrices.size() == 1) {
+                            renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
+                        }
+                        data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
 
-
-                            // this stuff for cauterized mesh
-                            /*CauterizedModel* cModel = static_cast<CauterizedModel*>(model.get());
-                            const Model::MeshState& cState = cModel->getCauterizeMeshState(data._meshIndex);
-                            renderTransform = modelTransform;
-                            if (cState.clusterMatrices.size() == 1) {
-                                renderTransform = modelTransform.worldTransform(Transform(cState.clusterMatrices[0]));
-                            }
-                            data.updateTransformForCauterizedMesh(renderTransform, cState.clusterBuffer);
-                            */
-                            renderTransform = modelTransform;
-                            if (clusterMatricesCauterized.size() == 1) {
-                                renderTransform = modelTransform.worldTransform(Transform(clusterMatricesCauterized[0]));
-                            }
-                            data.updateTransformForCauterizedMesh(renderTransform, nullptr);
-                   //     }
-                   // }
+                        renderTransform = modelTransform;
+                        if (clusterMatricesCauterized.size() == 1) {
+                            renderTransform = modelTransform.worldTransform(Transform(clusterMatricesCauterized[0]));
+                        }
+                        data.updateTransformForCauterizedMesh(renderTransform, nullptr);
                 });
-                meshIndex++;
             }
 
             scene->enqueueTransaction(transaction);
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 9b337b3662..4add6fb5ba 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -241,31 +241,14 @@ void Model::updateRenderItems() {
         uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
 
         render::Transaction transaction;
-      //  foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
-      //  for (auto itemID : self->_modelMeshRenderItemIDs) {
         for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
             auto itemID = self->_modelMeshRenderItemIDs[i];
             auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
             if (self && self->isLoaded()) {
-                //int meshIndex = std::dynamic_pointer_cast<ModelMeshPartPayload>(self->_modelMeshRenderItemsMap[itemID])->_meshIndex;
-             //   int meshIndex = std::dynamic_pointer_cast<ModelMeshPartPayload>(self->_modelMeshRenderItemsMap[itemID])->_meshIndex;
                 const Model::MeshState& state = self->getMeshState(meshIndex);
                 auto clusterMatrices(state.clusterMatrices);
 
                 transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter, modelTransform, clusterMatrices](ModelMeshPartPayload& data) {
-                    //  ModelPointer model = data._model.lock();
-                   //   if (model && model->isLoaded()) {
-                          // Ensure the model geometry was not reset between frames
-                     //     if (deleteGeometryCounter == model->_deleteGeometryCounter) {
-
-                              /*const Model::MeshState& state = model->getMeshState(data._meshIndex);
-                              Transform renderTransform = modelTransform;
-                              if (state.clusterMatrices.size() == 1) {
-                                  renderTransform = modelTransform.worldTransform(Transform(state.clusterMatrices[0]));
-                              }
-                              data.updateTransformForSkinnedMesh(renderTransform, modelTransform, state.clusterBuffer);
-                              */
-
                     data.updateClusterBuffer(clusterMatrices);
 
                     Transform renderTransform = modelTransform;
@@ -273,9 +256,6 @@ void Model::updateRenderItems() {
                         renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
                     }
                     data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
-
-                    //  }
-                 // }
                 });
             }
         }
diff --git a/libraries/render-utils/src/SoftAttachmentModel.cpp b/libraries/render-utils/src/SoftAttachmentModel.cpp
index 975d099ac3..f364e9c037 100644
--- a/libraries/render-utils/src/SoftAttachmentModel.cpp
+++ b/libraries/render-utils/src/SoftAttachmentModel.cpp
@@ -60,17 +60,6 @@ void SoftAttachmentModel::updateClusterMatrices() {
             }
             glm_mat4u_mul(jointMatrix, cluster.inverseBindMatrix, state.clusterMatrices[j]);
         }
-
-        // Once computed the cluster matrices, update the buffer(s)
-     /*   if (mesh.clusters.size() > 1) {
-            if (!state.clusterBuffer) {
-                state.clusterBuffer = std::make_shared<gpu::Buffer>(state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                                    (const gpu::Byte*) state.clusterMatrices.constData());
-            } else {
-                state.clusterBuffer->setSubData(0, state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                (const gpu::Byte*) state.clusterMatrices.constData());
-            }
-        }*/
     }
 
     // post the blender if we're not currently waiting for one to finish

From c11f46a8d3fdf01ad5d5b78bb5db8b7978360b98 Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Thu, 2 Nov 2017 23:35:18 -0700
Subject: [PATCH 07/13] cleaning more code

---
 .../src/CauterizedMeshPartPayload.cpp         | 15 ++++-----
 .../src/CauterizedMeshPartPayload.h           |  4 +--
 .../render-utils/src/CauterizedModel.cpp      | 31 ++-----------------
 .../render-utils/src/MeshPartPayload.cpp      | 15 ++++-----
 libraries/render-utils/src/MeshPartPayload.h  |  8 ++---
 libraries/render-utils/src/Model.cpp          | 17 ++--------
 libraries/render-utils/src/Model.h            |  5 ++-
 7 files changed, 24 insertions(+), 71 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
index 068eb03378..a54a072b75 100644
--- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
+++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
@@ -20,36 +20,33 @@ using namespace render;
 CauterizedMeshPartPayload::CauterizedMeshPartPayload(ModelPointer model, int meshIndex, int partIndex, int shapeIndex, const Transform& transform, const Transform& offsetTransform)
     : ModelMeshPartPayload(model, meshIndex, partIndex, shapeIndex, transform, offsetTransform) {}
 
-void CauterizedMeshPartPayload::updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices, const QVector<glm::mat4>& cauterizedClusterMatrices) {
+void CauterizedMeshPartPayload::updateClusterBuffer(const std::vector<glm::mat4>& clusterMatrices, const std::vector<glm::mat4>& cauterizedClusterMatrices) {
 
     // Once computed the cluster matrices, update the buffer(s)
     if (clusterMatrices.size() > 1) {
         if (!_clusterBuffer) {
             _clusterBuffer = std::make_shared<gpu::Buffer>(clusterMatrices.size() * sizeof(glm::mat4),
-            (const gpu::Byte*) clusterMatrices.constData());
+            (const gpu::Byte*) clusterMatrices.data());
         } else {
             _clusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
-            (const gpu::Byte*) clusterMatrices.constData());
+            (const gpu::Byte*) clusterMatrices.data());
         }
     }
 
     if (cauterizedClusterMatrices.size() > 1) {
         if (!_cauterizedClusterBuffer) {
             _cauterizedClusterBuffer = std::make_shared<gpu::Buffer>(cauterizedClusterMatrices.size() * sizeof(glm::mat4),
-                (const gpu::Byte*) cauterizedClusterMatrices.constData());
+                (const gpu::Byte*) cauterizedClusterMatrices.data());
         }
         else {
             _cauterizedClusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
-                (const gpu::Byte*) clusterMatrices.constData());
+                (const gpu::Byte*) clusterMatrices.data());
         }
     }
 }
 
-void CauterizedMeshPartPayload::updateTransformForCauterizedMesh(
-        const Transform& renderTransform,
-        const gpu::BufferPointer& buffer) {
+void CauterizedMeshPartPayload::updateTransformForCauterizedMesh(const Transform& renderTransform) {
     _cauterizedTransform = renderTransform;
-  //  _cauterizedClusterBuffer = buffer;
 }
 
 void CauterizedMeshPartPayload::bindTransform(gpu::Batch& batch, const render::ShapePipeline::LocationsPointer locations, RenderArgs::RenderMode renderMode) const {
diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.h b/libraries/render-utils/src/CauterizedMeshPartPayload.h
index 4bd20461eb..1c98f5abf3 100644
--- a/libraries/render-utils/src/CauterizedMeshPartPayload.h
+++ b/libraries/render-utils/src/CauterizedMeshPartPayload.h
@@ -15,9 +15,9 @@ class CauterizedMeshPartPayload : public ModelMeshPartPayload {
 public:
     CauterizedMeshPartPayload(ModelPointer model, int meshIndex, int partIndex, int shapeIndex, const Transform& transform, const Transform& offsetTransform);
 
-    void updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices, const QVector<glm::mat4>& cauterizedClusterMatrices);
+    void updateClusterBuffer(const std::vector<glm::mat4>& clusterMatrices, const std::vector<glm::mat4>& cauterizedClusterMatrices);
 
-    void updateTransformForCauterizedMesh(const Transform& renderTransform, const gpu::BufferPointer& buffer);
+    void updateTransformForCauterizedMesh(const Transform& renderTransform);
 
     void bindTransform(gpu::Batch& batch, const render::ShapePipeline::LocationsPointer locations, RenderArgs::RenderMode renderMode) const override;
 
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index b2cf5093d5..776de727b4 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -112,19 +112,6 @@ void CauterizedModel::updateClusterMatrices() {
             auto jointMatrix = _rig.getJointTransform(cluster.jointIndex);
             glm_mat4u_mul(jointMatrix, cluster.inverseBindMatrix, state.clusterMatrices[j]);
         }
-
-        /*
-        // Once computed the cluster matrices, update the buffer(s)
-        if (mesh.clusters.size() > 1) {
-            if (!state.clusterBuffer) {
-                state.clusterBuffer = std::make_shared<gpu::Buffer>(state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                                    (const gpu::Byte*) state.clusterMatrices.constData());
-            } else {
-                state.clusterBuffer->setSubData(0, state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                (const gpu::Byte*) state.clusterMatrices.constData());
-            }
-        }
-        */
     }
 
     // as an optimization, don't build cautrizedClusterMatrices if the boneSet is empty.
@@ -147,17 +134,6 @@ void CauterizedModel::updateClusterMatrices() {
                 }
                 glm_mat4u_mul(jointMatrix, cluster.inverseBindMatrix, state.clusterMatrices[j]);
             }
-/*
-            if (!_cauterizeBoneSet.empty() && (state.clusterMatrices.size() > 1)) {
-                if (!state.clusterBuffer) {
-                    state.clusterBuffer =
-                        std::make_shared<gpu::Buffer>(state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                      (const gpu::Byte*) state.clusterMatrices.constData());
-                } else {
-                    state.clusterBuffer->setSubData(0, state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                              (const gpu::Byte*) state.clusterMatrices.constData());
-                }
-            }*/
         }
     }
 
@@ -202,9 +178,6 @@ void CauterizedModel::updateRenderItems() {
             modelTransform.setTranslation(self->getTranslation());
             modelTransform.setRotation(self->getRotation());
 
-       /*     if (!self->isLoaded()) {
-                return;
-            }*/
             render::Transaction transaction;
             QList<render::ItemID> keys = self->getRenderItems().keys();
             int meshIndex{ 0 };
@@ -225,13 +198,13 @@ void CauterizedModel::updateRenderItems() {
                         if (clusterMatrices.size() == 1) {
                             renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
                         }
-                        data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
+                        data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
 
                         renderTransform = modelTransform;
                         if (clusterMatricesCauterized.size() == 1) {
                             renderTransform = modelTransform.worldTransform(Transform(clusterMatricesCauterized[0]));
                         }
-                        data.updateTransformForCauterizedMesh(renderTransform, nullptr);
+                        data.updateTransformForCauterizedMesh(renderTransform);
                 });
             }
 
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index abb0d299e1..5426ed0ea6 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -337,7 +337,7 @@ ModelMeshPartPayload::ModelMeshPartPayload(ModelPointer model, int meshIndex, in
     if (state.clusterMatrices.size() == 1) {
         renderTransform = transform.worldTransform(Transform(state.clusterMatrices[0]));
     }
-    updateTransformForSkinnedMesh(renderTransform, transform, state.clusterBuffer);
+    updateTransformForSkinnedMesh(renderTransform, transform);
 
     initCache();
 }
@@ -368,26 +368,24 @@ void ModelMeshPartPayload::notifyLocationChanged() {
 }
 
 
-void ModelMeshPartPayload::updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices) {
+void ModelMeshPartPayload::updateClusterBuffer(const std::vector<glm::mat4>& clusterMatrices) {
     // Once computed the cluster matrices, update the buffer(s)
     if (clusterMatrices.size() > 1) {
         if (!_clusterBuffer) {
             _clusterBuffer = std::make_shared<gpu::Buffer>(clusterMatrices.size() * sizeof(glm::mat4),
-                (const gpu::Byte*) clusterMatrices.constData());
+                (const gpu::Byte*) clusterMatrices.data());
         }
         else {
             _clusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
-                (const gpu::Byte*) clusterMatrices.constData());
+                (const gpu::Byte*) clusterMatrices.data());
         }
     }
 }
 
-void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& renderTransform, const Transform& boundTransform,
-        const gpu::BufferPointer& buffer) {
+void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& renderTransform, const Transform& boundTransform) {
     _transform = renderTransform;
     _worldBound = _adjustedLocalBound;
     _worldBound.transform(boundTransform);
- //   _clusterBuffer = buffer;
 }
 
 ItemKey ModelMeshPartPayload::getKey() const {
@@ -431,7 +429,6 @@ int ModelMeshPartPayload::getLayer() const {
 }
 
 ShapeKey ModelMeshPartPayload::getShapeKey() const {
-
     // guard against partially loaded meshes
     ModelPointer model = _model.lock();
     if (!model || !model->isLoaded() || !model->getGeometry()) {
@@ -597,7 +594,7 @@ void ModelMeshPartPayload::render(RenderArgs* args) {
     args->_details._trianglesRendered += _drawPart._numIndices / INDICES_PER_TRIANGLE;
 }
 
-void ModelMeshPartPayload::computeAdjustedLocalBound(const QVector<glm::mat4>& clusterMatrices) {
+void ModelMeshPartPayload::computeAdjustedLocalBound(const std::vector<glm::mat4>& clusterMatrices) {
     _adjustedLocalBound = _localBound;
     if (clusterMatrices.size() > 0) {
         _adjustedLocalBound.transform(clusterMatrices[0]);
diff --git a/libraries/render-utils/src/MeshPartPayload.h b/libraries/render-utils/src/MeshPartPayload.h
index 0e8464f873..971c6fe90b 100644
--- a/libraries/render-utils/src/MeshPartPayload.h
+++ b/libraries/render-utils/src/MeshPartPayload.h
@@ -87,10 +87,8 @@ public:
     typedef Payload::DataPointer Pointer;
 
     void notifyLocationChanged() override;
-    void updateClusterBuffer(const QVector<glm::mat4>& clusterMatrices);
-    void updateTransformForSkinnedMesh(const Transform& renderTransform,
-            const Transform& boundTransform,
-            const gpu::BufferPointer& buffer);
+    void updateClusterBuffer(const std::vector<glm::mat4>& clusterMatrices);
+    void updateTransformForSkinnedMesh(const Transform& renderTransform, const Transform& boundTransform);
 
     // Render Item interface
     render::ItemKey getKey() const override;
@@ -104,7 +102,7 @@ public:
 
     void initCache();
 
-    void computeAdjustedLocalBound(const QVector<glm::mat4>& clusterMatrices);
+    void computeAdjustedLocalBound(const std::vector<glm::mat4>& clusterMatrices);
 
     gpu::BufferPointer _clusterBuffer;
     ModelWeakPointer _model;
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 4add6fb5ba..79b968ffb7 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -255,7 +255,7 @@ void Model::updateRenderItems() {
                     if (clusterMatrices.size() == 1) {
                         renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
                     }
-                    data.updateTransformForSkinnedMesh(renderTransform, modelTransform, nullptr);
+                    data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
                 });
             }
         }
@@ -313,7 +313,7 @@ bool Model::updateGeometry() {
         foreach (const FBXMesh& mesh, fbxGeometry.meshes) {
             MeshState state;
             state.clusterMatrices.resize(mesh.clusters.size());
-            _meshStates.append(state);
+            _meshStates.push_back(state);
 
             // Note: we add empty buffers for meshes that lack blendshapes so we can access the buffers by index
             // later in ModelMeshPayload, however the vast majority of meshes will not have them.
@@ -1138,17 +1138,6 @@ void Model::updateClusterMatrices() {
             auto jointMatrix = _rig.getJointTransform(cluster.jointIndex);
             glm_mat4u_mul(jointMatrix, cluster.inverseBindMatrix, state.clusterMatrices[j]);
         }
-
-      /*  // Once computed the cluster matrices, update the buffer(s)
-        if (mesh.clusters.size() > 1) {
-            if (!state.clusterBuffer) {
-                state.clusterBuffer = std::make_shared<gpu::Buffer>(state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                                    (const gpu::Byte*) state.clusterMatrices.constData());
-            } else {
-                state.clusterBuffer->setSubData(0, state.clusterMatrices.size() * sizeof(glm::mat4),
-                                                (const gpu::Byte*) state.clusterMatrices.constData());
-            }
-        }*/
     }
 
     // post the blender if we're not currently waiting for one to finish
@@ -1332,7 +1321,7 @@ void Model::createCollisionRenderItemSet() {
 }
 
 bool Model::isRenderable() const {
-    return !_meshStates.isEmpty() || (isLoaded() && _renderGeometry->getMeshes().empty());
+    return !_meshStates.empty() || (isLoaded() && _renderGeometry->getMeshes().empty());
 }
 
 class CollisionRenderGeometry : public Geometry {
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index 58ed143062..c537a928b3 100644
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@@ -246,8 +246,7 @@ public:
 
     class MeshState {
     public:
-        QVector<glm::mat4> clusterMatrices;
-        gpu::BufferPointer clusterBuffer;
+        std::vector<glm::mat4> clusterMatrices;
     };
 
     const MeshState& getMeshState(int index) { return _meshStates.at(index); }
@@ -317,7 +316,7 @@ protected:
     bool _snappedToRegistrationPoint; /// are we currently snapped to a registration point
     glm::vec3 _registrationPoint = glm::vec3(0.5f); /// the point in model space our center is snapped to
 
-    QVector<MeshState> _meshStates;
+    std::vector<MeshState> _meshStates;
 
     virtual void initJointStates();
 

From 390f5b53caeaab609bddebefc0eb8a54de6ea9d5 Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Thu, 2 Nov 2017 23:55:44 -0700
Subject: [PATCH 08/13] cleaning more code

---
 .../render-utils/src/CauterizedModel.cpp      | 37 ++++++++-----------
 libraries/render-utils/src/Model.cpp          | 28 ++++++--------
 2 files changed, 27 insertions(+), 38 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 776de727b4..2105806134 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -165,7 +165,7 @@ void CauterizedModel::updateRenderItems() {
         AbstractViewStateInterface::instance()->pushPostUpdateLambda(key, [weakSelf]() {
             // do nothing, if the model has already been destroyed.
             auto self = weakSelf.lock();
-            if (!self) {
+            if (!self || !self->isLoaded()) {
                 return;
             }
 
@@ -179,32 +179,27 @@ void CauterizedModel::updateRenderItems() {
             modelTransform.setRotation(self->getRotation());
 
             render::Transaction transaction;
-            QList<render::ItemID> keys = self->getRenderItems().keys();
-            int meshIndex{ 0 };
             for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
+
                 auto itemID = self->_modelMeshRenderItemIDs[i];
                 auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
+                auto clusterMatrices(self->getMeshState(meshIndex).clusterMatrices);
+                auto clusterMatricesCauterized(self->getCauterizeMeshState(meshIndex).clusterMatrices);
 
-                const Model::MeshState& state = self->getMeshState(meshIndex);
-                auto clusterMatrices(state.clusterMatrices);
-                const Model::MeshState& cState = self->getCauterizeMeshState(meshIndex);
-                auto clusterMatricesCauterized(cState.clusterMatrices);
+                transaction.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, clusterMatrices, clusterMatricesCauterized](CauterizedMeshPartPayload& data) {
+                    data.updateClusterBuffer(clusterMatrices, clusterMatricesCauterized);
 
-                transaction.updateItem<CauterizedMeshPartPayload>(itemID, 
-                    [modelTransform, clusterMatrices, clusterMatricesCauterized](CauterizedMeshPartPayload& data) {
-                        data.updateClusterBuffer(clusterMatrices, clusterMatricesCauterized);
+                    Transform renderTransform = modelTransform;
+                    if (clusterMatrices.size() == 1) {
+                        renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
+                    }
+                    data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
 
-                        Transform renderTransform = modelTransform;
-                        if (clusterMatrices.size() == 1) {
-                            renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
-                        }
-                        data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
-
-                        renderTransform = modelTransform;
-                        if (clusterMatricesCauterized.size() == 1) {
-                            renderTransform = modelTransform.worldTransform(Transform(clusterMatricesCauterized[0]));
-                        }
-                        data.updateTransformForCauterizedMesh(renderTransform);
+                    renderTransform = modelTransform;
+                    if (clusterMatricesCauterized.size() == 1) {
+                        renderTransform = modelTransform.worldTransform(Transform(clusterMatricesCauterized[0]));
+                    }
+                    data.updateTransformForCauterizedMesh(renderTransform);
                 });
             }
 
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 79b968ffb7..f27aa284be 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -218,7 +218,6 @@ void Model::updateRenderItems() {
     _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;
@@ -227,7 +226,7 @@ void Model::updateRenderItems() {
 
         // do nothing, if the model has already been destroyed.
         auto self = weakSelf.lock();
-        if (!self) {
+        if (!self || !self->isLoaded()) {
             return;
         }
 
@@ -238,26 +237,21 @@ void Model::updateRenderItems() {
         Transform modelTransform = self->getTransform();
         modelTransform.setScale(glm::vec3(1.0f));
 
-        uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
-
         render::Transaction transaction;
         for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
+
             auto itemID = self->_modelMeshRenderItemIDs[i];
             auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
-            if (self && self->isLoaded()) {
-                const Model::MeshState& state = self->getMeshState(meshIndex);
-                auto clusterMatrices(state.clusterMatrices);
+            auto clusterMatrices(self->getMeshState(meshIndex).clusterMatrices);
 
-                transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter, modelTransform, clusterMatrices](ModelMeshPartPayload& data) {
-                    data.updateClusterBuffer(clusterMatrices);
-
-                    Transform renderTransform = modelTransform;
-                    if (clusterMatrices.size() == 1) {
-                        renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
-                    }
-                    data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
-                });
-            }
+            transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, clusterMatrices](ModelMeshPartPayload& data) {
+                data.updateClusterBuffer(clusterMatrices);
+                Transform renderTransform = modelTransform;
+                if (clusterMatrices.size() == 1) {
+                    renderTransform = modelTransform.worldTransform(Transform(clusterMatrices[0]));
+                }
+                data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
+            });
         }
 
         Transform collisionMeshOffset;

From 053052a95db484cb48a55a4584d6c939bbb8b2e2 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Fri, 3 Nov 2017 13:28:20 -0700
Subject: [PATCH 09/13] removing warnings

---
 libraries/render-utils/src/CauterizedModel.cpp     | 6 +++---
 libraries/render-utils/src/MeshPartPayload.cpp     | 2 +-
 libraries/render-utils/src/Model.cpp               | 6 +++---
 libraries/render-utils/src/SoftAttachmentModel.cpp | 2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 2105806134..30121a232d 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -48,7 +48,7 @@ void CauterizedModel::createVisibleRenderItemSet() {
         const auto& meshes = _renderGeometry->getMeshes();
 
         // all of our mesh vectors must match in size
-        if ((int)meshes.size() != _meshStates.size()) {
+        if (meshes.size() != _meshStates.size()) {
             qCDebug(renderutils) << "WARNING!!!! Mesh Sizes don't match! We will not segregate mesh groups yet.";
             return;
         }
@@ -104,7 +104,7 @@ void CauterizedModel::updateClusterMatrices() {
     _needsUpdateClusterMatrices = false;
     const FBXGeometry& geometry = getFBXGeometry();
 
-    for (int i = 0; i < _meshStates.size(); i++) {
+    for (int i = 0; i < (int)_meshStates.size(); i++) {
         Model::MeshState& state = _meshStates[i];
         const FBXMesh& mesh = geometry.meshes.at(i);
         for (int j = 0; j < mesh.clusters.size(); j++) {
@@ -179,7 +179,7 @@ void CauterizedModel::updateRenderItems() {
             modelTransform.setRotation(self->getRotation());
 
             render::Transaction transaction;
-            for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
+            for (int i = 0; i < (int)self->_modelMeshRenderItemIDs.size(); i++) {
 
                 auto itemID = self->_modelMeshRenderItemIDs[i];
                 auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index 5426ed0ea6..1ea3e1a705 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -598,7 +598,7 @@ void ModelMeshPartPayload::computeAdjustedLocalBound(const std::vector<glm::mat4
     _adjustedLocalBound = _localBound;
     if (clusterMatrices.size() > 0) {
         _adjustedLocalBound.transform(clusterMatrices[0]);
-        for (int i = 1; i < clusterMatrices.size(); ++i) {
+        for (int i = 1; i < (int)clusterMatrices.size(); ++i) {
             AABox clusterBound = _localBound;
             clusterBound.transform(clusterMatrices[i]);
             _adjustedLocalBound += clusterBound;
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index f27aa284be..428fcc7a54 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -238,7 +238,7 @@ void Model::updateRenderItems() {
         modelTransform.setScale(glm::vec3(1.0f));
 
         render::Transaction transaction;
-        for (int i = 0; i < self->_modelMeshRenderItemIDs.size(); i++) {
+        for (int i = 0; i < (int) self->_modelMeshRenderItemIDs.size(); i++) {
 
             auto itemID = self->_modelMeshRenderItemIDs[i];
             auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
@@ -1124,7 +1124,7 @@ void Model::updateClusterMatrices() {
     }
     _needsUpdateClusterMatrices = false;
     const FBXGeometry& geometry = getFBXGeometry();
-    for (int i = 0; i < _meshStates.size(); i++) {
+    for (int i = 0; i < (int) _meshStates.size(); i++) {
         MeshState& state = _meshStates[i];
         const FBXMesh& mesh = geometry.meshes.at(i);
         for (int j = 0; j < mesh.clusters.size(); j++) {
@@ -1241,7 +1241,7 @@ void Model::createVisibleRenderItemSet() {
     const auto& meshes = _renderGeometry->getMeshes();
 
     // all of our mesh vectors must match in size
-    if ((int)meshes.size() != _meshStates.size()) {
+    if (meshes.size() != _meshStates.size()) {
         qCDebug(renderutils) << "WARNING!!!! Mesh Sizes don't match! We will not segregate mesh groups yet.";
         return;
     }
diff --git a/libraries/render-utils/src/SoftAttachmentModel.cpp b/libraries/render-utils/src/SoftAttachmentModel.cpp
index f364e9c037..63991f9422 100644
--- a/libraries/render-utils/src/SoftAttachmentModel.cpp
+++ b/libraries/render-utils/src/SoftAttachmentModel.cpp
@@ -43,7 +43,7 @@ void SoftAttachmentModel::updateClusterMatrices() {
 
     const FBXGeometry& geometry = getFBXGeometry();
 
-    for (int i = 0; i < _meshStates.size(); i++) {
+    for (int i = 0; i < (int) _meshStates.size(); i++) {
         MeshState& state = _meshStates[i];
         const FBXMesh& mesh = geometry.meshes.at(i);
 

From f665bf384b30ca82feacf9978c0126ad592266b4 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Mon, 6 Nov 2017 17:02:10 -0800
Subject: [PATCH 10/13] merge with upstream, and clean code

---
 libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
index bbd0110c11..d2dc116e15 100644
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
+++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
@@ -728,21 +728,19 @@ void Avatar::simulateAttachments(float deltaTime) {
         glm::quat jointRotation;
         if (attachment.isSoft) {
             // soft attachments do not have transform offsets
-        //    model->setTranslation(getPosition());
-        //    model->setRotation(getOrientation() * Quaternions::Y_180);
             model->setTransformNoUpdateRenderItems(Transform(getOrientation() * Quaternions::Y_180, glm::vec3(1.0), getPosition()));
             model->simulate(deltaTime);
             model->updateRenderItems();
         } else {
             if (_skeletonModel->getJointPositionInWorldFrame(jointIndex, jointPosition) &&
                 _skeletonModel->getJointRotationInWorldFrame(jointIndex, jointRotation)) {
-                model->setTranslation(jointPosition + jointRotation * attachment.translation * getModelScale());
-                model->setRotation(jointRotation * attachment.rotation);
+                model->setTransformNoUpdateRenderItems(Transform(jointRotation * attachment.rotation, glm::vec3(1.0), jointPosition + jointRotation * attachment.translation * getModelScale()));
                 float scale = getModelScale() * attachment.scale;
                 model->setScaleToFit(true, model->getNaturalDimensions() * scale, true); // hack to force rescale
                 model->setSnapModelToCenter(false); // hack to force resnap
                 model->setSnapModelToCenter(true);
                 model->simulate(deltaTime);
+                model->updateRenderItems();
             }
         }
     }

From 6481e0f713169e51205855ff64688b32b86b019e Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Tue, 7 Nov 2017 12:52:23 -0800
Subject: [PATCH 11/13] Address cauterized cluster matrices issue

---
 libraries/render-utils/src/CauterizedMeshPartPayload.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
index a54a072b75..a5d782098d 100644
--- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
+++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
@@ -39,8 +39,8 @@ void CauterizedMeshPartPayload::updateClusterBuffer(const std::vector<glm::mat4>
                 (const gpu::Byte*) cauterizedClusterMatrices.data());
         }
         else {
-            _cauterizedClusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
-                (const gpu::Byte*) clusterMatrices.data());
+            _cauterizedClusterBuffer->setSubData(0, cauterizedClusterMatrices.size() * sizeof(glm::mat4),
+                (const gpu::Byte*) cauterizedClusterMatrices.data());
         }
     }
 }

From 0718763ed1d8ff076e13ca8de8460236bd365d80 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Tue, 7 Nov 2017 17:31:15 -0800
Subject: [PATCH 12/13] Adjust syntax

---
 libraries/render-utils/src/CauterizedMeshPartPayload.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
index a5d782098d..983832e9c8 100644
--- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
+++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
@@ -37,8 +37,7 @@ void CauterizedMeshPartPayload::updateClusterBuffer(const std::vector<glm::mat4>
         if (!_cauterizedClusterBuffer) {
             _cauterizedClusterBuffer = std::make_shared<gpu::Buffer>(cauterizedClusterMatrices.size() * sizeof(glm::mat4),
                 (const gpu::Byte*) cauterizedClusterMatrices.data());
-        }
-        else {
+        } else {
             _cauterizedClusterBuffer->setSubData(0, cauterizedClusterMatrices.size() * sizeof(glm::mat4),
                 (const gpu::Byte*) cauterizedClusterMatrices.data());
         }

From af1180255ead9d31ea88e9c23ee313f5fe339429 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Wed, 8 Nov 2017 11:45:40 -0800
Subject: [PATCH 13/13] fixes from code review

---
 .../render-utils/src/CauterizedMeshPartPayload.cpp   | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
index 983832e9c8..3bb2aa2ef9 100644
--- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
+++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp
@@ -21,17 +21,7 @@ CauterizedMeshPartPayload::CauterizedMeshPartPayload(ModelPointer model, int mes
     : ModelMeshPartPayload(model, meshIndex, partIndex, shapeIndex, transform, offsetTransform) {}
 
 void CauterizedMeshPartPayload::updateClusterBuffer(const std::vector<glm::mat4>& clusterMatrices, const std::vector<glm::mat4>& cauterizedClusterMatrices) {
-
-    // Once computed the cluster matrices, update the buffer(s)
-    if (clusterMatrices.size() > 1) {
-        if (!_clusterBuffer) {
-            _clusterBuffer = std::make_shared<gpu::Buffer>(clusterMatrices.size() * sizeof(glm::mat4),
-            (const gpu::Byte*) clusterMatrices.data());
-        } else {
-            _clusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
-            (const gpu::Byte*) clusterMatrices.data());
-        }
-    }
+    ModelMeshPartPayload::updateClusterBuffer(clusterMatrices);
 
     if (cauterizedClusterMatrices.size() > 1) {
         if (!_cauterizedClusterBuffer) {