Showing the changes to libraries/render-utils/src/Model.cpp (1 of 291 files). Show all
Unified · Split
| @@ -44,7 +44,7 @@ · 43 unmodified lines | ||
| 44 | 44 | using namespace std; |
| 45 | 45 | |
| 46 | 46 | int nakedModelPointerTypeId = qRegisterMetaType<ModelPointer>(); |
| 47 | −int weakGeometryResourceBridgePointerTypeId = qRegisterMetaType<NetworkModel::WeakPointer>(); | |
| 47 | +int weakGeometryResourceBridgePointerTypeId = qRegisterMetaType<Geometry::WeakPointer>(); | |
| 48 | 48 | int vec3VectorTypeId = qRegisterMetaType<QVector<glm::vec3>>(); |
| 49 | 49 | int normalTypeVecTypeId = qRegisterMetaType<QVector<NormalType>>("QVector<NormalType>"); |
| 50 | 50 | float Model::FAKE_DIMENSION_PLACEHOLDER = -1.0f; |
| @@ -74,7 +74,7 @@ Model::Model(QObject* parent, SpatiallyNestable* spatiallyNestableOverride, uint · 23 unmodified lines | ||
| 74 | 74 | |
| 75 | 75 | setSnapModelToRegistrationPoint(true, glm::vec3(0.5f)); |
| 76 | 76 | |
| 77 | − connect(&_renderWatcher, &ModelResourceWatcher::finished, this, &Model::loadURLFinished); | |
| 77 | + connect(&_renderWatcher, &GeometryResourceWatcher::finished, this, &Model::loadURLFinished); | |
| 78 | 78 | } |
| 79 | 79 | |
| 80 | 80 | Model::~Model() { |
| @@ -154,7 +154,7 @@ void Model::setOffset(const glm::vec3& offset) { · 73 unmodified lines | ||
| 154 | 154 | } |
| 155 | 155 | |
| 156 | 156 | void Model::calculateTextureInfo() { |
| 157 | − if (!_hasCalculatedTextureInfo && isLoaded() && getNetworkModel()->areTexturesLoaded() && !_modelMeshRenderItems.isEmpty()) { | |
| 157 | + if (!_hasCalculatedTextureInfo && isLoaded() && getGeometry()->areTexturesLoaded() && !_modelMeshRenderItems.isEmpty()) { | |
| 158 | 158 | size_t textureSize = 0; |
| 159 | 159 | int textureCount = 0; |
| 160 | 160 | bool allTexturesLoaded = true; |
| @@ -181,15 +181,15 @@ int Model::getRenderInfoTextureCount() { · 20 unmodified lines | ||
| 181 | 181 | } |
| 182 | 182 | |
| 183 | 183 | bool Model::shouldInvalidatePayloadShapeKey(int meshIndex) { |
| 184 | − if (!getNetworkModel()) { | |
| 184 | + if (!getGeometry()) { | |
| 185 | 185 | return true; |
| 186 | 186 | } |
| 187 | 187 | |
| 188 | 188 | const HFMModel& hfmModel = getHFMModel(); |
| 189 | − const auto& networkMeshes = getNetworkModel()->getMeshes(); | |
| 189 | + const auto& networkMeshes = getGeometry()->getMeshes(); | |
| 190 | 190 | // if our index is ever out of range for either meshes or networkMeshes, then skip it, and set our _meshGroupsKnown |
| 191 | 191 | // 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()) { | |
| 193 | 193 | _needsFixupInScene = true; // trigger remove/add cycle |
| 194 | 194 | invalidCalculatedMeshBoxes(); // if we have to reload, we need to assume our mesh boxes are all invalid |
| 195 | 195 | return true; |
| @@ -231,45 +231,46 @@ void Model::updateRenderItems() { · 35 unmodified lines | ||
| 231 | 231 | |
| 232 | 232 | render::Transaction transaction; |
| 233 | 233 | for (int i = 0; i < (int) self->_modelMeshRenderItemIDs.size(); i++) { |
| 234 | + | |
| 234 | 235 | auto itemID = self->_modelMeshRenderItemIDs[i]; |
| 236 | + auto meshIndex = self->_modelMeshRenderItemShapes[i].meshIndex; | |
| 235 | 237 | |
| 236 | − const auto& shapeState = self->getShapeState(i); | |
| 238 | + const auto& meshState = self->getMeshState(meshIndex); | |
| 237 | 239 | |
| 238 | − auto skinDeformerIndex = shapeState._skinDeformerIndex; | |
| 240 | + bool invalidatePayloadShapeKey = self->shouldInvalidatePayloadShapeKey(meshIndex); | |
| 241 | + bool useDualQuaternionSkinning = self->getUseDualQuaternionSkinning(); | |
| 239 | 242 | |
| 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 | + } | |
| 241 | 252 | |
| 242 | − if (skinDeformerIndex != hfm::UNDEFINED_KEY) { | |
| 243 | − const auto& meshState = self->getMeshState(skinDeformerIndex); | |
| 244 | − bool useDualQuaternionSkinning = self->getUseDualQuaternionSkinning(); | |
| 253 | + Transform renderTransform = modelTransform; | |
| 245 | 254 | |
| 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)); | |
| 252 | 262 | } |
| 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); | |
| 253 | 269 | |
| 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 | + }); | |
| 273 | 274 | } |
| 274 | 275 | |
| 275 | 276 | AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction); |
| @@ -290,15 +291,6 @@ void Model::reset() { · 14 unmodified lines | ||
| 290 | 291 | } |
| 291 | 292 | } |
| 292 | 293 | |
| 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 | − | |
| 302 | 294 | bool Model::updateGeometry() { |
| 303 | 295 | bool needFullUpdate = false; |
| 304 | 296 | |
| @@ -314,27 +306,14 @@ bool Model::updateGeometry() { · 9 unmodified lines | ||
| 314 | 306 | assert(_meshStates.empty()); |
| 315 | 307 | |
| 316 | 308 | 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) { | |
| 332 | 311 | 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()); | |
| 335 | 314 | _meshStates.push_back(state); |
| 315 | + i++; | |
| 336 | 316 | } |
| 337 | − | |
| 338 | 317 | needFullUpdate = true; |
| 339 | 318 | emit rigReady(); |
| 340 | 319 | } |
| @@ -662,8 +641,8 @@ glm::mat4 Model::getWorldToHFMMatrix() const { · 321 unmodified lines | ||
| 662 | 641 | // TODO: deprecate and remove |
| 663 | 642 | MeshProxyList Model::getMeshes() const { |
| 664 | 643 | 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(); | |
| 667 | 646 | |
| 668 | 647 | if (!isLoaded()) { |
| 669 | 648 | return result; |
| @@ -732,9 +711,9 @@ bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointe · 62 unmodified lines | ||
| 732 | 711 | render::Transaction transaction; |
| 733 | 712 | for (int i = 0; i < (int) _modelMeshRenderItemIDs.size(); i++) { |
| 734 | 713 | auto itemID = _modelMeshRenderItemIDs[i]; |
| 735 | − auto& shape = _shapeStates[i]; | |
| 714 | + auto shape = _modelMeshRenderItemShapes[i]; | |
| 736 | 715 | // TODO: check to see if .partIndex matches too |
| 737 | − if (shape._meshIndex == (uint32_t) meshIndex) { | |
| 716 | + if (shape.meshIndex == meshIndex) { | |
| 738 | 717 | transaction.updateItem<ModelMeshPartPayload>(itemID, [=](ModelMeshPartPayload& data) { |
| 739 | 718 | data.updateMeshPart(mesh, partIndex); |
| 740 | 719 | }); |
| @@ -753,7 +732,7 @@ bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointe · 12 unmodified lines | ||
| 753 | 732 | for (int partID = 0; partID < numParts; partID++) { |
| 754 | 733 | HFMMeshPart part; |
| 755 | 734 | part.triangleIndices = buffer_helpers::bufferToVector<int>(mesh._mesh->getIndexBuffer(), "part.triangleIndices"); |
| 756 | − mesh.parts.push_back(part); | |
| 735 | + mesh.parts << part; | |
| 757 | 736 | } |
| 758 | 737 | { |
| 759 | 738 | foreach (const glm::vec3& vertex, mesh.vertices) { |
| @@ -764,7 +743,7 @@ bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointe · 4 unmodified lines | ||
| 764 | 743 | mesh.meshExtents.maximum = glm::max(mesh.meshExtents.maximum, transformedVertex); |
| 765 | 744 | } |
| 766 | 745 | } |
| 767 | − hfmModel.meshes.push_back(mesh); | |
| 746 | + hfmModel.meshes << mesh; | |
| 768 | 747 | } |
| 769 | 748 | calculateTriangleSets(hfmModel); |
| 770 | 749 | } |
| @@ -781,9 +760,9 @@ scriptable::ScriptableModelBase Model::getScriptableModel() { · 10 unmodified lines | ||
| 781 | 760 | } |
| 782 | 761 | |
| 783 | 762 | const HFMModel& hfmModel = getHFMModel(); |
| 784 | − uint32_t numberOfMeshes = (uint32_t)hfmModel.meshes.size(); | |
| 763 | + int numberOfMeshes = hfmModel.meshes.size(); | |
| 785 | 764 | int shapeID = 0; |
| 786 | − for (uint32_t i = 0; i < numberOfMeshes; i++) { | |
| 765 | + for (int i = 0; i < numberOfMeshes; i++) { | |
| 787 | 766 | const HFMMesh& hfmMesh = hfmModel.meshes.at(i); |
| 788 | 767 | if (auto mesh = hfmMesh._mesh) { |
| 789 | 768 | result.append(mesh); |
| @@ -791,7 +770,7 @@ scriptable::ScriptableModelBase Model::getScriptableModel() { · 1 unmodified line | ||
| 791 | 770 | int numParts = (int)mesh->getNumParts(); |
| 792 | 771 | for (int partIndex = 0; partIndex < numParts; partIndex++) { |
| 793 | 772 | 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); | |
| 795 | 774 | |
| 796 | 775 | { |
| 797 | 776 | std::unique_lock<std::mutex> lock(_materialMappingMutex); |
| @@ -814,70 +793,78 @@ scriptable::ScriptableModelBase Model::getScriptableModel() { · 16 unmodified lines | ||
| 814 | 793 | void Model::calculateTriangleSets(const HFMModel& hfmModel) { |
| 815 | 794 | PROFILE_RANGE(render, __FUNCTION__); |
| 816 | 795 | |
| 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(); | |
| 825 | 797 | |
| 826 | 798 | _triangleSetsValid = true; |
| 827 | 799 | _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 | + } | |
| 852 | 848 | |
| 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); | |
| 857 | 865 | } |
| 858 | 866 | } |
| 859 | 867 | } |
| 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 | − } | |
| 881 | 868 | } |
| 882 | 869 | } |
| 883 | 870 | |
| @@ -888,7 +875,7 @@ void Model::updateRenderItemsKey(const render::ScenePointer& scene) { · 4 unmodified lines | ||
| 888 | 875 | } |
| 889 | 876 | auto renderItemsKey = _renderItemKeyGlobalFlags; |
| 890 | 877 | render::Transaction transaction; |
| 891 | − for(auto itemID: _modelMeshRenderItemIDs) { | |
| 878 | + for (auto itemID: _modelMeshRenderItemIDs) { | |
| 892 | 879 | transaction.updateItem<ModelMeshPartPayload>(itemID, [renderItemsKey](ModelMeshPartPayload& data) { |
| 893 | 880 | data.updateKey(renderItemsKey); |
| 894 | 881 | }); |
| @@ -966,8 +953,8 @@ void Model::setCauterized(bool cauterized, const render::ScenePointer& scene) { · 71 unmodified lines | ||
| 966 | 953 | return; |
| 967 | 954 | } |
| 968 | 955 | 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) { | |
| 971 | 958 | data.setCauterized(cauterized); |
| 972 | 959 | }); |
| 973 | 960 | } |
| @@ -981,7 +968,7 @@ void Model::setCullWithParent(bool cullWithParent) { · 7 unmodified lines | ||
| 981 | 968 | |
| 982 | 969 | render::Transaction transaction; |
| 983 | 970 | auto renderItemsKey = _renderItemKeyGlobalFlags; |
| 984 | − for(auto item : _modelMeshRenderItemIDs) { | |
| 971 | + for (auto item : _modelMeshRenderItemIDs) { | |
| 985 | 972 | transaction.updateItem<ModelMeshPartPayload>(item, [cullWithParent, renderItemsKey](ModelMeshPartPayload& data) { |
| 986 | 973 | data.setCullWithParent(cullWithParent); |
| 987 | 974 | data.updateKey(renderItemsKey); |
| @@ -991,6 +978,16 @@ void Model::setCullWithParent(bool cullWithParent) { · 3 unmodified lines | ||
| 991 | 978 | } |
| 992 | 979 | } |
| 993 | 980 | |
| 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 | + | |
| 994 | 991 | const render::ItemKey Model::getRenderItemKeyGlobalFlags() const { |
| 995 | 992 | return _renderItemKeyGlobalFlags; |
| 996 | 993 | } |
| @@ -1012,25 +1009,26 @@ bool Model::addToScene(const render::ScenePointer& scene, · 15 unmodified lines | ||
| 1012 | 1009 | |
| 1013 | 1010 | bool somethingAdded = false; |
| 1014 | 1011 | |
| 1015 | − if (_modelMeshRenderItemIDs.empty()) { | |
| 1012 | + if (_modelMeshRenderItemsMap.empty()) { | |
| 1016 | 1013 | bool hasTransparent = false; |
| 1017 | 1014 | size_t verticesCount = 0; |
| 1018 | 1015 | foreach(auto renderItem, _modelMeshRenderItems) { |
| 1019 | 1016 | auto item = scene->allocateID(); |
| 1020 | 1017 | auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem); |
| 1021 | − if (_modelMeshRenderItemIDs.empty() && statusGetters.size()) { | |
| 1018 | + if (_modelMeshRenderItemsMap.empty() && statusGetters.size()) { | |
| 1022 | 1019 | renderPayload->addStatusGetters(statusGetters); |
| 1023 | 1020 | } |
| 1024 | 1021 | transaction.resetItem(item, renderPayload); |
| 1025 | 1022 | |
| 1026 | 1023 | hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent(); |
| 1027 | 1024 | verticesCount += renderItem.get()->getVerticesCount(); |
| 1025 | + _modelMeshRenderItemsMap.insert(item, renderPayload); | |
| 1028 | 1026 | _modelMeshRenderItemIDs.emplace_back(item); |
| 1029 | 1027 | } |
| 1030 | − somethingAdded = !_modelMeshRenderItemIDs.empty(); | |
| 1028 | + somethingAdded = !_modelMeshRenderItemsMap.empty(); | |
| 1031 | 1029 | |
| 1032 | 1030 | _renderInfoVertexCount = verticesCount; |
| 1033 | − _renderInfoDrawCalls = (uint32_t) _modelMeshRenderItemIDs.size(); | |
| 1031 | + _renderInfoDrawCalls = _modelMeshRenderItemsMap.count(); | |
| 1034 | 1032 | _renderInfoHasTransparent = hasTransparent; |
| 1035 | 1033 | } |
| 1036 | 1034 | |
| @@ -1045,12 +1043,14 @@ bool Model::addToScene(const render::ScenePointer& scene, · 8 unmodified lines | ||
| 1045 | 1043 | } |
| 1046 | 1044 | |
| 1047 | 1045 | 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); | |
| 1050 | 1048 | } |
| 1051 | 1049 | _modelMeshRenderItemIDs.clear(); |
| 1050 | + _modelMeshRenderItemsMap.clear(); | |
| 1052 | 1051 | _modelMeshRenderItems.clear(); |
| 1053 | 1052 | _modelMeshMaterialNames.clear(); |
| 1053 | + _modelMeshRenderItemShapes.clear(); | |
| 1054 | 1054 | _priorityMap.clear(); |
| 1055 | 1055 | |
| 1056 | 1056 | _addedToScene = false; |
| @@ -1229,7 +1229,7 @@ void Model::setURL(const QUrl& url) { · 172 unmodified lines | ||
| 1229 | 1229 | invalidCalculatedMeshBoxes(); |
| 1230 | 1230 | deleteGeometry(); |
| 1231 | 1231 | |
| 1232 | − auto resource = DependencyManager::get<ModelCache>()->getModelResource(url); | |
| 1232 | + auto resource = DependencyManager::get<ModelCache>()->getGeometryResource(url); | |
| 1233 | 1233 | if (resource) { |
| 1234 | 1234 | resource->setLoadPriority(this, _loadingPriority); |
| 1235 | 1235 | _renderWatcher.setResource(resource); |
| @@ -1418,29 +1418,33 @@ void Model::updateClusterMatrices() { · 182 unmodified lines | ||
| 1418 | 1418 | return; |
| 1419 | 1419 | } |
| 1420 | 1420 | |
| 1421 | − updateShapeStatesFromRig(); | |
| 1422 | − | |
| 1423 | 1421 | _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; | |
| 1430 | 1430 | |
| 1431 | 1431 | if (_useDualQuaternionSkinning) { |
| 1432 | − auto jointPose = _rig.getJointPose(cbmov.jointIndex); | |
| 1432 | + auto jointPose = _rig.getJointPose(cluster.jointIndex); | |
| 1433 | 1433 | Transform jointTransform(jointPose.rot(), jointPose.scale(), jointPose.trans()); |
| 1434 | 1434 | 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); | |
| 1437 | 1437 | } 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]); | |
| 1440 | 1440 | } |
| 1441 | 1441 | } |
| 1442 | 1442 | } |
| 1443 | 1443 | |
| 1444 | + updateBlendshapes(); | |
| 1445 | +} | |
| 1446 | + | |
| 1447 | +void Model::updateBlendshapes() { | |
| 1444 | 1448 | // post the blender if we're not currently waiting for one to finish |
| 1445 | 1449 | auto modelBlender = DependencyManager::get<ModelBlender>(); |
| 1446 | 1450 | if (modelBlender->shouldComputeBlendshapes() && getHFMModel().hasBlendedMeshes() && _blendshapeCoefficients != _blendedBlendshapeCoefficients) { |
| @@ -1451,7 +1455,6 @@ void Model::updateClusterMatrices() { · 4 unmodified lines | ||
| 1451 | 1455 | |
| 1452 | 1456 | void Model::deleteGeometry() { |
| 1453 | 1457 | _deleteGeometryCounter++; |
| 1454 | − _shapeStates.clear(); | |
| 1455 | 1458 | _meshStates.clear(); |
| 1456 | 1459 | _rig.destroyAnimGraph(); |
| 1457 | 1460 | _blendedBlendshapeCoefficients.clear(); |
| @@ -1485,12 +1488,20 @@ const render::ItemIDs& Model::fetchRenderItemIDs() const { · 27 unmodified lines | ||
| 1485 | 1488 | |
| 1486 | 1489 | void Model::createRenderItemSet() { |
| 1487 | 1490 | 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 | + } | |
| 1488 | 1498 | |
| 1489 | 1499 | // We should not have any existing renderItems if we enter this section of code |
| 1490 | 1500 | Q_ASSERT(_modelMeshRenderItems.isEmpty()); |
| 1491 | 1501 | |
| 1492 | 1502 | _modelMeshRenderItems.clear(); |
| 1493 | 1503 | _modelMeshMaterialNames.clear(); |
| 1504 | + _modelMeshRenderItemShapes.clear(); | |
| 1494 | 1505 | |
| 1495 | 1506 | Transform transform; |
| 1496 | 1507 | transform.setTranslation(_translation); |
| @@ -1501,19 +1512,28 @@ void Model::createRenderItemSet() { · 4 unmodified lines | ||
| 1501 | 1512 | offset.postTranslate(_offset); |
| 1502 | 1513 | |
| 1503 | 1514 | // 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 | + } | |
| 1509 | 1522 | |
| 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 | + } | |
| 1512 | 1532 | } |
| 1513 | 1533 | } |
| 1514 | 1534 | |
| 1515 | 1535 | bool Model::isRenderable() const { |
| 1516 | − return (!_shapeStates.empty()) || (isLoaded() && _renderGeometry->getMeshes().empty()); | |
| 1536 | + return !_meshStates.empty() || (isLoaded() && _renderGeometry->getMeshes().empty()); | |
| 1517 | 1537 | } |
| 1518 | 1538 | |
| 1519 | 1539 | std::set<unsigned int> Model::getMeshIDsFromMaterialID(QString parentMaterialName) { |
| @@ -1569,11 +1589,11 @@ void Model::applyMaterialMapping() { · 49 unmodified lines | ||
| 1569 | 1589 | PrimitiveMode primitiveMode = getPrimitiveMode(); |
| 1570 | 1590 | bool useDualQuaternionSkinning = _useDualQuaternionSkinning; |
| 1571 | 1591 | auto modelMeshRenderItemIDs = _modelMeshRenderItemIDs; |
| 1572 | − auto shapeStates = _shapeStates; | |
| 1592 | + auto modelMeshRenderItemShapes = _modelMeshRenderItemShapes; | |
| 1573 | 1593 | std::unordered_map<int, bool> shouldInvalidatePayloadShapeKeyMap; |
| 1574 | 1594 | |
| 1575 | − for (auto& shape : _shapeStates) { | |
| 1576 | − shouldInvalidatePayloadShapeKeyMap[shape._meshIndex] = shouldInvalidatePayloadShapeKey(shape._meshIndex); | |
| 1595 | + for (auto& shape : _modelMeshRenderItemShapes) { | |
| 1596 | + shouldInvalidatePayloadShapeKeyMap[shape.meshIndex] = shouldInvalidatePayloadShapeKey(shape.meshIndex); | |
| 1577 | 1597 | } |
| 1578 | 1598 | |
| 1579 | 1599 | auto& materialMapping = getMaterialMapping(); |
| @@ -1596,7 +1616,7 @@ void Model::applyMaterialMapping() { · 16 unmodified lines | ||
| 1596 | 1616 | |
| 1597 | 1617 | std::weak_ptr<Model> weakSelf = shared_from_this(); |
| 1598 | 1618 | auto materialLoaded = [networkMaterialResource, shapeIDs, priorityMapPerResource, renderItemsKey, primitiveMode, useDualQuaternionSkinning, |
| 1599 | − modelMeshRenderItemIDs, shapeStates, shouldInvalidatePayloadShapeKeyMap, weakSelf]() { | |
| 1619 | + modelMeshRenderItemIDs, modelMeshRenderItemShapes, shouldInvalidatePayloadShapeKeyMap, weakSelf]() { | |
| 1600 | 1620 | std::shared_ptr<Model> self = weakSelf.lock(); |
| 1601 | 1621 | if (!self || networkMaterialResource->isFailed() || networkMaterialResource->parsedMaterials.names.size() == 0) { |
| 1602 | 1622 | return; |
| @@ -1622,7 +1642,7 @@ void Model::applyMaterialMapping() { · 19 unmodified lines | ||
| 1622 | 1642 | for (auto shapeID : shapeIDs) { |
| 1623 | 1643 | if (shapeID < modelMeshRenderItemIDs.size()) { |
| 1624 | 1644 | auto itemID = modelMeshRenderItemIDs[shapeID]; |
| 1625 | − auto meshIndex = shapeStates[shapeID]._meshIndex; | |
| 1645 | + auto meshIndex = modelMeshRenderItemShapes[shapeID].meshIndex; | |
| 1626 | 1646 | bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKeyMap.at(meshIndex); |
| 1627 | 1647 | graphics::MaterialLayer material = graphics::MaterialLayer(networkMaterial, priorityMapPerResource.at(shapeID)); |
| 1628 | 1648 | { |
| @@ -1660,7 +1680,7 @@ void Model::addMaterial(graphics::MaterialLayer material, const std::string& par · 31 unmodified lines | ||
| 1660 | 1680 | for (auto shapeID : shapeIDs) { |
| 1661 | 1681 | if (shapeID < _modelMeshRenderItemIDs.size()) { |
| 1662 | 1682 | auto itemID = _modelMeshRenderItemIDs[shapeID]; |
| 1663 | − auto meshIndex = _shapeStates[shapeID]._meshIndex; | |
| 1683 | + auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex; | |
| 1664 | 1684 | bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex); |
| 1665 | 1685 | transaction.updateItem<ModelMeshPartPayload>(itemID, [material, renderItemsKey, |
| 1666 | 1686 | invalidatePayloadShapeKey, primitiveMode, useDualQuaternionSkinning](ModelMeshPartPayload& data) { |
| @@ -1682,7 +1702,7 @@ void Model::removeMaterial(graphics::MaterialPointer material, const std::string · 15 unmodified lines | ||
| 1682 | 1702 | auto itemID = _modelMeshRenderItemIDs[shapeID]; |
| 1683 | 1703 | auto renderItemsKey = _renderItemKeyGlobalFlags; |
| 1684 | 1704 | PrimitiveMode primitiveMode = getPrimitiveMode(); |
| 1685 | − auto meshIndex = _shapeStates[shapeID]._meshIndex; | |
| 1705 | + auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex; | |
| 1686 | 1706 | bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex); |
| 1687 | 1707 | bool useDualQuaternionSkinning = _useDualQuaternionSkinning; |
| 1688 | 1708 | transaction.updateItem<ModelMeshPartPayload>(itemID, [material, renderItemsKey, |
| @@ -1697,13 +1717,14 @@ void Model::removeMaterial(graphics::MaterialPointer material, const std::string · 8 unmodified lines | ||
| 1697 | 1717 | AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction); |
| 1698 | 1718 | } |
| 1699 | 1719 | |
| 1700 | −class CollisionRenderGeometry : public NetworkModel { | |
| 1720 | +class CollisionRenderGeometry : public Geometry { | |
| 1701 | 1721 | public: |
| 1702 | 1722 | CollisionRenderGeometry(graphics::MeshPointer mesh) { |
| 1703 | 1723 | _hfmModel = std::make_shared<HFMModel>(); |
| 1704 | 1724 | std::shared_ptr<GeometryMeshes> meshes = std::make_shared<GeometryMeshes>(); |
| 1705 | 1725 | meshes->push_back(mesh); |
| 1706 | 1726 | _meshes = meshes; |
| 1727 | + _meshParts = std::shared_ptr<const GeometryMeshParts>(); | |
| 1707 | 1728 | } |
| 1708 | 1729 | }; |
| 1709 | 1730 | |
| @@ -1854,7 +1875,7 @@ void Blender::run() { · 144 unmodified lines | ||
| 1854 | 1875 | |
| 1855 | 1876 | bool Model::maybeStartBlender() { |
| 1856 | 1877 | if (isLoaded()) { |
| 1857 | − QThreadPool::globalInstance()->start(new Blender(getThisPointer(), getNetworkModel()->getConstHFMModelPointer(), | |
| 1878 | + QThreadPool::globalInstance()->start(new Blender(getThisPointer(), getGeometry()->getConstHFMModelPointer(), | |
| 1858 | 1879 | ++_blendNumber, _blendshapeCoefficients)); |
| 1859 | 1880 | return true; |
| 1860 | 1881 | } |