@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/WebGPU/ForwardPass.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
 import vtkWebGPUOpaquePass from './OpaquePass.js';
 import vtkWebGPUOrderIndepenentTranslucentPass from './OrderIndependentTranslucentPass.js';
@@ -8,41 +8,63 @@ import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkWebGPUSampler from './Sampler.js';
 import vtkWebGPUTextureView from './TextureView.js';
 
-var finalBlitFragTemplate = "\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 computedColor: vec4<f32> = clamp(textureSampleLevel(opaquePassColorTexture, finalPassSampler, input.tcoordVS, 0),vec4<f32>(0.0),vec4<f32>(1.0));\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+const finalBlitFragTemplate = `
+//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 computedColor: vec4<f32> = clamp(textureSampleLevel(opaquePassColorTexture, finalPassSampler, input.tcoordVS, 0),vec4<f32>(0.0),vec4<f32>(1.0));
+
+  //VTK::RenderEncoder::Impl
+  return output;
+}
+`;
+
+// ----------------------------------------------------------------------------
 
 function vtkForwardPass(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkForwardPass'); // this pass implements a forward rendering pipeline
+  model.classHierarchy.push('vtkForwardPass');
+
+  // 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 (viewNode) {
-    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
+    let parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (model.deleted) {
       return;
-    } // we just render our delegates in order
-
+    }
 
-    model._currentParent = parent; // build
+    // we just render our delegates in order
+    model._currentParent = parent;
 
+    // build
     publicAPI.setCurrentOperation('buildPass');
     viewNode.traverse(publicAPI);
-
     if (!model.opaquePass) {
       model.opaquePass = vtkWebGPUOpaquePass.newInstance();
     }
-
-    var numlayers = viewNode.getRenderable().getNumberOfLayers(); // iterate over renderers
-
-    var renderers = viewNode.getChildren();
-
-    for (var i = 0; i < numlayers; i++) {
-      for (var index = 0; index < renderers.length; index++) {
-        var renNode = renderers[index];
-        var ren = viewNode.getRenderable().getRenderers()[index];
-
+    const numlayers = viewNode.getRenderable().getNumberOfLayers();
+
+    // iterate over renderers
+    const renderers = viewNode.getChildren();
+    for (let i = 0; i < numlayers; i++) {
+      for (let index = 0; index < renderers.length; index++) {
+        const renNode = renderers[index];
+        const ren = viewNode.getRenderable().getRenderers()[index];
         if (ren.getDraw() && ren.getLayer() === i) {
           // check for both opaque and volume actors
           model.opaqueActorCount = 0;
@@ -51,65 +73,56 @@ function vtkForwardPass(publicAPI, model) {
           publicAPI.setCurrentOperation('queryPass');
           renNode.traverse(publicAPI);
           publicAPI.setCurrentOperation('cameraPass');
-          renNode.traverse(publicAPI); // always do opaque pass to get a valid color and zbuffer, even if empty
+          renNode.traverse(publicAPI);
 
-          model.opaquePass.traverse(renNode, viewNode); // optional translucent pass
+          // always do opaque pass to get a valid color and zbuffer, even if empty
+          model.opaquePass.traverse(renNode, viewNode);
 
+          // optional translucent pass
           if (model.translucentActorCount > 0) {
             if (!model.translucentPass) {
               model.translucentPass = vtkWebGPUOrderIndepenentTranslucentPass.newInstance();
             }
-
             model.translucentPass.setColorTextureView(model.opaquePass.getColorTextureView());
             model.translucentPass.setDepthTextureView(model.opaquePass.getDepthTextureView());
             model.translucentPass.traverse(renNode, viewNode);
-          } // optional volume pass
-
+          }
 
+          // optional volume pass
           if (model.volumes.length > 0) {
             if (!model.volumePass) {
               model.volumePass = vtkWebGPUVolumePass.newInstance();
             }
-
             model.volumePass.setColorTextureView(model.opaquePass.getColorTextureView());
             model.volumePass.setDepthTextureView(model.opaquePass.getDepthTextureView());
             model.volumePass.setVolumes(model.volumes);
             model.volumePass.traverse(renNode, viewNode);
-          } // blit the result into the swap chain
-
+          }
 
+          // blit the result into the swap chain
           publicAPI.finalPass(viewNode, renNode);
         }
       }
     }
   };
-
-  publicAPI.finalPass = function (viewNode, renNode) {
+  publicAPI.finalPass = (viewNode, renNode) => {
     if (!model._finalBlitEncoder) {
       publicAPI.createFinalBlitEncoder(viewNode);
     }
-
     model._finalBlitOutputTextureView.createFromTextureHandle(viewNode.getCurrentTexture(), {
       depth: 1,
       format: viewNode.getPresentationFormat()
     });
-
     model._finalBlitEncoder.attachTextureViews();
-
     model._finalBlitEncoder.begin(viewNode.getCommandEncoder());
-
     renNode.scissorAndViewport(model._finalBlitEncoder);
-
     model._fullScreenQuad.prepareAndDraw(model._finalBlitEncoder);
-
     model._finalBlitEncoder.end();
   };
-
-  publicAPI.createFinalBlitEncoder = function (viewNode) {
+  publicAPI.createFinalBlitEncoder = viewNode => {
     model._finalBlitEncoder = vtkWebGPURenderEncoder.newInstance({
       label: 'forwardPassBlit'
     });
-
     model._finalBlitEncoder.setDescription({
       colorAttachments: [{
         view: null,
@@ -117,9 +130,7 @@ function vtkForwardPass(publicAPI, model) {
         storeOp: 'store'
       }]
     });
-
     model._finalBlitEncoder.setPipelineHash('fpf');
-
     model._finalBlitEncoder.setPipelineSettings({
       primitive: {
         cullMode: 'none'
@@ -140,73 +151,65 @@ function vtkForwardPass(publicAPI, model) {
         }]
       }
     });
-
     model._fsqSampler = vtkWebGPUSampler.newInstance({
       label: 'finalPassSampler'
     });
-
     model._fsqSampler.create(viewNode.getDevice(), {
       minFilter: 'linear',
       magFilter: 'linear'
     });
-
     model._fullScreenQuad = vtkWebGPUFullScreenQuad.newInstance();
-
     model._fullScreenQuad.setDevice(viewNode.getDevice());
-
     model._fullScreenQuad.setPipelineHash('fpfsq');
-
     model._fullScreenQuad.setTextureViews([model.opaquePass.getColorTextureView()]);
-
     model._fullScreenQuad.setAdditionalBindables([model._fsqSampler]);
-
     model._fullScreenQuad.setFragmentShaderTemplate(finalBlitFragTemplate);
-
     model._finalBlitOutputTextureView = vtkWebGPUTextureView.newInstance();
-
     model._finalBlitEncoder.setColorTextureView(0, model._finalBlitOutputTextureView);
   };
-
-  publicAPI.incrementOpaqueActorCount = function () {
-    return model.opaqueActorCount++;
-  };
-
-  publicAPI.incrementTranslucentActorCount = function () {
-    return model.translucentActorCount++;
-  };
-
-  publicAPI.addVolume = function (volume) {
+  publicAPI.incrementOpaqueActorCount = () => model.opaqueActorCount++;
+  publicAPI.incrementTranslucentActorCount = () => model.translucentActorCount++;
+  publicAPI.addVolume = volume => {
     model.volumes.push(volume);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   opaqueActorCount: 0,
   translucentActorCount: 0,
   volumes: null,
   opaqueRenderEncoder: null,
   translucentPass: null,
   volumePass: 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, ['opaquePass', 'translucentPass', 'volumePass']); // Object methods
+  macro.setGet(publicAPI, model, ['opaquePass', 'translucentPass', 'volumePass']);
 
+  // Object methods
   vtkForwardPass(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkForwardPass'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkForwardPass');
+
+// ----------------------------------------------------------------------------
 
 var vtkForwardPass$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkForwardPass$1 as default, extend, newInstance };

package/Rendering/WebGPU/FullScreenQuad.js

@@ -1,51 +1,58 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUSimpleMapper from './SimpleMapper.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUFullScreenQuad methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUFullScreenQuad(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUFullScreenQuad');
-
-  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');
     vDesc.addOutput('vec4<f32>', 'vertexVC');
-    var code = vDesc.getCode();
+    let code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['output.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);', 'output.Position = vec4<f32>(vertexBC, 1.0);', 'output.vertexVC = vec4<f32>(vertexBC, 1);']).result;
     vDesc.setCode(code);
   };
-
   model.shaderReplacements.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
-
-  publicAPI.updateBuffers = function () {
-    var buff = model.device.getBufferManager().getFullScreenQuadBuffer();
+  publicAPI.updateBuffers = () => {
+    const buff = model.device.getBufferManager().getFullScreenQuadBuffer();
     model.vertexInput.addBuffer(buff, ['vertexBC']);
     model.numberOfVertices = 6;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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);
 
-  vtkWebGPUSimpleMapper.extend(publicAPI, model, initialValues); // Object methods
+  // Inheritance
+  vtkWebGPUSimpleMapper.extend(publicAPI, model, initialValues);
 
+  // Object methods
   vtkWebGPUFullScreenQuad(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUFullScreenQuad'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkWebGPUFullScreenQuad');
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUFullScreenQuad$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUFullScreenQuad$1 as default, extend, newInstance };

package/Rendering/WebGPU/Glyph3DMapper.js

@@ -1,180 +1,162 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { newInstance as newInstance$1, obj } from '../../macros.js';
+import { n as newInstance$1, o as obj } from '../../macros2.js';
 import vtkWebGPUCellArrayMapper from './CellArrayMapper.js';
 import vtkWebGPUPolyDataMapper from './PolyDataMapper.js';
 import vtkWebGPUStorageBuffer from './StorageBuffer.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 function vtkWebGPUGlyph3DCellArrayMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUGlyph3DCellArrayMapper');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.setGlyphInstances = function (val) {
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.setGlyphInstances = val => {
     model.glyphInstances = val;
   };
-
-  publicAPI.updateBuffers = function () {
+  publicAPI.updateBuffers = () => {
     superClass.updateBuffers();
     publicAPI.setNumberOfInstances(model.glyphInstances);
   };
-
-  publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
-    var vDesc = pipeline.getShaderDescription('vertex');
+  publicAPI.replaceShaderPosition = (hash, pipeline, vertexInput) => {
+    const vDesc = pipeline.getShaderDescription('vertex');
     vDesc.addBuiltinInput('u32', '@builtin(instance_index) instanceIndex');
     vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
     if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec3<f32>', 'vertexVC');
-    var code = vDesc.getCode();
+    let code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var vertexSC: vec4<f32> = mapperUBO.BCSCMatrix*glyphSSBO.values[input.instanceIndex].matrix*vertexBC;', '    output.vertexVC = (rendererUBO.SCVCMatrix*vertexSC).xyz;', '    output.Position = rendererUBO.SCPCMatrix*vertexSC;']).result;
     vDesc.setCode(code);
   };
-
   model.shaderReplacements.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
-
-  publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
+  publicAPI.replaceShaderNormal = (hash, pipeline, vertexInput) => {
     if (vertexInput.hasAttribute('normalMC')) {
-      var vDesc = pipeline.getShaderDescription('vertex');
-      var code = vDesc.getCode();
+      const vDesc = pipeline.getShaderDescription('vertex');
+      let code = vDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  output.normalVC = normalize((rendererUBO.WCVCNormals', ' * mapperUBO.MCWCNormals', ' * glyphSSBO.values[input.instanceIndex].normal*normalMC).xyz);']).result;
       vDesc.setCode(code);
     }
-
     superClass.replaceShaderNormal(hash, pipeline, vertexInput);
   };
-
   model.shaderReplacements.set('replaceShaderNormal', publicAPI.replaceShaderNormal);
-
-  publicAPI.replaceShaderColor = function (hash, pipeline, vertexInput) {
+  publicAPI.replaceShaderColor = (hash, pipeline, vertexInput) => {
     if (!model.renderable.getColorArray()) {
       superClass.replaceShaderColor(hash, pipeline, vertexInput);
       return;
     }
-
-    var vDesc = pipeline.getShaderDescription('vertex');
+    const vDesc = pipeline.getShaderDescription('vertex');
     vDesc.addOutput('vec4<f32>', 'color');
-    var code = vDesc.getCode();
+    let code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Color::Impl', ['  output.color = glyphSSBO.values[input.instanceIndex].color;']).result;
     vDesc.setCode(code);
-    var fDesc = pipeline.getShaderDescription('fragment');
+    const fDesc = pipeline.getShaderDescription('fragment');
     code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Color::Impl', ['ambientColor = input.color;', 'diffuseColor = input.color;', 'opacity = mapperUBO.Opacity * input.color.a;']).result;
     fDesc.setCode(code);
   };
-
   model.shaderReplacements.set('replaceShaderColor', publicAPI.replaceShaderColor);
-
-  publicAPI.replaceShaderSelect = function (hash, pipeline, vertexInput) {
+  publicAPI.replaceShaderSelect = (hash, pipeline, vertexInput) => {
     if (hash.includes('sel')) {
-      var vDesc = pipeline.getShaderDescription('vertex');
+      const vDesc = pipeline.getShaderDescription('vertex');
       vDesc.addOutput('u32', 'compositeID', 'flat');
-      var code = vDesc.getCode();
+      let code = vDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::Select::Impl', ['  output.compositeID = input.instanceIndex;']).result;
       vDesc.setCode(code);
-      var fDesc = pipeline.getShaderDescription('fragment');
+      const fDesc = pipeline.getShaderDescription('fragment');
       code = fDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::Select::Impl', ['var compositeID: u32 = input.compositeID;']).result;
       fDesc.setCode(code);
     }
   };
-
   model.shaderReplacements.set('replaceShaderSelect', publicAPI.replaceShaderSelect);
-} // ----------------------------------------------------------------------------
-
+}
 
+// ----------------------------------------------------------------------------
 function caExtend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, {}, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, {}, initialValues);
 
-  vtkWebGPUCellArrayMapper.extend(publicAPI, model, initialValues); // Object methods
+  // Inheritance
+  vtkWebGPUCellArrayMapper.extend(publicAPI, model, initialValues);
 
+  // Object methods
   vtkWebGPUGlyph3DCellArrayMapper(publicAPI, model);
 }
-var caNewInstance = newInstance$1(caExtend, 'vtkWebGPUGlyph3DCellArrayMapper'); // ----------------------------------------------------------------------------
+const caNewInstance = newInstance$1(caExtend, 'vtkWebGPUGlyph3DCellArrayMapper');
+
+// ----------------------------------------------------------------------------
 // vtkWebGPUSphereMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUGlyph3DMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUGlyph3DMapper');
-
-  publicAPI.createCellArrayMapper = function () {
-    var mpr = caNewInstance();
+  publicAPI.createCellArrayMapper = () => {
+    const mpr = caNewInstance();
     mpr.setSSBO(model.SSBO);
     mpr.setRenderable(model.renderable);
     return mpr;
   };
-
-  publicAPI.buildPass = function (prepass) {
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor');
-
       if (!model.renderable.getStatic()) {
         model.renderable.update();
       }
-
-      var gpoly = model.renderable.getInputData(1);
+      const gpoly = model.renderable.getInputData(1);
       model.renderable.mapScalars(gpoly, 1.0);
       publicAPI.updateSSBO();
       publicAPI.updateCellArrayMappers(gpoly);
-
-      for (var i = 0; i < model.children.length; i++) {
-        var cellMapper = model.children[i];
+      for (let i = 0; i < model.children.length; i++) {
+        const cellMapper = model.children[i];
         cellMapper.setGlyphInstances(model.numInstances);
       }
     }
   };
-
-  publicAPI.updateSSBO = function () {
+  publicAPI.updateSSBO = () => {
     model.currentInput = model.renderable.getInputData(1);
-    model.renderable.buildArrays(); // update the buffer objects if needed
+    model.renderable.buildArrays();
 
-    var garray = model.renderable.getMatrixArray();
-    var narray = model.renderable.getNormalArray();
+    // update the buffer objects if needed
+    const garray = model.renderable.getMatrixArray();
+    const narray = model.renderable.getNormalArray();
     model.carray = model.renderable.getColorArray();
     model.numInstances = garray.length / 16;
-
     if (model.renderable.getBuildTime().getMTime() > model.glyphBOBuildTime.getMTime()) {
       // In Core class all arrays are rebuilt when this happens
       // but these arrays can be shared between all primType
       model.WebGPURenderWindow = publicAPI.getFirstAncestorOfType('vtkWebGPURenderWindow');
-      var device = model.WebGPURenderWindow.getDevice();
+      const device = model.WebGPURenderWindow.getDevice();
       model.SSBO.clearData();
       model.SSBO.setNumberOfInstances(model.numInstances);
       model.SSBO.addEntry('matrix', 'mat4x4<f32>');
       model.SSBO.addEntry('normal', 'mat4x4<f32>');
-
       if (model.carray) {
         model.SSBO.addEntry('color', 'vec4<f32>');
       }
-
       model.SSBO.setAllInstancesFromArray('matrix', garray);
       model.SSBO.setAllInstancesFromArray3x3To4x4('normal', narray);
-
       if (model.carray) {
         model.SSBO.setAllInstancesFromArrayColorToFloat('color', model.carray.getData());
       }
-
       model.SSBO.send(device);
       model.glyphBOBuildTime.modified();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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
   vtkWebGPUPolyDataMapper.extend(publicAPI, model, initialValues);
   model.glyphBOBuildTime = {};
   obj(model.glyphBOBuildTime, {
@@ -182,18 +164,24 @@ function extend(publicAPI, model) {
   });
   model.SSBO = vtkWebGPUStorageBuffer.newInstance({
     label: 'glyphSSBO'
-  }); // Object methods
+  });
 
+  // Object methods
   vtkWebGPUGlyph3DMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUGlyph3DMapper'); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPUGlyph3DMapper');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkGlyph3DMapper', newInstance);
 
 export { caExtend, index as default, extend, newInstance };