@kitware/vtk.js 33.0.0-beta.4 → 33.0.1

package/Rendering/OpenGL/PolyDataMapper.js

@@ -2,7 +2,7 @@ import { mat3, mat4, vec3 } from 'gl-matrix';
 import { n as newInstance$1, e as setGet, o as obj, c as macro } from '../../macros2.js';
 import vtkHelper from './Helper.js';
 import vtkMapper from '../Core/Mapper.js';
-import { l as normalize } from '../../Common/Core/Math/index.js';
+import { l as normalize, u as uninitializeBounds } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkProp from '../Core/Prop.js';
 import vtkProperty from '../Core/Property.js';
@@ -941,6 +941,13 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
   };
+  publicAPI.computeBounds = (ren, actor) => {
+    if (!publicAPI.getInput()) {
+      uninitializeBounds(model.bounds);
+      return;
+    }
+    model.bounds = publicAPI.getInput().getBounds();
+  };
   publicAPI.updateBufferObjects = (ren, actor) => {
     // Rebuild buffers if needed
     if (publicAPI.getNeedToRebuildBufferObjects(ren, actor)) {

package/Rendering/OpenGL/RenderWindow/resourceSharingHelper.d.ts

@@ -9,8 +9,8 @@ import { vtkObject } from '../../../interfaces';
  * @param useIndependentComponents A boolean taken from the image or volume property, using getIndependentComponents()
  * @param numberOfComponents Taken from the data array, using getNumberOfComponents()
  */
-export function getTransferFunctionsHash(
-  transferFunctions: (vtkObject | null | undefined)[],
+export function getTransferFunctionHash(
+  transferFunction: vtkObject | undefined,
   useIndependentComponents: boolean,
   numberOfComponents: number
 ): string;
@@ -27,7 +27,7 @@ export function getImageDataHash(
 ): string;
 
 declare const defaultExport: {
-  getTransferFunctionsHash: typeof getTransferFunctionsHash;
+  getTransferFunctionHash: typeof getTransferFunctionHash;
   getImageDataHash: typeof getImageDataHash;
 };
 

package/Rendering/OpenGL/RenderWindow/resourceSharingHelper.js

@@ -1,17 +1,14 @@
 // See typescript header for documentation
 
-function getTransferFunctionsHash(transferFunctions, useIndependentComponents, numberOfComponents) {
-  return transferFunctions.length > 0 ? `${transferFunctions.map(tf => tf?.getMTime() ?? 'x').join('/')}-${useIndependentComponents}-${numberOfComponents}` : '0';
+function getTransferFunctionHash(transferFunction, useIndependentComponents, numberOfComponents) {
+  return transferFunction ? `${transferFunction.getMTime()}-${useIndependentComponents}-${numberOfComponents}` : '0';
 }
 function getImageDataHash(image, scalars) {
-  // Don't use the image data, as the scalars will define the texture
-  // If using the image data in the hash, it will cause issues when two image data
-  // using the same scalars are in the same mapper (for example the VolumeMapper)
-  return `${scalars.getMTime()}`;
+  return `${image.getMTime()}A${scalars.getMTime()}`;
 }
 var resourceSharingHelper = {
-  getTransferFunctionsHash,
+  getTransferFunctionHash,
   getImageDataHash
 };
 
-export { resourceSharingHelper as default, getImageDataHash, getTransferFunctionsHash };
+export { resourceSharingHelper as default, getImageDataHash, getTransferFunctionHash };

package/Rendering/OpenGL/SphereMapper.js

@@ -8,6 +8,7 @@ import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import { v as vtkSphereMapperVS } from './glsl/vtkSphereMapperVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import { computeCoordShiftAndScale } from './CellArrayBufferObject/helpers.js';
 
 const {
   vtkErrorMacro
@@ -112,14 +113,24 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
     if (program.isUniformUsed('VCPCMatrix')) {
       program.setUniformMatrix('VCPCMatrix', keyMats.vcpc);
     }
+
+    // mat4.create() defaults to Float32Array b/c of gl-matrix's settings.
+    // We need Float64Array to avoid loss of precision with large coordinates.
+    const tmp4 = new Float64Array(16);
     if (program.isUniformUsed('MCVCMatrix')) {
       if (!actor.getIsIdentity()) {
         const actMats = model.openGLActor.getKeyMatrices();
-        const tmp4 = new Float64Array(16);
         mat4.multiply(tmp4, keyMats.wcvc, actMats.mcwc);
+        if (cellBO.getCABO().getCoordShiftAndScaleEnabled()) {
+          mat4.multiply(tmp4, tmp4, cellBO.getCABO().getInverseShiftAndScaleMatrix());
+        }
         program.setUniformMatrix('MCVCMatrix', tmp4);
       } else {
-        program.setUniformMatrix('MCVCMatrix', keyMats.wcvc);
+        mat4.copy(tmp4, keyMats.wcvc);
+        if (cellBO.getCABO().getCoordShiftAndScaleEnabled()) {
+          mat4.multiply(tmp4, tmp4, cellBO.getCABO().getInverseShiftAndScaleMatrix());
+        }
+        program.setUniformMatrix('MCVCMatrix', tmp4);
       }
     }
     if (program.isUniformUsed('cameraParallel')) {
@@ -166,6 +177,14 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
     const cos30 = Math.cos(radiansFromDegrees(30.0));
     let pointIdx = 0;
     let colorIdx = 0;
+    const {
+      useShiftAndScale,
+      coordShift,
+      coordScale
+    } = computeCoordShiftAndScale(points);
+    if (useShiftAndScale) {
+      vbo.setCoordShiftAndScale(coordShift, coordScale);
+    }
 
     //
     // Generate points and point data for sides
@@ -178,9 +197,12 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         radius = scales[i];
       }
       pointIdx = i * 3;
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
+      const ptX = (pointArray[pointIdx++] - coordShift[0]) * coordScale[0];
+      const ptY = (pointArray[pointIdx++] - coordShift[1]) * coordScale[1];
+      const ptZ = (pointArray[pointIdx++] - coordShift[2]) * coordScale[2];
+      packedVBO[vboIdx++] = ptX;
+      packedVBO[vboIdx++] = ptY;
+      packedVBO[vboIdx++] = ptZ;
       packedVBO[vboIdx++] = -2.0 * radius * cos30;
       packedVBO[vboIdx++] = -radius;
       if (colorData) {
@@ -190,10 +212,9 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         packedUCVBO[ucIdx++] = colorData[colorIdx + 2];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 3];
       }
-      pointIdx = i * 3;
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
+      packedVBO[vboIdx++] = ptX;
+      packedVBO[vboIdx++] = ptY;
+      packedVBO[vboIdx++] = ptZ;
       packedVBO[vboIdx++] = 2.0 * radius * cos30;
       packedVBO[vboIdx++] = -radius;
       if (colorData) {
@@ -202,10 +223,9 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         packedUCVBO[ucIdx++] = colorData[colorIdx + 2];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 3];
       }
-      pointIdx = i * 3;
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
+      packedVBO[vboIdx++] = ptX;
+      packedVBO[vboIdx++] = ptY;
+      packedVBO[vboIdx++] = ptZ;
       packedVBO[vboIdx++] = 0.0;
       packedVBO[vboIdx++] = 2.0 * radius;
       if (colorData) {