@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/WebGPU/SphereMapper.js

@@ -1,93 +1,181 @@
-import { newInstance as newInstance$1, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
+import { n as newInstance$1, c as macro } from '../../macros2.js';
 import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkWebGPUCellArrayMapper from './CellArrayMapper.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-var BufferUsage = vtkWebGPUBufferManager.BufferUsage;
-var vtkErrorMacro = vtkErrorMacro$1;
-var vtkWebGPUSphereMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.xyz, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = length(offsetMC)*0.5;\n\n  // make the triangle face the camera\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    var dir: vec3<f32> = normalize(-vertexVC.xyz);\n    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));\n    var base1: vec3<f32> = cross(base2,dir);\n    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;\n    vertexVC = vec4<f32>(dir, 1.0);\n    }\n  else\n    {\n    // add in the offset\n    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;\n    vertexVC = vec4<f32>(tmp2, vertexVC.zw);\n    }\n\n  output.vertexVC = vec4<f32>(vertexVC.xyz, 0.0);\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+const {
+  BufferUsage
+} = vtkWebGPUBufferManager;
+const {
+  vtkErrorMacro
+} = macro;
+const vtkWebGPUSphereMapperVS = `
+//VTK::Renderer::Dec
+
+//VTK::Mapper::Dec
+
+//VTK::Color::Dec
+
+//VTK::IOStructs::Dec
+
+@vertex
+fn main(
+//VTK::IOStructs::Input
+)
+//VTK::IOStructs::Output
+{
+  var output : vertexOutput;
+
+  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.xyz, 1.0);
+
+  //VTK::Color::Impl
+
+  // compute the projected vertex position
+  output.centerVC = vertexVC.xyz;
+  output.radiusVC = length(offsetMC)*0.5;
+
+  // make the triangle face the camera
+  if (rendererUBO.cameraParallel == 0u)
+    {
+    var dir: vec3<f32> = normalize(-vertexVC.xyz);
+    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));
+    var base1: vec3<f32> = cross(base2,dir);
+    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;
+    vertexVC = vec4<f32>(dir, 1.0);
+    }
+  else
+    {
+    // add in the offset
+    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;
+    vertexVC = vec4<f32>(tmp2, vertexVC.zw);
+    }
+
+  output.vertexVC = vec4<f32>(vertexVC.xyz, 0.0);
+
+  //VTK::Position::Impl
+
+  return output;
+}
+`;
+
+// ----------------------------------------------------------------------------
 // vtkWebGPUSphereMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUSphereMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUSphereMapper');
-  var cellMapperBuildPass = publicAPI.buildPass;
-
-  publicAPI.buildPass = function (prepass) {
+  const cellMapperBuildPass = publicAPI.buildPass;
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       if (!model.renderable.getStatic()) {
         model.renderable.update();
       }
-
-      var poly = model.renderable.getInputData();
+      const poly = model.renderable.getInputData();
       publicAPI.setCellArray(poly.getVerts());
       publicAPI.setCurrentInput(poly);
     }
-
     cellMapperBuildPass(prepass);
   };
-
-  publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
-    var vDesc = pipeline.getShaderDescription('vertex');
+  publicAPI.replaceShaderNormal = (hash, pipeline, vertexInput) => {
+    const vDesc = pipeline.getShaderDescription('vertex');
     if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec4<f32>', 'vertexVC');
     vDesc.addOutput('vec3<f32>', 'centerVC');
     vDesc.addOutput('f32', 'radiusVC');
-    var fDesc = pipeline.getShaderDescription('fragment');
+    const fDesc = pipeline.getShaderDescription('fragment');
     fDesc.addBuiltinOutput('f32', '@builtin(frag_depth) fragDepth');
-    var sphereFrag = "\n    // compute the eye position and unit direction\n    var vertexVC: vec4<f32>;\n    var EyePos: vec3<f32>;\n    var EyeDir: vec3<f32>;\n    var invertedDepth: f32 = 1.0;\n    if (rendererUBO.cameraParallel != 0u) {\n      EyePos = vec3<f32>(input.vertexVC.x, input.vertexVC.y, input.vertexVC.z + 3.0*input.radiusVC);\n      EyeDir = vec3<f32>(0.0, 0.0, -1.0);\n    }\n    else {\n      EyeDir = input.vertexVC.xyz;\n      EyePos = vec3<f32>(0.0,0.0,0.0);\n      var lengthED: f32 = length(EyeDir);\n      EyeDir = normalize(EyeDir);\n      // we adjust the EyePos to be closer if it is too far away\n      // to prevent floating point precision noise\n      if (lengthED > input.radiusVC*3.0) {\n        EyePos = input.vertexVC.xyz - EyeDir*3.0*input.radiusVC;\n      }\n    }\n\n    // translate to Sphere center\n    EyePos = EyePos - input.centerVC;\n    // scale to radius 1.0\n    EyePos = EyePos * (1.0 / input.radiusVC);\n    // find the intersection\n    var b: f32 = 2.0*dot(EyePos,EyeDir);\n    var c: f32 = dot(EyePos,EyePos) - 1.0;\n    var d: f32 = b*b - 4.0*c;\n    var normal: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n    if (d < 0.0) { discard; }\n    else {\n      var t: f32 = (-b - invertedDepth*sqrt(d))*0.5;\n\n      // compute the normal, for unit sphere this is just\n      // the intersection point\n      normal = invertedDepth*normalize(EyePos + t*EyeDir);\n      // compute the intersection point in VC\n      vertexVC = vec4<f32>(normal * input.radiusVC + input.centerVC, 1.0);\n    }\n    // compute the pixel's depth\n    var pos: vec4<f32> = rendererUBO.VCPCMatrix * vertexVC;\n    output.fragDepth = pos.z / pos.w;\n    ";
-    var code = fDesc.getCode();
+    const sphereFrag = `
+    // compute the eye position and unit direction
+    var vertexVC: vec4<f32>;
+    var EyePos: vec3<f32>;
+    var EyeDir: vec3<f32>;
+    var invertedDepth: f32 = 1.0;
+    if (rendererUBO.cameraParallel != 0u) {
+      EyePos = vec3<f32>(input.vertexVC.x, input.vertexVC.y, input.vertexVC.z + 3.0*input.radiusVC);
+      EyeDir = vec3<f32>(0.0, 0.0, -1.0);
+    }
+    else {
+      EyeDir = input.vertexVC.xyz;
+      EyePos = vec3<f32>(0.0,0.0,0.0);
+      var lengthED: f32 = length(EyeDir);
+      EyeDir = normalize(EyeDir);
+      // we adjust the EyePos to be closer if it is too far away
+      // to prevent floating point precision noise
+      if (lengthED > input.radiusVC*3.0) {
+        EyePos = input.vertexVC.xyz - EyeDir*3.0*input.radiusVC;
+      }
+    }
+
+    // translate to Sphere center
+    EyePos = EyePos - input.centerVC;
+    // scale to radius 1.0
+    EyePos = EyePos * (1.0 / input.radiusVC);
+    // find the intersection
+    var b: f32 = 2.0*dot(EyePos,EyeDir);
+    var c: f32 = dot(EyePos,EyePos) - 1.0;
+    var d: f32 = b*b - 4.0*c;
+    var normal: vec3<f32> = vec3<f32>(0.0,0.0,1.0);
+    if (d < 0.0) { discard; }
+    else {
+      var t: f32 = (-b - invertedDepth*sqrt(d))*0.5;
+
+      // compute the normal, for unit sphere this is just
+      // the intersection point
+      normal = invertedDepth*normalize(EyePos + t*EyeDir);
+      // compute the intersection point in VC
+      vertexVC = vec4<f32>(normal * input.radiusVC + input.centerVC, 1.0);
+    }
+    // compute the pixel's depth
+    var pos: vec4<f32> = rendererUBO.VCPCMatrix * vertexVC;
+    output.fragDepth = pos.z / pos.w;
+    `;
+    let code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', [sphereFrag]).result;
     fDesc.setCode(code);
   };
-
-  publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
-    var vDesc = pipeline.getShaderDescription('vertex');
+  publicAPI.replaceShaderPosition = (hash, pipeline, vertexInput) => {
+    const vDesc = pipeline.getShaderDescription('vertex');
     vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
-    var code = vDesc.getCode();
+    let code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['  output.Position = rendererUBO.VCPCMatrix*vertexVC;']).result;
     vDesc.setCode(code);
-  }; // compute a unique hash for a pipeline, this needs to be unique enough to
+  };
+
+  // compute a unique hash for a pipeline, this needs to be unique enough to
   // capture any pipeline code changes (which includes shader changes)
   // or vertex input changes/ bind groups/ etc
-
-
-  publicAPI.computePipelineHash = function () {
+  publicAPI.computePipelineHash = () => {
     model.pipelineHash = 'spm';
-
-    if (model.vertexInput.hasAttribute("colorVI")) {
-      model.pipelineHash += "c";
+    if (model.vertexInput.hasAttribute(`colorVI`)) {
+      model.pipelineHash += `c`;
     }
-
     model.pipelineHash += model.renderEncoder.getPipelineHash();
   };
-
-  publicAPI.updateBuffers = function () {
-    var poly = model.currentInput;
+  publicAPI.updateBuffers = () => {
+    const poly = model.currentInput;
     model.renderable.mapScalars(poly, 1.0);
-    var points = poly.getPoints();
-    var numPoints = points.getNumberOfPoints();
-    var pointArray = points.getData(); // default to one instance and computed number of verts
+    const points = poly.getPoints();
+    const numPoints = points.getNumberOfPoints();
+    const pointArray = points.getData();
 
+    // default to one instance and computed number of verts
     publicAPI.setNumberOfInstances(1);
     publicAPI.setNumberOfVertices(3 * numPoints);
-    var vertexInput = model.vertexInput;
-    var hash = "spm".concat(points.getMTime(), "float32x3");
-
+    const vertexInput = model.vertexInput;
+    let hash = `spm${points.getMTime()}float32x3`;
     if (!model.device.getBufferManager().hasBuffer(hash)) {
-      var buffRequest = {
-        hash: hash,
+      const buffRequest = {
+        hash,
         usage: BufferUsage.RawVertex,
         format: 'float32x3'
-      }; // xyz v1 v2 v3
-
-      var tmpVBO = new Float32Array(3 * numPoints * 3);
-      var pointIdx = 0;
-      var vboIdx = 0;
-
-      for (var id = 0; id < numPoints; ++id) {
+      };
+      // xyz v1 v2 v3
+      const tmpVBO = new Float32Array(3 * numPoints * 3);
+      let pointIdx = 0;
+      let vboIdx = 0;
+      for (let id = 0; id < numPoints; ++id) {
         pointIdx = id * 3;
         tmpVBO[vboIdx++] = pointArray[pointIdx];
         tmpVBO[vboIdx++] = pointArray[pointIdx + 1];
@@ -99,144 +187,126 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
         tmpVBO[vboIdx++] = pointArray[pointIdx + 1];
         tmpVBO[vboIdx++] = pointArray[pointIdx + 2];
       }
-
       buffRequest.nativeArray = tmpVBO;
-      var buff = model.device.getBufferManager().getBuffer(buffRequest);
+      const buff = model.device.getBufferManager().getBuffer(buffRequest);
       vertexInput.addBuffer(buff, ['vertexBC']);
-    } // compute offset VBO
-
-
-    var pointData = poly.getPointData();
-    var scales = null;
+    }
 
+    // compute offset VBO
+    const pointData = poly.getPointData();
+    let scales = null;
     if (model.renderable.getScaleArray() != null && pointData.hasArray(model.renderable.getScaleArray())) {
       scales = pointData.getArray(model.renderable.getScaleArray()).getData();
     }
-
-    var defaultRadius = model.renderable.getRadius();
-
+    const defaultRadius = model.renderable.getRadius();
     if (scales || defaultRadius !== model._lastRadius) {
-      hash = "spm".concat(scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : defaultRadius, "float32x2");
-
+      hash = `spm${scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : defaultRadius}float32x2`;
       if (!model.device.getBufferManager().hasBuffer(hash)) {
-        var _buffRequest = {
-          hash: hash,
+        const buffRequest = {
+          hash,
           usage: BufferUsage.RawVertex,
           format: 'float32x2'
         };
-
-        var _tmpVBO = new Float32Array(3 * numPoints * 2);
-
-        var cos30 = Math.cos(radiansFromDegrees(30.0));
-        var _vboIdx = 0;
-
-        for (var _id = 0; _id < numPoints; ++_id) {
-          var radius = model.renderable.getRadius();
-
+        const tmpVBO = new Float32Array(3 * numPoints * 2);
+        const cos30 = Math.cos(radiansFromDegrees(30.0));
+        let vboIdx = 0;
+        for (let id = 0; id < numPoints; ++id) {
+          let radius = model.renderable.getRadius();
           if (scales) {
-            radius = scales[_id] * model.renderable.getScaleFactor();
+            radius = scales[id] * model.renderable.getScaleFactor();
           }
-
-          _tmpVBO[_vboIdx++] = -2.0 * radius * cos30;
-          _tmpVBO[_vboIdx++] = -radius;
-          _tmpVBO[_vboIdx++] = 2.0 * radius * cos30;
-          _tmpVBO[_vboIdx++] = -radius;
-          _tmpVBO[_vboIdx++] = 0.0;
-          _tmpVBO[_vboIdx++] = 2.0 * radius;
+          tmpVBO[vboIdx++] = -2.0 * radius * cos30;
+          tmpVBO[vboIdx++] = -radius;
+          tmpVBO[vboIdx++] = 2.0 * radius * cos30;
+          tmpVBO[vboIdx++] = -radius;
+          tmpVBO[vboIdx++] = 0.0;
+          tmpVBO[vboIdx++] = 2.0 * radius;
         }
-
-        _buffRequest.nativeArray = _tmpVBO;
-
-        var _buff = model.device.getBufferManager().getBuffer(_buffRequest);
-
-        vertexInput.addBuffer(_buff, ['offsetMC']);
+        buffRequest.nativeArray = tmpVBO;
+        const buff = model.device.getBufferManager().getBuffer(buffRequest);
+        vertexInput.addBuffer(buff, ['offsetMC']);
       }
-
       model._lastRadius = defaultRadius;
-    } // deal with colors but only if modified
-
-
-    var haveColors = false;
+    }
 
+    // deal with colors but only if modified
+    let haveColors = false;
     if (model.renderable.getScalarVisibility()) {
-      var c = model.renderable.getColorMapColors();
-
+      const c = model.renderable.getColorMapColors();
       if (c) {
-        hash = "spm".concat(c.getMTime(), "unorm8x4");
-
+        hash = `spm${c.getMTime()}unorm8x4`;
         if (!model.device.getBufferManager().hasBuffer(hash)) {
-          var _buffRequest2 = {
-            hash: hash,
+          const buffRequest = {
+            hash,
             usage: BufferUsage.RawVertex,
             format: 'unorm8x4'
           };
-          var colorComponents = c.getNumberOfComponents();
-
+          const colorComponents = c.getNumberOfComponents();
           if (colorComponents !== 4) {
             vtkErrorMacro('this should be 4');
           }
-
-          var _tmpVBO2 = new Uint8Array(3 * numPoints * 4);
-
-          var _vboIdx2 = 0;
-          var colorData = c.getData();
-
-          for (var _id2 = 0; _id2 < numPoints; ++_id2) {
-            var colorIdx = _id2 * colorComponents;
-
-            for (var v = 0; v < 3; v++) {
-              _tmpVBO2[_vboIdx2++] = colorData[colorIdx];
-              _tmpVBO2[_vboIdx2++] = colorData[colorIdx + 1];
-              _tmpVBO2[_vboIdx2++] = colorData[colorIdx + 2];
-              _tmpVBO2[_vboIdx2++] = colorData[colorIdx + 3];
+          const tmpVBO = new Uint8Array(3 * numPoints * 4);
+          let vboIdx = 0;
+          const colorData = c.getData();
+          for (let id = 0; id < numPoints; ++id) {
+            const colorIdx = id * colorComponents;
+            for (let v = 0; v < 3; v++) {
+              tmpVBO[vboIdx++] = colorData[colorIdx];
+              tmpVBO[vboIdx++] = colorData[colorIdx + 1];
+              tmpVBO[vboIdx++] = colorData[colorIdx + 2];
+              tmpVBO[vboIdx++] = colorData[colorIdx + 3];
             }
           }
-
-          _buffRequest2.nativeArray = _tmpVBO2;
-
-          var _buff2 = model.device.getBufferManager().getBuffer(_buffRequest2);
-
-          vertexInput.addBuffer(_buff2, ['colorVI']);
+          buffRequest.nativeArray = tmpVBO;
+          const buff = model.device.getBufferManager().getBuffer(buffRequest);
+          vertexInput.addBuffer(buff, ['colorVI']);
         }
-
         haveColors = true;
       }
     }
-
     if (!haveColors) {
       vertexInput.removeBufferIfPresent('colorVI');
     }
-
     publicAPI.setTopology('triangle-list');
     publicAPI.updateUBO();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkWebGPUCellArrayMapper.extend(publicAPI, model, initialValues);
-  publicAPI.setVertexShaderTemplate(vtkWebGPUSphereMapperVS); // Object methods
+  publicAPI.setVertexShaderTemplate(vtkWebGPUSphereMapperVS);
 
+  // Object methods
   vtkWebGPUSphereMapper(publicAPI, model);
-  var sr = model.shaderReplacements;
+  const sr = model.shaderReplacements;
   sr.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
   sr.set('replaceShaderNormal', publicAPI.replaceShaderNormal);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUSphereMapper'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend, 'vtkWebGPUSphereMapper');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkSphereMapper', newInstance);
 
 export { index as default, extend, newInstance };