History

Merge remote-tracking branch 'upstream/master' into parenting

HifiExperiments committed 6 years ago

Commit 56d359f2 parents ebc9dae f68810f291 files · +5018 −4276Browse files

Showing the changes to libraries/render-utils/src/Model.cpp (1 of 291 files). Show all

Unified · Split

libraries/render-utils/src/Model.cpp+193−172
@@ -44,7 +44,7 @@ · 43 unmodified lines
4444 using namespace std;
4545
4646 int nakedModelPointerTypeId = qRegisterMetaType<ModelPointer>();
47−int weakGeometryResourceBridgePointerTypeId = qRegisterMetaType<NetworkModel::WeakPointer>();
47+int weakGeometryResourceBridgePointerTypeId = qRegisterMetaType<Geometry::WeakPointer>();
4848 int vec3VectorTypeId = qRegisterMetaType<QVector<glm::vec3>>();
4949 int normalTypeVecTypeId = qRegisterMetaType<QVector<NormalType>>("QVector<NormalType>");
5050 float Model::FAKE_DIMENSION_PLACEHOLDER = -1.0f;
@@ -74,7 +74,7 @@ Model::Model(QObject* parent, SpatiallyNestable* spatiallyNestableOverride, uint · 23 unmodified lines
7474
7575 setSnapModelToRegistrationPoint(true, glm::vec3(0.5f));
7676
77− connect(&_renderWatcher, &ModelResourceWatcher::finished, this, &Model::loadURLFinished);
77+ connect(&_renderWatcher, &GeometryResourceWatcher::finished, this, &Model::loadURLFinished);
7878 }
7979
8080 Model::~Model() {
@@ -154,7 +154,7 @@ void Model::setOffset(const glm::vec3& offset) { · 73 unmodified lines
154154 }
155155
156156 void Model::calculateTextureInfo() {
157− if (!_hasCalculatedTextureInfo && isLoaded() && getNetworkModel()->areTexturesLoaded() && !_modelMeshRenderItems.isEmpty()) {
157+ if (!_hasCalculatedTextureInfo && isLoaded() && getGeometry()->areTexturesLoaded() && !_modelMeshRenderItems.isEmpty()) {
158158 size_t textureSize = 0;
159159 int textureCount = 0;
160160 bool allTexturesLoaded = true;
@@ -181,15 +181,15 @@ int Model::getRenderInfoTextureCount() { · 20 unmodified lines
181181 }
182182
183183 bool Model::shouldInvalidatePayloadShapeKey(int meshIndex) {
184− if (!getNetworkModel()) {
184+ if (!getGeometry()) {
185185 return true;
186186 }
187187
188188 const HFMModel& hfmModel = getHFMModel();
189− const auto& networkMeshes = getNetworkModel()->getMeshes();
189+ const auto& networkMeshes = getGeometry()->getMeshes();
190190 // if our index is ever out of range for either meshes or networkMeshes, then skip it, and set our _meshGroupsKnown
191191 // to false to rebuild out mesh groups.
192− if (meshIndex < 0 || meshIndex >= (int)networkMeshes.size() || meshIndex >= (int)hfmModel.meshes.size()) {
192+ if (meshIndex < 0 || meshIndex >= (int)networkMeshes.size() || meshIndex >= (int)hfmModel.meshes.size() || meshIndex >= (int)_meshStates.size()) {
193193 _needsFixupInScene = true; // trigger remove/add cycle
194194 invalidCalculatedMeshBoxes(); // if we have to reload, we need to assume our mesh boxes are all invalid
195195 return true;
@@ -231,45 +231,46 @@ void Model::updateRenderItems() { · 35 unmodified lines
231231
232232 render::Transaction transaction;
233233 for (int i = 0; i < (int) self->_modelMeshRenderItemIDs.size(); i++) {
234+
234235 auto itemID = self->_modelMeshRenderItemIDs[i];
236+ auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex;
235237
236− const auto& shapeState = self->getShapeState(i);
238+ const auto& meshState = self->getMeshState(meshIndex);
237239
238− auto skinDeformerIndex = shapeState._skinDeformerIndex;
240+ bool invalidatePayloadShapeKey = self->shouldInvalidatePayloadShapeKey(meshIndex);
241+ bool useDualQuaternionSkinning = self->getUseDualQuaternionSkinning();
239242
240− bool invalidatePayloadShapeKey = self->shouldInvalidatePayloadShapeKey(shapeState._meshIndex);
243+ transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, meshState, useDualQuaternionSkinning,
244+ invalidatePayloadShapeKey, primitiveMode, renderItemKeyGlobalFlags, cauterized](ModelMeshPartPayload& data) {
245+ if (useDualQuaternionSkinning) {
246+ data.updateClusterBuffer(meshState.clusterDualQuaternions);
247+ data.computeAdjustedLocalBound(meshState.clusterDualQuaternions);
248+ } else {
249+ data.updateClusterBuffer(meshState.clusterMatrices);
250+ data.computeAdjustedLocalBound(meshState.clusterMatrices);
251+ }
241252
242− if (skinDeformerIndex != hfm::UNDEFINED_KEY) {
243− const auto& meshState = self->getMeshState(skinDeformerIndex);
244− bool useDualQuaternionSkinning = self->getUseDualQuaternionSkinning();
253+ Transform renderTransform = modelTransform;
245254
246− transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, shapeState, meshState, useDualQuaternionSkinning,
247− invalidatePayloadShapeKey, primitiveMode, renderItemKeyGlobalFlags, cauterized](ModelMeshPartPayload& data) {
248− if (useDualQuaternionSkinning) {
249− data.updateClusterBuffer(meshState.clusterDualQuaternions);
250− } else {
251− data.updateClusterBuffer(meshState.clusterMatrices);
255+ if (useDualQuaternionSkinning) {
256+ if (meshState.clusterDualQuaternions.size() == 1 || meshState.clusterDualQuaternions.size() == 2) {
257+ const auto& dq = meshState.clusterDualQuaternions[0];
258+ Transform transform(dq.getRotation(),
259+ dq.getScale(),
260+ dq.getTranslation());
261+ renderTransform = modelTransform.worldTransform(Transform(transform));
252262 }
263+ } else {
264+ if (meshState.clusterMatrices.size() == 1 || meshState.clusterMatrices.size() == 2) {
265+ renderTransform = modelTransform.worldTransform(Transform(meshState.clusterMatrices[0]));
266+ }
267+ }
268+ data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
253269
254− Transform renderTransform = modelTransform;
255− data.updateTransform(renderTransform);
256− data.updateTransformAndBound(modelTransform.worldTransform(shapeState._rootFromJointTransform));
257−
258− data.setCauterized(cauterized);
259− data.updateKey(renderItemKeyGlobalFlags);
260− data.setShapeKey(invalidatePayloadShapeKey, primitiveMode, useDualQuaternionSkinning);
261− });
262− } else {
263− transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, shapeState, invalidatePayloadShapeKey, primitiveMode, renderItemKeyGlobalFlags](ModelMeshPartPayload& data) {
264−
265− Transform renderTransform = modelTransform;
266− renderTransform = modelTransform.worldTransform(shapeState._rootFromJointTransform);
267− data.updateTransform(renderTransform);
268−
269− data.updateKey(renderItemKeyGlobalFlags);
270− data.setShapeKey(invalidatePayloadShapeKey, primitiveMode, false);
271− });
272− }
270+ data.setCauterized(cauterized);
271+ data.updateKey(renderItemKeyGlobalFlags);
272+ data.setShapeKey(invalidatePayloadShapeKey, primitiveMode, useDualQuaternionSkinning);
273+ });
273274 }
274275
275276 AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
@@ -290,15 +291,6 @@ void Model::reset() { · 14 unmodified lines
290291 }
291292 }
292293
293−void Model::updateShapeStatesFromRig() {
294− for (auto& shape : _shapeStates) {
295− uint32_t jointId = shape._jointIndex;
296− if (jointId < (uint32_t) _rig.getJointStateCount()) {
297− shape._rootFromJointTransform = _rig.getJointTransform(jointId);
298− }
299− }
300−}
301−
302294 bool Model::updateGeometry() {
303295 bool needFullUpdate = false;
304296
@@ -314,27 +306,14 @@ bool Model::updateGeometry() { · 9 unmodified lines
314306 assert(_meshStates.empty());
315307
316308 const HFMModel& hfmModel = getHFMModel();
317−
318− const auto& shapes = hfmModel.shapes;
319− _shapeStates.resize(shapes.size());
320− for (uint32_t s = 0; s < (uint32_t) shapes.size(); ++s) {
321− auto& shapeState = _shapeStates[s];
322− shapeState._jointIndex = shapes[s].joint;
323− shapeState._meshIndex = shapes[s].mesh;
324− shapeState._meshPartIndex = shapes[s].meshPart;
325− shapeState._skinDeformerIndex = shapes[s].skinDeformer;
326− }
327− updateShapeStatesFromRig();
328−
329− const auto& hfmSkinDeformers = hfmModel.skinDeformers;
330− for (uint32_t i = 0; i < (uint32_t) hfmSkinDeformers.size(); i++) {
331− const auto& dynT = hfmSkinDeformers[i];
309+ int i = 0;
310+ foreach (const HFMMesh& mesh, hfmModel.meshes) {
332311 MeshState state;
333− state.clusterDualQuaternions.resize(dynT.clusters.size());
334− state.clusterMatrices.resize(dynT.clusters.size());
312+ state.clusterDualQuaternions.resize(mesh.clusters.size());
313+ state.clusterMatrices.resize(mesh.clusters.size());
335314 _meshStates.push_back(state);
315+ i++;
336316 }
337−
338317 needFullUpdate = true;
339318 emit rigReady();
340319 }
@@ -662,8 +641,8 @@ glm::mat4 Model::getWorldToHFMMatrix() const { · 321 unmodified lines
662641 // TODO: deprecate and remove
663642 MeshProxyList Model::getMeshes() const {
664643 MeshProxyList result;
665− const NetworkModel::Pointer& renderGeometry = getNetworkModel();
666− const NetworkModel::GeometryMeshes& meshes = renderGeometry->getMeshes();
644+ const Geometry::Pointer& renderGeometry = getGeometry();
645+ const Geometry::GeometryMeshes& meshes = renderGeometry->getMeshes();
667646
668647 if (!isLoaded()) {
669648 return result;
@@ -732,9 +711,9 @@ bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointe · 62 unmodified lines
732711 render::Transaction transaction;
733712 for (int i = 0; i < (int) _modelMeshRenderItemIDs.size(); i++) {
734713 auto itemID = _modelMeshRenderItemIDs[i];
735− auto& shape = _shapeStates[i];
714+ auto shape = _modelMeshRenderItemShapes[i];
736715 // TODO: check to see if .partIndex matches too
737− if (shape._meshIndex == (uint32_t) meshIndex) {
716+ if (shape.meshIndex == meshIndex) {
738717 transaction.updateItem<ModelMeshPartPayload>(itemID, [=](ModelMeshPartPayload& data) {
739718 data.updateMeshPart(mesh, partIndex);
740719 });
@@ -753,7 +732,7 @@ bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointe · 12 unmodified lines
753732 for (int partID = 0; partID < numParts; partID++) {
754733 HFMMeshPart part;
755734 part.triangleIndices = buffer_helpers::bufferToVector<int>(mesh._mesh->getIndexBuffer(), "part.triangleIndices");
756− mesh.parts.push_back(part);
735+ mesh.parts << part;
757736 }
758737 {
759738 foreach (const glm::vec3& vertex, mesh.vertices) {
@@ -764,7 +743,7 @@ bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointe · 4 unmodified lines
764743 mesh.meshExtents.maximum = glm::max(mesh.meshExtents.maximum, transformedVertex);
765744 }
766745 }
767− hfmModel.meshes.push_back(mesh);
746+ hfmModel.meshes << mesh;
768747 }
769748 calculateTriangleSets(hfmModel);
770749 }
@@ -781,9 +760,9 @@ scriptable::ScriptableModelBase Model::getScriptableModel() { · 10 unmodified lines
781760 }
782761
783762 const HFMModel& hfmModel = getHFMModel();
784− uint32_t numberOfMeshes = (uint32_t)hfmModel.meshes.size();
763+ int numberOfMeshes = hfmModel.meshes.size();
785764 int shapeID = 0;
786− for (uint32_t i = 0; i < numberOfMeshes; i++) {
765+ for (int i = 0; i < numberOfMeshes; i++) {
787766 const HFMMesh& hfmMesh = hfmModel.meshes.at(i);
788767 if (auto mesh = hfmMesh._mesh) {
789768 result.append(mesh);
@@ -791,7 +770,7 @@ scriptable::ScriptableModelBase Model::getScriptableModel() { · 1 unmodified line
791770 int numParts = (int)mesh->getNumParts();
792771 for (int partIndex = 0; partIndex < numParts; partIndex++) {
793772 auto& materialName = _modelMeshMaterialNames[shapeID];
794− result.appendMaterial(graphics::MaterialLayer(getNetworkModel()->getShapeMaterial(shapeID), 0), shapeID, materialName);
773+ result.appendMaterial(graphics::MaterialLayer(getGeometry()->getShapeMaterial(shapeID), 0), shapeID, materialName);
795774
796775 {
797776 std::unique_lock<std::mutex> lock(_materialMappingMutex);
@@ -814,70 +793,78 @@ scriptable::ScriptableModelBase Model::getScriptableModel() { · 16 unmodified lines
814793 void Model::calculateTriangleSets(const HFMModel& hfmModel) {
815794 PROFILE_RANGE(render, __FUNCTION__);
816795
817− uint32_t meshInstanceCount = 0;
818− uint32_t lastMeshForInstanceCount = hfm::UNDEFINED_KEY;
819− for (const auto& shape : hfmModel.shapes) {
820− if (shape.mesh != lastMeshForInstanceCount) {
821− ++meshInstanceCount;
822− }
823− lastMeshForInstanceCount = shape.mesh;
824− }
796+ int numberOfMeshes = hfmModel.meshes.size();
825797
826798 _triangleSetsValid = true;
827799 _modelSpaceMeshTriangleSets.clear();
828− _modelSpaceMeshTriangleSets.reserve(meshInstanceCount);
829−
830− uint32_t lastMeshForTriangleBuilding = hfm::UNDEFINED_KEY;
831− glm::mat4 lastTransformForTriangleBuilding { 0 };
832− std::vector<glm::vec3> transformedPoints;
833− for (const auto& shape : hfmModel.shapes) {
834− const uint32_t meshIndex = shape.mesh;
835− const hfm::Mesh& mesh = hfmModel.meshes.at(meshIndex);
836− const auto& triangleListMesh = mesh.triangleListMesh;
837− const glm::vec2 part = triangleListMesh.parts[shape.meshPart];
838− glm::mat4 worldFromMeshTransform;
839− if (shape.joint != hfm::UNDEFINED_KEY) {
840− // globalTransform includes hfmModel.offset,
841− // which includes the scaling, rotation, and translation specified by the FST,
842− // and the scaling from the unit conversion in FBX.
843− // This can't change at runtime, so we can safely store these in our TriangleSet.
844− worldFromMeshTransform = hfmModel.joints[shape.joint].globalTransform;
845− }
846−
847− if (meshIndex != lastMeshForTriangleBuilding || worldFromMeshTransform != lastTransformForTriangleBuilding) {
848− lastMeshForTriangleBuilding = meshIndex;
849− lastTransformForTriangleBuilding = worldFromMeshTransform;
850− _modelSpaceMeshTriangleSets.emplace_back();
851− _modelSpaceMeshTriangleSets.back().reserve(mesh.parts.size());
800+ _modelSpaceMeshTriangleSets.resize(numberOfMeshes);
801+
802+ for (int i = 0; i < numberOfMeshes; i++) {
803+ const HFMMesh& mesh = hfmModel.meshes.at(i);
804+
805+ const int numberOfParts = mesh.parts.size();
806+ auto& meshTriangleSets = _modelSpaceMeshTriangleSets[i];
807+ meshTriangleSets.resize(numberOfParts);
808+
809+ for (int j = 0; j < numberOfParts; j++) {
810+ const HFMMeshPart& part = mesh.parts.at(j);
811+
812+ auto& partTriangleSet = meshTriangleSets[j];
813+
814+ const int INDICES_PER_TRIANGLE = 3;
815+ const int INDICES_PER_QUAD = 4;
816+ const int TRIANGLES_PER_QUAD = 2;
817+
818+ // tell our triangleSet how many triangles to expect.
819+ int numberOfQuads = part.quadIndices.size() / INDICES_PER_QUAD;
820+ int numberOfTris = part.triangleIndices.size() / INDICES_PER_TRIANGLE;
821+ int totalTriangles = (numberOfQuads * TRIANGLES_PER_QUAD) + numberOfTris;
822+ partTriangleSet.reserve(totalTriangles);
823+
824+ auto meshTransform = hfmModel.offset * mesh.modelTransform;
825+
826+ if (part.quadIndices.size() > 0) {
827+ int vIndex = 0;
828+ for (int q = 0; q < numberOfQuads; q++) {
829+ int i0 = part.quadIndices[vIndex++];
830+ int i1 = part.quadIndices[vIndex++];
831+ int i2 = part.quadIndices[vIndex++];
832+ int i3 = part.quadIndices[vIndex++];
833+
834+ // track the model space version... these points will be transformed by the FST's offset,
835+ // which includes the scaling, rotation, and translation specified by the FST/FBX,
836+ // this can't change at runtime, so we can safely store these in our TriangleSet
837+ glm::vec3 v0 = glm::vec3(meshTransform * glm::vec4(mesh.vertices[i0], 1.0f));
838+ glm::vec3 v1 = glm::vec3(meshTransform * glm::vec4(mesh.vertices[i1], 1.0f));
839+ glm::vec3 v2 = glm::vec3(meshTransform * glm::vec4(mesh.vertices[i2], 1.0f));
840+ glm::vec3 v3 = glm::vec3(meshTransform * glm::vec4(mesh.vertices[i3], 1.0f));
841+
842+ Triangle tri1 = { v0, v1, v3 };
843+ Triangle tri2 = { v1, v2, v3 };
844+ partTriangleSet.insert(tri1);
845+ partTriangleSet.insert(tri2);
846+ }
847+ }
852848
853− transformedPoints = triangleListMesh.vertices;
854− if (worldFromMeshTransform != glm::mat4()) {
855− for (auto& point : transformedPoints) {
856− point = glm::vec3(worldFromMeshTransform * glm::vec4(point, 1.0f));
849+ if (part.triangleIndices.size() > 0) {
850+ int vIndex = 0;
851+ for (int t = 0; t < numberOfTris; t++) {
852+ int i0 = part.triangleIndices[vIndex++];
853+ int i1 = part.triangleIndices[vIndex++];
854+ int i2 = part.triangleIndices[vIndex++];
855+
856+ // track the model space version... these points will be transformed by the FST's offset,
857+ // which includes the scaling, rotation, and translation specified by the FST/FBX,
858+ // this can't change at runtime, so we can safely store these in our TriangleSet
859+ glm::vec3 v0 = glm::vec3(meshTransform * glm::vec4(mesh.vertices[i0], 1.0f));
860+ glm::vec3 v1 = glm::vec3(meshTransform * glm::vec4(mesh.vertices[i1], 1.0f));
861+ glm::vec3 v2 = glm::vec3(meshTransform * glm::vec4(mesh.vertices[i2], 1.0f));
862+
863+ Triangle tri = { v0, v1, v2 };
864+ partTriangleSet.insert(tri);
857865 }
858866 }
859867 }
860− auto& meshTriangleSets = _modelSpaceMeshTriangleSets.back();
861− meshTriangleSets.emplace_back();
862− auto& partTriangleSet = meshTriangleSets.back();
863−
864− const static size_t INDICES_PER_TRIANGLE = 3;
865− const size_t triangleCount = (size_t)(part.y) / INDICES_PER_TRIANGLE;
866− partTriangleSet.reserve(triangleCount);
867− const size_t indexStart = (uint32_t)part.x;
868− const size_t indexEnd = indexStart + (triangleCount * INDICES_PER_TRIANGLE);
869− for (size_t i = indexStart; i < indexEnd; i += INDICES_PER_TRIANGLE) {
870− const int i0 = triangleListMesh.indices[i];
871− const int i1 = triangleListMesh.indices[i + 1];
872− const int i2 = triangleListMesh.indices[i + 2];
873−
874− const glm::vec3 v0 = transformedPoints[i0];
875− const glm::vec3 v1 = transformedPoints[i1];
876− const glm::vec3 v2 = transformedPoints[i2];
877−
878− const Triangle tri = { v0, v1, v2 };
879− partTriangleSet.insert(tri);
880− }
881868 }
882869 }
883870
@@ -888,7 +875,7 @@ void Model::updateRenderItemsKey(const render::ScenePointer& scene) { · 4 unmodified lines
888875 }
889876 auto renderItemsKey = _renderItemKeyGlobalFlags;
890877 render::Transaction transaction;
891− for(auto itemID: _modelMeshRenderItemIDs) {
878+ for (auto itemID: _modelMeshRenderItemIDs) {
892879 transaction.updateItem<ModelMeshPartPayload>(itemID, [renderItemsKey](ModelMeshPartPayload& data) {
893880 data.updateKey(renderItemsKey);
894881 });
@@ -966,8 +953,8 @@ void Model::setCauterized(bool cauterized, const render::ScenePointer& scene) { · 71 unmodified lines
966953 return;
967954 }
968955 render::Transaction transaction;
969− for (auto itemID : _modelMeshRenderItemIDs) {
970− transaction.updateItem<ModelMeshPartPayload>(itemID, [cauterized](ModelMeshPartPayload& data) {
956+ foreach (auto item, _modelMeshRenderItemsMap.keys()) {
957+ transaction.updateItem<ModelMeshPartPayload>(item, [cauterized](ModelMeshPartPayload& data) {
971958 data.setCauterized(cauterized);
972959 });
973960 }
@@ -981,7 +968,7 @@ void Model::setCullWithParent(bool cullWithParent) { · 7 unmodified lines
981968
982969 render::Transaction transaction;
983970 auto renderItemsKey = _renderItemKeyGlobalFlags;
984− for(auto item : _modelMeshRenderItemIDs) {
971+ for (auto item : _modelMeshRenderItemIDs) {
985972 transaction.updateItem<ModelMeshPartPayload>(item, [cullWithParent, renderItemsKey](ModelMeshPartPayload& data) {
986973 data.setCullWithParent(cullWithParent);
987974 data.updateKey(renderItemsKey);
@@ -991,6 +978,16 @@ void Model::setCullWithParent(bool cullWithParent) { · 3 unmodified lines
991978 }
992979 }
993980
981+void Model::setRenderWithZones(const QVector<QUuid>& renderWithZones) {
982+ render::Transaction transaction;
983+ for (auto item : _modelMeshRenderItemIDs) {
984+ transaction.updateItem<ModelMeshPartPayload>(item, [renderWithZones](ModelMeshPartPayload& data) {
985+ data.setRenderWithZones(renderWithZones);
986+ });
987+ }
988+ AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
989+}
990+
994991 const render::ItemKey Model::getRenderItemKeyGlobalFlags() const {
995992 return _renderItemKeyGlobalFlags;
996993 }
@@ -1012,25 +1009,26 @@ bool Model::addToScene(const render::ScenePointer& scene, · 15 unmodified lines
10121009
10131010 bool somethingAdded = false;
10141011
1015− if (_modelMeshRenderItemIDs.empty()) {
1012+ if (_modelMeshRenderItemsMap.empty()) {
10161013 bool hasTransparent = false;
10171014 size_t verticesCount = 0;
10181015 foreach(auto renderItem, _modelMeshRenderItems) {
10191016 auto item = scene->allocateID();
10201017 auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
1021− if (_modelMeshRenderItemIDs.empty() && statusGetters.size()) {
1018+ if (_modelMeshRenderItemsMap.empty() && statusGetters.size()) {
10221019 renderPayload->addStatusGetters(statusGetters);
10231020 }
10241021 transaction.resetItem(item, renderPayload);
10251022
10261023 hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
10271024 verticesCount += renderItem.get()->getVerticesCount();
1025+ _modelMeshRenderItemsMap.insert(item, renderPayload);
10281026 _modelMeshRenderItemIDs.emplace_back(item);
10291027 }
1030− somethingAdded = !_modelMeshRenderItemIDs.empty();
1028+ somethingAdded = !_modelMeshRenderItemsMap.empty();
10311029
10321030 _renderInfoVertexCount = verticesCount;
1033− _renderInfoDrawCalls = (uint32_t) _modelMeshRenderItemIDs.size();
1031+ _renderInfoDrawCalls = _modelMeshRenderItemsMap.count();
10341032 _renderInfoHasTransparent = hasTransparent;
10351033 }
10361034
@@ -1045,12 +1043,14 @@ bool Model::addToScene(const render::ScenePointer& scene, · 8 unmodified lines
10451043 }
10461044
10471045 void Model::removeFromScene(const render::ScenePointer& scene, render::Transaction& transaction) {
1048− for (auto itemID: _modelMeshRenderItemIDs) {
1049− transaction.removeItem(itemID);
1046+ foreach (auto item, _modelMeshRenderItemsMap.keys()) {
1047+ transaction.removeItem(item);
10501048 }
10511049 _modelMeshRenderItemIDs.clear();
1050+ _modelMeshRenderItemsMap.clear();
10521051 _modelMeshRenderItems.clear();
10531052 _modelMeshMaterialNames.clear();
1053+ _modelMeshRenderItemShapes.clear();
10541054 _priorityMap.clear();
10551055
10561056 _addedToScene = false;
@@ -1229,7 +1229,7 @@ void Model::setURL(const QUrl& url) { · 172 unmodified lines
12291229 invalidCalculatedMeshBoxes();
12301230 deleteGeometry();
12311231
1232− auto resource = DependencyManager::get<ModelCache>()->getModelResource(url);
1232+ auto resource = DependencyManager::get<ModelCache>()->getGeometryResource(url);
12331233 if (resource) {
12341234 resource->setLoadPriority(this, _loadingPriority);
12351235 _renderWatcher.setResource(resource);
@@ -1418,29 +1418,33 @@ void Model::updateClusterMatrices() { · 182 unmodified lines
14181418 return;
14191419 }
14201420
1421− updateShapeStatesFromRig();
1422−
14231421 _needsUpdateClusterMatrices = false;
1424−
1425− for (int skinDeformerIndex = 0; skinDeformerIndex < (int)_meshStates.size(); skinDeformerIndex++) {
1426− MeshState& state = _meshStates[skinDeformerIndex];
1427− auto numClusters = state.getNumClusters();
1428− for (uint32_t clusterIndex = 0; clusterIndex < numClusters; clusterIndex++) {
1429− const auto& cbmov = _rig.getAnimSkeleton()->getClusterBindMatricesOriginalValues(skinDeformerIndex, clusterIndex);
1422+ const HFMModel& hfmModel = getHFMModel();
1423+ for (int i = 0; i < (int) _meshStates.size(); i++) {
1424+ MeshState& state = _meshStates[i];
1425+ int meshIndex = i;
1426+ const HFMMesh& mesh = hfmModel.meshes.at(i);
1427+ for (int j = 0; j < mesh.clusters.size(); j++) {
1428+ const HFMCluster& cluster = mesh.clusters.at(j);
1429+ int clusterIndex = j;
14301430
14311431 if (_useDualQuaternionSkinning) {
1432− auto jointPose = _rig.getJointPose(cbmov.jointIndex);
1432+ auto jointPose = _rig.getJointPose(cluster.jointIndex);
14331433 Transform jointTransform(jointPose.rot(), jointPose.scale(), jointPose.trans());
14341434 Transform clusterTransform;
1435− Transform::mult(clusterTransform, jointTransform, cbmov.inverseBindTransform);
1436− state.clusterDualQuaternions[clusterIndex] = Model::TransformDualQuaternion(clusterTransform);
1435+ Transform::mult(clusterTransform, jointTransform, _rig.getAnimSkeleton()->getClusterBindMatricesOriginalValues(meshIndex, clusterIndex).inverseBindTransform);
1436+ state.clusterDualQuaternions[j] = Model::TransformDualQuaternion(clusterTransform);
14371437 } else {
1438− auto jointMatrix = _rig.getJointTransform(cbmov.jointIndex);
1439− glm_mat4u_mul(jointMatrix, cbmov.inverseBindMatrix, state.clusterMatrices[clusterIndex]);
1438+ auto jointMatrix = _rig.getJointTransform(cluster.jointIndex);
1439+ glm_mat4u_mul(jointMatrix, _rig.getAnimSkeleton()->getClusterBindMatricesOriginalValues(meshIndex, clusterIndex).inverseBindMatrix, state.clusterMatrices[j]);
14401440 }
14411441 }
14421442 }
14431443
1444+ updateBlendshapes();
1445+}
1446+
1447+void Model::updateBlendshapes() {
14441448 // post the blender if we're not currently waiting for one to finish
14451449 auto modelBlender = DependencyManager::get<ModelBlender>();
14461450 if (modelBlender->shouldComputeBlendshapes() && getHFMModel().hasBlendedMeshes() && _blendshapeCoefficients != _blendedBlendshapeCoefficients) {
@@ -1451,7 +1455,6 @@ void Model::updateClusterMatrices() { · 4 unmodified lines
14511455
14521456 void Model::deleteGeometry() {
14531457 _deleteGeometryCounter++;
1454− _shapeStates.clear();
14551458 _meshStates.clear();
14561459 _rig.destroyAnimGraph();
14571460 _blendedBlendshapeCoefficients.clear();
@@ -1485,12 +1488,20 @@ const render::ItemIDs& Model::fetchRenderItemIDs() const { · 27 unmodified lines
14851488
14861489 void Model::createRenderItemSet() {
14871490 assert(isLoaded());
1491+ const auto& meshes = _renderGeometry->getMeshes();
1492+
1493+ // all of our mesh vectors must match in size
1494+ if (meshes.size() != _meshStates.size()) {
1495+ qCDebug(renderutils) << "WARNING!!!! Mesh Sizes don't match! " << meshes.size() << _meshStates.size() << " We will not segregate mesh groups yet.";
1496+ return;
1497+ }
14881498
14891499 // We should not have any existing renderItems if we enter this section of code
14901500 Q_ASSERT(_modelMeshRenderItems.isEmpty());
14911501
14921502 _modelMeshRenderItems.clear();
14931503 _modelMeshMaterialNames.clear();
1504+ _modelMeshRenderItemShapes.clear();
14941505
14951506 Transform transform;
14961507 transform.setTranslation(_translation);
@@ -1501,19 +1512,28 @@ void Model::createRenderItemSet() { · 4 unmodified lines
15011512 offset.postTranslate(_offset);
15021513
15031514 // Run through all of the meshes, and place them into their segregated, but unsorted buckets
1504− const auto& shapes = _renderGeometry->getHFMModel().shapes;
1505− for (uint32_t shapeID = 0; shapeID < shapes.size(); shapeID++) {
1506− const auto& shape = shapes[shapeID];
1507−
1508− _modelMeshRenderItems << std::make_shared<ModelMeshPartPayload>(shared_from_this(), shape.mesh, shape.meshPart, shapeID, transform, offset, _created);
1515+ int shapeID = 0;
1516+ uint32_t numMeshes = (uint32_t)meshes.size();
1517+ for (uint32_t i = 0; i < numMeshes; i++) {
1518+ const auto& mesh = meshes.at(i);
1519+ if (!mesh) {
1520+ continue;
1521+ }
15091522
1510− auto material = getNetworkModel()->getShapeMaterial(shapeID);
1511− _modelMeshMaterialNames.push_back(material ? material->getName() : "");
1523+ // Create the render payloads
1524+ int numParts = (int)mesh->getNumParts();
1525+ for (int partIndex = 0; partIndex < numParts; partIndex++) {
1526+ _modelMeshRenderItems << std::make_shared<ModelMeshPartPayload>(shared_from_this(), i, partIndex, shapeID, transform, offset, _created);
1527+ auto material = getGeometry()->getShapeMaterial(shapeID);
1528+ _modelMeshMaterialNames.push_back(material ? material->getName() : "");
1529+ _modelMeshRenderItemShapes.emplace_back(ShapeInfo{ (int)i });
1530+ shapeID++;
1531+ }
15121532 }
15131533 }
15141534
15151535 bool Model::isRenderable() const {
1516− return (!_shapeStates.empty()) || (isLoaded() && _renderGeometry->getMeshes().empty());
1536+ return !_meshStates.empty() || (isLoaded() && _renderGeometry->getMeshes().empty());
15171537 }
15181538
15191539 std::set<unsigned int> Model::getMeshIDsFromMaterialID(QString parentMaterialName) {
@@ -1569,11 +1589,11 @@ void Model::applyMaterialMapping() { · 49 unmodified lines
15691589 PrimitiveMode primitiveMode = getPrimitiveMode();
15701590 bool useDualQuaternionSkinning = _useDualQuaternionSkinning;
15711591 auto modelMeshRenderItemIDs = _modelMeshRenderItemIDs;
1572− auto shapeStates = _shapeStates;
1592+ auto modelMeshRenderItemShapes = _modelMeshRenderItemShapes;
15731593 std::unordered_map<int, bool> shouldInvalidatePayloadShapeKeyMap;
15741594
1575− for (auto& shape : _shapeStates) {
1576− shouldInvalidatePayloadShapeKeyMap[shape._meshIndex] = shouldInvalidatePayloadShapeKey(shape._meshIndex);
1595+ for (auto& shape : _modelMeshRenderItemShapes) {
1596+ shouldInvalidatePayloadShapeKeyMap[shape.meshIndex] = shouldInvalidatePayloadShapeKey(shape.meshIndex);
15771597 }
15781598
15791599 auto& materialMapping = getMaterialMapping();
@@ -1596,7 +1616,7 @@ void Model::applyMaterialMapping() { · 16 unmodified lines
15961616
15971617 std::weak_ptr<Model> weakSelf = shared_from_this();
15981618 auto materialLoaded = [networkMaterialResource, shapeIDs, priorityMapPerResource, renderItemsKey, primitiveMode, useDualQuaternionSkinning,
1599− modelMeshRenderItemIDs, shapeStates, shouldInvalidatePayloadShapeKeyMap, weakSelf]() {
1619+ modelMeshRenderItemIDs, modelMeshRenderItemShapes, shouldInvalidatePayloadShapeKeyMap, weakSelf]() {
16001620 std::shared_ptr<Model> self = weakSelf.lock();
16011621 if (!self || networkMaterialResource->isFailed() || networkMaterialResource->parsedMaterials.names.size() == 0) {
16021622 return;
@@ -1622,7 +1642,7 @@ void Model::applyMaterialMapping() { · 19 unmodified lines
16221642 for (auto shapeID : shapeIDs) {
16231643 if (shapeID < modelMeshRenderItemIDs.size()) {
16241644 auto itemID = modelMeshRenderItemIDs[shapeID];
1625− auto meshIndex = shapeStates[shapeID]._meshIndex;
1645+ auto meshIndex = modelMeshRenderItemShapes[shapeID].meshIndex;
16261646 bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKeyMap.at(meshIndex);
16271647 graphics::MaterialLayer material = graphics::MaterialLayer(networkMaterial, priorityMapPerResource.at(shapeID));
16281648 {
@@ -1660,7 +1680,7 @@ void Model::addMaterial(graphics::MaterialLayer material, const std::string& par · 31 unmodified lines
16601680 for (auto shapeID : shapeIDs) {
16611681 if (shapeID < _modelMeshRenderItemIDs.size()) {
16621682 auto itemID = _modelMeshRenderItemIDs[shapeID];
1663− auto meshIndex = _shapeStates[shapeID]._meshIndex;
1683+ auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex;
16641684 bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex);
16651685 transaction.updateItem<ModelMeshPartPayload>(itemID, [material, renderItemsKey,
16661686 invalidatePayloadShapeKey, primitiveMode, useDualQuaternionSkinning](ModelMeshPartPayload& data) {
@@ -1682,7 +1702,7 @@ void Model::removeMaterial(graphics::MaterialPointer material, const std::string · 15 unmodified lines
16821702 auto itemID = _modelMeshRenderItemIDs[shapeID];
16831703 auto renderItemsKey = _renderItemKeyGlobalFlags;
16841704 PrimitiveMode primitiveMode = getPrimitiveMode();
1685− auto meshIndex = _shapeStates[shapeID]._meshIndex;
1705+ auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex;
16861706 bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex);
16871707 bool useDualQuaternionSkinning = _useDualQuaternionSkinning;
16881708 transaction.updateItem<ModelMeshPartPayload>(itemID, [material, renderItemsKey,
@@ -1697,13 +1717,14 @@ void Model::removeMaterial(graphics::MaterialPointer material, const std::string · 8 unmodified lines
16971717 AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
16981718 }
16991719
1700−class CollisionRenderGeometry : public NetworkModel {
1720+class CollisionRenderGeometry : public Geometry {
17011721 public:
17021722 CollisionRenderGeometry(graphics::MeshPointer mesh) {
17031723 _hfmModel = std::make_shared<HFMModel>();
17041724 std::shared_ptr<GeometryMeshes> meshes = std::make_shared<GeometryMeshes>();
17051725 meshes->push_back(mesh);
17061726 _meshes = meshes;
1727+ _meshParts = std::shared_ptr<const GeometryMeshParts>();
17071728 }
17081729 };
17091730
@@ -1854,7 +1875,7 @@ void Blender::run() { · 144 unmodified lines
18541875
18551876 bool Model::maybeStartBlender() {
18561877 if (isLoaded()) {
1857− QThreadPool::globalInstance()->start(new Blender(getThisPointer(), getNetworkModel()->getConstHFMModelPointer(),
1878+ QThreadPool::globalInstance()->start(new Blender(getThisPointer(), getGeometry()->getConstHFMModelPointer(),
18581879 ++_blendNumber, _blendshapeCoefficients));
18591880 return true;
18601881 }

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t