perf(Prop3D): only recompute the matrix when the transform changes

Sources/Rendering/Core/Prop3D/index.js

@@ -15,11 +15,23 @@ function vtkProp3D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProp3D');
 
+  // Track the modification time of the transform inputs (origin, position,
+  // scale, rotation, userMatrix) separately so computeMatrix() does not run
+  // on every modified() event, e.g. when only the visibility changes.
+  // The _onXXXChanged hooks run before the setter's own modified() call.
+  function transformsModified() {
+    model.transformsMTime.modified();
+    publicAPI.modified();
+  }
+  model._onOriginChanged = () => model.transformsMTime.modified();
+  model._onPositionChanged = () => model.transformsMTime.modified();
+  model._onScaleChanged = () => model.transformsMTime.modified();
+
   publicAPI.addPosition = (deltaXYZ) => {
     model.position = model.position.map(
       (value, index) => value + deltaXYZ[index]
     );
-    publicAPI.modified();
+    transformsModified();
   };
 
   publicAPI.getOrientationWXYZ = () => {
@@ -42,7 +54,7 @@ function vtkProp3D(publicAPI, model) {
       model.rotation,
       vtkMath.radiansFromDegrees(val)
     );
-    publicAPI.modified();
+    transformsModified();
   };
 
   publicAPI.rotateY = (val) => {
@@ -54,7 +66,7 @@ function vtkProp3D(publicAPI, model) {
       model.rotation,
       vtkMath.radiansFromDegrees(val)
     );
-    publicAPI.modified();
+    transformsModified();
   };
 
   publicAPI.rotateZ = (val) => {
@@ -66,7 +78,7 @@ function vtkProp3D(publicAPI, model) {
       model.rotation,
       vtkMath.radiansFromDegrees(val)
     );
-    publicAPI.modified();
+    transformsModified();
   };
 
   publicAPI.rotateWXYZ = (degrees, x, y, z) => {
@@ -83,7 +95,7 @@ function vtkProp3D(publicAPI, model) {
     const quatMat = new Float64Array(16);
     mat4.fromQuat(quatMat, q);
     mat4.multiply(model.rotation, model.rotation, quatMat);
-    publicAPI.modified();
+    transformsModified();
   };
 
   publicAPI.rotateQuaternion = (orientationQuaternion) => {
@@ -96,7 +108,7 @@ function vtkProp3D(publicAPI, model) {
       orientationQuaternion
     );
     mat4.multiply(model.rotation, model.rotation, oriQuatMat);
-    publicAPI.modified();
+    transformsModified();
   };
 
   publicAPI.setOrientation = (x, y, z) => {
@@ -112,7 +124,7 @@ function vtkProp3D(publicAPI, model) {
     publicAPI.rotateZ(z);
     publicAPI.rotateX(x);
     publicAPI.rotateY(y);
-    publicAPI.modified();
+    transformsModified();
     return true;
   };
 
@@ -121,7 +133,7 @@ function vtkProp3D(publicAPI, model) {
     mat4.fromQuat(rotation, q);
     if (!vtkMath.areMatricesEqual(rotation, model.rotation)) {
       model.rotation = rotation;
-      publicAPI.modified();
+      transformsModified();
       return true;
     }
     return false;
@@ -132,7 +144,7 @@ function vtkProp3D(publicAPI, model) {
       return false;
     }
     mat4.copy(model.userMatrix, matrix);
-    publicAPI.modified();
+    transformsModified();
     return true;
   };
 
@@ -143,7 +155,7 @@ function vtkProp3D(publicAPI, model) {
 
   publicAPI.computeMatrix = () => {
     // check whether or not need to rebuild the matrix
-    if (publicAPI.getMTime() > model.matrixMTime.getMTime()) {
+    if (model.transformsMTime.getMTime() > model.matrixMTime.getMTime()) {
       mat4.identity(model.matrix);
       if (model.userMatrix) {
         mat4.multiply(model.matrix, model.matrix, model.userMatrix);
@@ -303,6 +315,7 @@ const DEFAULT_VALUES = {
   cachedProp3D: null,
   isIdentity: true,
   matrixMTime: null,
+  transformsMTime: null,
 };
 
 // ----------------------------------------------------------------------------
@@ -315,6 +328,8 @@ export function extend(publicAPI, model, initialValues = {}) {
 
   model.matrixMTime = {};
   macro.obj(model.matrixMTime);
+  model.transformsMTime = {};
+  macro.obj(model.transformsMTime);
 
   // Build VTK API
   macro.get(publicAPI, model, ['isIdentity']);

Sources/Rendering/Core/Prop3D/test/testComputeMatrix.js

@@ -0,0 +1,60 @@
+import { it, expect } from 'vitest';
+
+import vtkActor from 'vtk.js/Sources/Rendering/Core/Actor';
+
+// The actor matrix only depends on the transform state (position, origin,
+// scale, orientation, userMatrix). Recomputing it on any other modification
+// (e.g. setVisibility) is wasted work.
+it('Test computeMatrix only runs on transform change', () => {
+  const actor = vtkActor.newInstance();
+  const getMatrixMTime = () =>
+    actor.getReferenceByName('matrixMTime').getMTime();
+
+  // Build the matrix once so it is up to date
+  actor.getMatrix();
+  let mtime = getMatrixMTime();
+
+  // Modifications unrelated to the transform must not trigger a matrix
+  // recomputation, neither eagerly through onModified nor lazily through
+  // getMatrix()/computeMatrix().
+  actor.setVisibility(false);
+  actor.setPickable(false);
+  actor.getProperty().setOpacity(0.5);
+  actor.getMatrix();
+  actor.computeMatrix();
+  expect(getMatrixMTime()).toBe(mtime);
+
+  // Transform changes must still recompute the matrix
+  actor.setPosition(1, 2, 3);
+  expect(getMatrixMTime()).toBeGreaterThan(mtime);
+  expect(actor.getIsIdentity()).toBe(false);
+  const matrix = actor.getMatrix();
+  expect(matrix[3]).toBe(1);
+  expect(matrix[7]).toBe(2);
+  expect(matrix[11]).toBe(3);
+
+  mtime = getMatrixMTime();
+  actor.setOrigin(1, 0, 0);
+  expect(getMatrixMTime()).toBeGreaterThan(mtime);
+
+  mtime = getMatrixMTime();
+  actor.setScale(2, 2, 2);
+  expect(getMatrixMTime()).toBeGreaterThan(mtime);
+
+  mtime = getMatrixMTime();
+  actor.rotateZ(45);
+  expect(getMatrixMTime()).toBeGreaterThan(mtime);
+  expect(actor.getIsIdentity()).toBe(false);
+
+  // Resetting the orientation to zero must reset the rotation even though
+  // rotateX/Y/Z early-return on a null angle.
+  actor.setPosition(0, 0, 0);
+  actor.setOrigin(0, 0, 0);
+  actor.setScale(1, 1, 1);
+  actor.setOrientation(30, 0, 0);
+  expect(actor.getIsIdentity()).toBe(false);
+  mtime = getMatrixMTime();
+  actor.setOrientation(0, 0, 0);
+  expect(getMatrixMTime()).toBeGreaterThan(mtime);
+  expect(actor.getIsIdentity()).toBe(true);
+});