@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/WebGPU/OpaquePass.js

@@ -1,24 +1,26 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkWebGPURenderEncoder from './RenderEncoder.js';
 import vtkWebGPUTexture from './Texture.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 
+// ----------------------------------------------------------------------------
+
 function vtkWebGPUOpaquePass(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUOpaquePass'); // this pass implements a forward rendering pipeline
+  model.classHierarchy.push('vtkWebGPUOpaquePass');
+
+  // this pass implements a forward rendering pipeline
   // if both volumes and opaque geometry are present
   // it will mix the two together by capturing a zbuffer
   // first
-
-  publicAPI.traverse = function (renNode, viewNode) {
+  publicAPI.traverse = (renNode, viewNode) => {
     if (model.deleted) {
       return;
-    } // we just render our delegates in order
-
+    }
 
+    // we just render our delegates in order
     model._currentParent = viewNode;
-    var device = viewNode.getDevice();
-
+    const device = viewNode.getDevice();
     if (!model.renderEncoder) {
       publicAPI.createRenderEncoder();
       model.colorTexture = vtkWebGPUTexture.newInstance({
@@ -28,13 +30,11 @@ function vtkWebGPUOpaquePass(publicAPI, model) {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
         format: 'rgba16float',
-
         /* eslint-disable no-undef */
-
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
       });
-      var ctView = model.colorTexture.createView('opaquePassColorTexture');
+      const ctView = model.colorTexture.createView('opaquePassColorTexture');
       model.renderEncoder.setColorTextureView(0, ctView);
       model.depthFormat = 'depth32float';
       model.depthTexture = vtkWebGPUTexture.newInstance({
@@ -46,60 +46,61 @@ function vtkWebGPUOpaquePass(publicAPI, model) {
         format: model.depthFormat,
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
       });
-      var dView = model.depthTexture.createView('opaquePassDepthTexture');
+      const dView = model.depthTexture.createView('opaquePassDepthTexture');
       model.renderEncoder.setDepthTextureView(dView);
     } else {
       model.colorTexture.resize(viewNode.getCanvas().width, viewNode.getCanvas().height);
       model.depthTexture.resize(viewNode.getCanvas().width, viewNode.getCanvas().height);
     }
-
     model.renderEncoder.attachTextureViews();
     publicAPI.setCurrentOperation('opaquePass');
     renNode.setRenderEncoder(model.renderEncoder);
     renNode.traverse(publicAPI);
   };
-
-  publicAPI.getColorTextureView = function () {
-    return model.renderEncoder.getColorTextureViews()[0];
-  };
-
-  publicAPI.getDepthTextureView = function () {
-    return model.renderEncoder.getDepthTextureView();
-  };
-
-  publicAPI.createRenderEncoder = function () {
+  publicAPI.getColorTextureView = () => model.renderEncoder.getColorTextureViews()[0];
+  publicAPI.getDepthTextureView = () => model.renderEncoder.getDepthTextureView();
+  publicAPI.createRenderEncoder = () => {
     model.renderEncoder = vtkWebGPURenderEncoder.newInstance({
       label: 'OpaquePass'
-    }); // default settings are fine for this
-
+    });
+    // default settings are fine for this
     model.renderEncoder.setPipelineHash('op');
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   renderEncoder: null,
   colorTexture: null,
   depthTexture: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   vtkRenderPass.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['colorTexture', 'depthTexture']); // Object methods
+  macro.get(publicAPI, model, ['colorTexture', 'depthTexture']);
 
+  // Object methods
   vtkWebGPUOpaquePass(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebGPUOpaquePass');
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUOpaquePass'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUOpaquePass$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUOpaquePass$1 as default, extend, newInstance };

package/Rendering/WebGPU/OrderIndependentTranslucentPass.js

@@ -1,28 +1,56 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkWebGPUTexture from './Texture.js';
 import vtkWebGPURenderEncoder from './RenderEncoder.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
 
-var oitpFragTemplate = "\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n@fragment\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var tcoord: vec2<i32> = vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y));\n  var reveal: f32 = textureLoad(oitpAccumTexture, tcoord, 0).r;\n  if (reveal == 1.0) { discard; }\n  var tcolor: vec4<f32> = textureLoad(oitpColorTexture, tcoord, 0);\n  var total: f32 = max(tcolor.a, 0.01);\n  var computedColor: vec4<f32> = vec4<f32>(tcolor.r/total, tcolor.g/total, tcolor.b/total, 1.0 - reveal);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
+// ----------------------------------------------------------------------------
+
+const oitpFragTemplate = `
+//VTK::Mapper::Dec
+
+//VTK::TCoord::Dec
+
+//VTK::RenderEncoder::Dec
 
+//VTK::IOStructs::Dec
+
+@fragment
+fn main(
+//VTK::IOStructs::Input
+)
+//VTK::IOStructs::Output
+{
+  var output: fragmentOutput;
+
+  var tcoord: vec2<i32> = vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y));
+  var reveal: f32 = textureLoad(oitpAccumTexture, tcoord, 0).r;
+  if (reveal == 1.0) { discard; }
+  var tcolor: vec4<f32> = textureLoad(oitpColorTexture, tcoord, 0);
+  var total: f32 = max(tcolor.a, 0.01);
+  var computedColor: vec4<f32> = vec4<f32>(tcolor.r/total, tcolor.g/total, tcolor.b/total, 1.0 - reveal);
+
+  //VTK::RenderEncoder::Impl
+  return output;
+}
+`;
 function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUOrderIndependentTranslucentPass'); // this pass implements a forward rendering pipeline
+  model.classHierarchy.push('vtkWebGPUOrderIndependentTranslucentPass');
+
+  // this pass implements a forward rendering pipeline
   // if both volumes and opaque geometry are present
   // it will mix the two together by capturing a zbuffer
   // first
-
-  publicAPI.traverse = function (renNode, viewNode) {
+  publicAPI.traverse = (renNode, viewNode) => {
     if (model.deleted) {
       return;
-    } // we just render our delegates in order
-
+    }
 
+    // we just render our delegates in order
     model._currentParent = viewNode;
-    var device = viewNode.getDevice();
-
+    const device = viewNode.getDevice();
     if (!model.translucentRenderEncoder) {
       publicAPI.createRenderEncoder();
       publicAPI.createFinalEncoder();
@@ -33,13 +61,11 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
         format: 'rgba16float',
-
         /* eslint-disable no-undef */
-
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
       });
-      var v1 = model.translucentColorTexture.createView('oitpColorTexture');
+      const v1 = model.translucentColorTexture.createView('oitpColorTexture');
       model.translucentRenderEncoder.setColorTextureView(0, v1);
       model.translucentAccumulateTexture = vtkWebGPUTexture.newInstance({
         label: 'translucentPassAccumulate'
@@ -48,13 +74,11 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
         format: 'r16float',
-
         /* eslint-disable no-undef */
-
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
       });
-      var v2 = model.translucentAccumulateTexture.createView('oitpAccumTexture');
+      const v2 = model.translucentAccumulateTexture.createView('oitpAccumTexture');
       model.translucentRenderEncoder.setColorTextureView(1, v2);
       model.fullScreenQuad = vtkWebGPUFullScreenQuad.newInstance();
       model.fullScreenQuad.setDevice(viewNode.getDevice());
@@ -65,7 +89,6 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
       model.translucentColorTexture.resizeToMatch(model.colorTextureView.getTexture());
       model.translucentAccumulateTexture.resizeToMatch(model.colorTextureView.getTexture());
     }
-
     model.translucentRenderEncoder.setDepthTextureView(model.depthTextureView);
     model.translucentRenderEncoder.attachTextureViews();
     publicAPI.setCurrentOperation('translucentPass');
@@ -73,8 +96,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
     renNode.traverse(publicAPI);
     publicAPI.finalPass(viewNode, renNode);
   };
-
-  publicAPI.finalPass = function (viewNode, renNode) {
+  publicAPI.finalPass = (viewNode, renNode) => {
     model.translucentFinalEncoder.setColorTextureView(0, model.colorTextureView);
     model.translucentFinalEncoder.attachTextureViews();
     model.translucentFinalEncoder.begin(viewNode.getCommandEncoder());
@@ -82,16 +104,12 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
     model.fullScreenQuad.prepareAndDraw(model.translucentFinalEncoder);
     model.translucentFinalEncoder.end();
   };
-
-  publicAPI.getTextures = function () {
-    return [model.translucentColorTexture, model.translucentAccumulateTexture];
-  };
-
-  publicAPI.createRenderEncoder = function () {
+  publicAPI.getTextures = () => [model.translucentColorTexture, model.translucentAccumulateTexture];
+  publicAPI.createRenderEncoder = () => {
     model.translucentRenderEncoder = vtkWebGPURenderEncoder.newInstance({
       label: 'translucentRender'
     });
-    var rDesc = model.translucentRenderEncoder.getDescription();
+    const rDesc = model.translucentRenderEncoder.getDescription();
     rDesc.colorAttachments = [{
       view: undefined,
       clearValue: [0.0, 0.0, 0.0, 0.0],
@@ -108,13 +126,14 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
       depthLoadOp: 'load',
       depthStoreOp: 'store'
     };
-    model.translucentRenderEncoder.setReplaceShaderCodeFunction(function (pipeline) {
-      var fDesc = pipeline.getShaderDescription('fragment');
+    model.translucentRenderEncoder.setReplaceShaderCodeFunction(pipeline => {
+      const fDesc = pipeline.getShaderDescription('fragment');
       fDesc.addOutput('vec4<f32>', 'outColor');
       fDesc.addOutput('f32', 'outAccum');
       fDesc.addBuiltinInput('vec4<f32>', '@builtin(position) fragPos');
-      var code = fDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', [// very simple depth weighting in w z ranges from 1.0 near to 0.0
+      let code = fDesc.getCode();
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', [
+      // very simple depth weighting in w z ranges from 1.0 near to 0.0
       'var w: f32 = computedColor.a * pow(0.1 + input.fragPos.z, 2.0);', 'output.outColor = vec4<f32>(computedColor.rgb*w, w);', 'output.outAccum = computedColor.a;']).result;
       fDesc.setCode(code);
     });
@@ -157,8 +176,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
       }
     });
   };
-
-  publicAPI.createFinalEncoder = function () {
+  publicAPI.createFinalEncoder = () => {
     model.translucentFinalEncoder = vtkWebGPURenderEncoder.newInstance({
       label: 'translucentFinal'
     });
@@ -169,11 +187,11 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
         storeOp: 'store'
       }]
     });
-    model.translucentFinalEncoder.setReplaceShaderCodeFunction(function (pipeline) {
-      var fDesc = pipeline.getShaderDescription('fragment');
+    model.translucentFinalEncoder.setReplaceShaderCodeFunction(pipeline => {
+      const fDesc = pipeline.getShaderDescription('fragment');
       fDesc.addOutput('vec4<f32>', 'outColor');
       fDesc.addBuiltinInput('vec4<f32>', '@builtin(position) fragPos');
-      var code = fDesc.getCode();
+      let code = fDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);']).result;
       fDesc.setCode(code);
     });
@@ -199,31 +217,40 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
       }
     });
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   colorTextureView: null,
   depthTextureView: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   vtkRenderPass.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['colorTextureView', 'depthTextureView']); // Object methods
+  macro.setGet(publicAPI, model, ['colorTextureView', 'depthTextureView']);
 
+  // Object methods
   vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUOrderIndependentTranslucentPass'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebGPUOrderIndependentTranslucentPass');
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUOrderIndepenentTranslucentPass = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUOrderIndepenentTranslucentPass as default, extend, newInstance };

package/Rendering/WebGPU/Pipeline.js

@@ -1,94 +1,75 @@
-import { newInstance as newInstance$1, obj, get, setGet } from '../../macros.js';
+import { n as newInstance$1, o as obj, g as get, e as setGet } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUPipeline methods
 // ----------------------------------------------------------------------------
-
 function vtkWebGPUPipeline(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUPipeline');
-
-  publicAPI.getShaderDescriptions = function () {
-    return model.shaderDescriptions;
-  };
-
-  publicAPI.initialize = function (device, hash) {
+  publicAPI.getShaderDescriptions = () => model.shaderDescriptions;
+  publicAPI.initialize = (device, hash) => {
     // start with the renderencoder settings
     model.pipelineDescription = model.renderEncoder.getPipelineSettings();
     model.pipelineDescription.primitive.topology = model.topology;
     model.pipelineDescription.vertex = model.vertexState;
-    model.pipelineDescription.label = hash; // add in bind group layouts
-
-    var bindGroupLayouts = [];
+    model.pipelineDescription.label = hash;
 
-    for (var i = 0; i < model.layouts.length; i++) {
+    // add in bind group layouts
+    const bindGroupLayouts = [];
+    for (let i = 0; i < model.layouts.length; i++) {
       bindGroupLayouts.push(model.layouts[i].layout);
     }
-
     model.pipelineLayout = device.getHandle().createPipelineLayout({
-      bindGroupLayouts: bindGroupLayouts
+      bindGroupLayouts
     });
     model.pipelineDescription.layout = model.pipelineLayout;
-
-    for (var _i = 0; _i < model.shaderDescriptions.length; _i++) {
-      var sd = model.shaderDescriptions[_i];
-      var sm = device.getShaderModule(sd);
-
+    for (let i = 0; i < model.shaderDescriptions.length; i++) {
+      const sd = model.shaderDescriptions[i];
+      const sm = device.getShaderModule(sd);
       if (sd.getType() === 'vertex') {
         model.pipelineDescription.vertex.module = sm.getHandle();
         model.pipelineDescription.vertex.entryPoint = 'main';
       }
-
       if (sd.getType() === 'fragment') {
         model.pipelineDescription.fragment.module = sm.getHandle();
         model.pipelineDescription.fragment.entryPoint = 'main';
       }
     }
-
     model.handle = device.getHandle().createRenderPipeline(model.pipelineDescription);
   };
-
-  publicAPI.getShaderDescription = function (stype) {
-    for (var i = 0; i < model.shaderDescriptions.length; i++) {
+  publicAPI.getShaderDescription = stype => {
+    for (let i = 0; i < model.shaderDescriptions.length; i++) {
       if (model.shaderDescriptions[i].getType() === stype) return model.shaderDescriptions[i];
     }
-
     return null;
   };
-
-  publicAPI.addBindGroupLayout = function (bindGroup) {
+  publicAPI.addBindGroupLayout = bindGroup => {
     if (!bindGroup) {
       return;
     }
-
     model.layouts.push({
       layout: bindGroup.getBindGroupLayout(model.device),
       label: bindGroup.getLabel()
     });
   };
-
-  publicAPI.getBindGroupLayout = function (idx) {
-    return model.layouts[idx].layout;
-  };
-
-  publicAPI.getBindGroupLayoutCount = function (llabel) {
-    for (var i = 0; i < model.layouts.length; i++) {
+  publicAPI.getBindGroupLayout = idx => model.layouts[idx].layout;
+  publicAPI.getBindGroupLayoutCount = llabel => {
+    for (let i = 0; i < model.layouts.length; i++) {
       if (model.layouts[i].label === llabel) {
         return i;
       }
     }
-
     return 0;
   };
-
-  publicAPI.bindVertexInput = function (renderEncoder, vInput) {
+  publicAPI.bindVertexInput = (renderEncoder, vInput) => {
     vInput.bindBuffers(renderEncoder);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   handle: null,
   layouts: null,
   renderEncoder: null,
@@ -96,27 +77,32 @@ var DEFAULT_VALUES = {
   vertexState: null,
   topology: null,
   pipelineDescription: null
-}; // ----------------------------------------------------------------------------
+};
 
+// ----------------------------------------------------------------------------
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   obj(publicAPI, model);
   model.layouts = [];
   model.shaderDescriptions = [];
   get(publicAPI, model, ['handle', 'pipelineDescription']);
-  setGet(publicAPI, model, ['device', 'renderEncoder', 'topology', 'vertexState']); // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  setGet(publicAPI, model, ['device', 'renderEncoder', 'topology', 'vertexState']);
 
+  // For more macro methods, see "Sources/macros.js"
+  // Object specific methods
   vtkWebGPUPipeline(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUPipeline'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPUPipeline');
 
+// ----------------------------------------------------------------------------
 var vtkWebGPUPipeline$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUPipeline$1 as default, extend, newInstance };

package/Rendering/WebGPU/PixelSpaceCallbackMapper.js

@@ -1,48 +1,56 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUPixelSpaceCallbackMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUPixelSpaceCallbackMapper(publicAPI, model) {
   model.classHierarchy.push('vtkWebGPUPixelSpaceCallbackMapper');
-
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  publicAPI.opaquePass = (prepass, renderPass) => {
     model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
     model.WebGPURenderWindow = model.WebGPURenderer.getParent();
-    var aspectRatio = model.WebGPURenderer.getAspectRatio();
-    var camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
-    var tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
-    var texels = null;
-
+    const aspectRatio = model.WebGPURenderer.getAspectRatio();
+    const camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
+    const tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
+    const texels = null;
     if (model.renderable.getUseZValues()) ;
-
     model.renderable.invokeCallback(model.renderable.getInputData(), camera, aspectRatio, tsize, texels);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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);
 
-  vtkViewNode.extend(publicAPI, model, initialValues); // Object methods
+  // Inheritance
+  vtkViewNode.extend(publicAPI, model, initialValues);
 
+  // Object methods
   vtkWebGPUPixelSpaceCallbackMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUPixelSpaceCallbackMapper'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkWebGPUPixelSpaceCallbackMapper');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkPixelSpaceCallbackMapper', newInstance);
 
 export { index as default, extend, newInstance };