IMproving the JOb interface

samcake committed 11 years ago

Commit cc65ad32 parents d1ac314 0ef75da25 files · +749 −371Browse files

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

Unified · Split

libraries/render-utils/src/Model.cpp+38−31

     _isVisible(true),
     _blendNumber(0),
     _appliedBlendNumber(0),
+    _calculatedMeshPartOffsetValid(false),
     _calculatedMeshPartBoxesValid(false),
     _calculatedMeshBoxesValid(false),
     _calculatedMeshTrianglesValid(false),
     // we can use the AABox's ray intersection by mapping our origin and direction into the model frame
     // and testing intersection there.
     if (modelFrameBox.findRayIntersection(modelFrameOrigin, modelFrameDirection, distance, face)) {
+        if (!_calculatedMeshBoxesValid) {
+            recalculateMeshBoxes(pickAgainstTriangles);
+        }
         float bestDistance = std::numeric_limits<float>::max();
     return false;
 }
+void Model::recalculateMeshPartOffsets() {
+    if (!_calculatedMeshPartOffsetValid) {
+        const FBXGeometry& geometry = _geometry->getFBXGeometry();
+        int numberOfMeshes = geometry.meshes.size();
+        _calculatedMeshPartOffset.clear();
+        for (int i = 0; i < numberOfMeshes; i++) {
+            const FBXMesh& mesh = geometry.meshes.at(i);
+            qint64 partOffset = 0;
+            for (int j = 0; j < mesh.parts.size(); j++) {
+                const FBXMeshPart& part = mesh.parts.at(j);
+                _calculatedMeshPartOffset[QPair<int,int>(i, j)] = partOffset;
+                partOffset += part.quadIndices.size() * sizeof(int);
+                partOffset += part.triangleIndices.size() * sizeof(int);
+            }
+        }
+        _calculatedMeshPartOffsetValid = true;
+    }
+}
 // TODO: we seem to call this too often when things haven't actually changed... look into optimizing this
 // Any script might trigger findRayIntersectionAgainstSubMeshes (and maybe convexHullContains), so these
 // can occur multiple times. In addition, rendering does it's own ray picking in order to decide which
         _calculatedMeshTriangles.clear();
         _calculatedMeshTriangles.resize(numberOfMeshes);
         _calculatedMeshPartBoxes.clear();
-        _calculatedMeshPartOffet.clear();
+        _calculatedMeshPartOffset.clear();
+        _calculatedMeshPartOffsetValid = false;
         for (int i = 0; i < numberOfMeshes; i++) {
             const FBXMesh& mesh = geometry.meshes.at(i);
             Extents scaledMeshExtents = calculateScaledOffsetExtents(mesh.meshExtents);
                         }
                     }
                     _calculatedMeshPartBoxes[QPair<int,int>(i, j)] = thisPartBounds;
-                    _calculatedMeshPartOffet[QPair<int,int>(i, j)] = partOffset;
+                    _calculatedMeshPartOffset[QPair<int,int>(i, j)] = partOffset;
                     partOffset += part.quadIndices.size() * sizeof(int);
                     partOffset += part.triangleIndices.size() * sizeof(int);
                 }
                 _calculatedMeshTriangles[i] = thisMeshTriangles;
                 _calculatedMeshPartBoxesValid = true;
+                _calculatedMeshPartOffsetValid = true;
             }
         }
         _calculatedMeshBoxesValid = true;
 }
 void Model::renderSetup(RenderArgs* args) {
-    // if we don't have valid mesh boxes, calculate them now, this only matters in cases
-    // where our caller has passed RenderArgs which will include a view frustum we can cull
-    // against. We cache the results of these calculations so long as the model hasn't been
-    // simulated and the mesh hasn't changed.
-    if (args && !_calculatedMeshBoxesValid) {
-        _mutex.lock();
-        recalculateMeshBoxes();
-        _mutex.unlock();
-    }
     // set up dilated textures on first render after load/simulate
     const FBXGeometry& geometry = _geometry->getFBXGeometry();
     if (_dilatedTextures.isEmpty()) {
 }
 void Model::simulate(float deltaTime, bool fullUpdate) {
-    /*
-    qDebug() << "Model::simulate()";
-    qDebug() << "   _translation:" << _translation;
-    qDebug() << "   _rotation:" << _rotation;
-    */
     fullUpdate = updateGeometry() || fullUpdate || (_scaleToFit && !_scaledToFit)
                     || (_snapModelToRegistrationPoint && !_snappedToRegistrationPoint);
     if (isActive() && fullUpdate) {
-        // NOTE: this seems problematic... need to review
+        // NOTE: This is overly aggressive and we are invalidating the MeshBoxes when in fact they may not be invalid
-        _calculatedMeshBoxesValid = false; // if we have to simulate, we need to assume our mesh boxes are all invalid
+        //       they really only become invalid if something about the transform to world space has changed. This is
+        //       not too bad at this point, because it doesn't impact rendering. However it does slow down ray picking
+        //       because ray picking needs valid boxes to work
+        _calculatedMeshBoxesValid = false;
         _calculatedMeshTrianglesValid = false;
         // check for scale to fit
 }
 AABox Model::getPartBounds(int meshIndex, int partIndex) {
-    if (!_calculatedMeshPartBoxesValid || !_calculatedMeshBoxesValid) {
-        recalculateMeshBoxes(true);
-    }
     if (meshIndex < _meshStates.size()) {
         const MeshState& state = _meshStates.at(meshIndex);
         bool isSkinned = state.clusterMatrices.size() > 1;
         }
     }
-    if (_calculatedMeshPartBoxesValid && _calculatedMeshPartBoxes.contains(QPair<int,int>(meshIndex, partIndex))) {
+    if (_geometry->getFBXGeometry().meshes.size() > meshIndex) {
         // FIX ME! - This is currently a hack because for some mesh parts our efforts to calculate the bounding
         //           box of the mesh part fails. It seems to create boxes that are not consistent with where the
 void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool translucent) {
     PerformanceTimer perfTimer("Model::renderPart");
     if (!_readyWhenAdded) {
         return; // bail asap
     }
-    // we always need these properly calculated before we can render, this will likely already have been done
+    // We need to make sure we have valid offsets calculated before we can render
-    // since the engine will call our getPartBounds() before rendering us.
+    if (!_calculatedMeshPartOffsetValid) {
-    if (!_calculatedMeshPartBoxesValid || !_calculatedMeshBoxesValid) {
+        recalculateMeshPartOffsets();
-        recalculateMeshBoxes(true);
     }
     auto textureCache = DependencyManager::get<TextureCache>();
         }
     }
-    qint64 offset = _calculatedMeshPartOffet[QPair<int,int>(meshIndex, partIndex)];
+    qint64 offset = _calculatedMeshPartOffset[QPair<int,int>(meshIndex, partIndex)];
     if (part.quadIndices.size() > 0) {
         batch.drawIndexed(gpu::QUADS, part.quadIndices.size(), offset);