@kitware/vtk.js 24.5.6 → 24.6.0

package/Common/Core/CellArray.js

@@ -22,7 +22,14 @@ function extractCellSizes(cellArray) {
 }
 
 function getNumberOfCells(cellArray) {
-  return extractCellSizes(cellArray).length;
+  var cellId = 0;
+
+  for (var cellArrayIndex = 0; cellArrayIndex < cellArray.length;) {
+    cellArrayIndex += cellArray[cellArrayIndex] + 1;
+    cellId++;
+  }
+
+  return cellId;
 } // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
@@ -44,8 +51,12 @@ function vtkCellArray(publicAPI, model) {
       return model.numberOfCells;
     }
 
-    model.cellSizes = extractCellSizes(model.values);
-    model.numberOfCells = model.cellSizes.length;
+    if (model.cellSizes) {
+      model.numberOfCells = model.cellSizes.length;
+    } else {
+      model.numberOfCells = getNumberOfCells(model.values);
+    }
+
     return model.numberOfCells;
   };
 

package/Rendering/Core/Mapper.js

@@ -445,7 +445,7 @@ function vtkMapper(publicAPI, model) {
       points: input.getPoints().getNumberOfValues() / 3,
       verts: input.getVerts().getNumberOfValues() - input.getVerts().getNumberOfCells(),
       lines: input.getLines().getNumberOfValues() - 2 * input.getLines().getNumberOfCells(),
-      triangles: input.getPolys().getNumberOfValues() - 3 * input.getLines().getNumberOfCells()
+      triangles: input.getPolys().getNumberOfValues() - 3 * input.getPolys().getNumberOfCells()
     };
     return pcount;
   };

package/Rendering/WebGPU/BindGroup.js

@@ -105,7 +105,7 @@ function extend(publicAPI, model) {
     mtime: 0
   });
   macro.get(publicAPI, model, ['bindGroupTime', 'handle', 'sizeInBytes', 'usage']);
-  macro.setGet(publicAPI, model, ['label', 'device', 'arrayInformation', 'sourceTime']);
+  macro.setGet(publicAPI, model, ['label', 'device', 'arrayInformation']);
   vtkWebGPUBindGroup(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/BufferManager/Constants.js

@@ -12,7 +12,7 @@ var BufferUsage = {
   Texture: 10,
   RawVertex: 11,
   Storage: 12,
-  CellIndex: 13
+  Index: 13
 };
 var PrimitiveTypes = {
   Start: 0,

package/Rendering/WebGPU/BufferManager.js

@@ -1,20 +1,17 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { newInstance as newInstance$1, obj, setGet, vtkErrorMacro as vtkErrorMacro$1, newTypedArray, vtkDebugMacro as vtkDebugMacro$1 } from '../../macros.js';
+import { newInstance as newInstance$1, obj, setGet, vtkErrorMacro as vtkErrorMacro$1, newTypedArray } from '../../macros.js';
 import { j as cross, l as normalize } from '../../Common/Core/Math/index.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkWebGPUBuffer from './Buffer.js';
+import vtkWebGPUIndexBuffer from './IndexBuffer.js';
 import vtkWebGPUTypes from './Types.js';
-import vtkProperty from '../Core/Property.js';
 import Constants from './BufferManager/Constants.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; }
-var BufferUsage = Constants.BufferUsage,
-    PrimitiveTypes = Constants.PrimitiveTypes;
-var Representation = vtkProperty.Representation;
-var vtkDebugMacro = vtkDebugMacro$1,
-    vtkErrorMacro = vtkErrorMacro$1;
+var BufferUsage = Constants.BufferUsage;
+var vtkErrorMacro = vtkErrorMacro$1;
 var VtkDataTypes = vtkDataArray.VtkDataTypes; // the webgpu constants all show up as undefined
 
 /* eslint-disable no-undef */
@@ -23,47 +20,6 @@ var VtkDataTypes = vtkDataArray.VtkDataTypes; // the webgpu constants all show u
 // ----------------------------------------------------------------------------
 
 var STATIC = {};
-var cellCounters = {
-  // easy, every input point becomes an output point
-  anythingToPoints: function anythingToPoints(numPoints, cellPts) {
-    return numPoints;
-  },
-  linesToWireframe: function linesToWireframe(numPoints, cellPts) {
-    if (numPoints > 1) {
-      return (numPoints - 1) * 2;
-    }
-
-    return 0;
-  },
-  polysToWireframe: function polysToWireframe(numPoints, cellPts) {
-    if (numPoints > 2) {
-      return numPoints * 2;
-    }
-
-    return 0;
-  },
-  stripsToWireframe: function stripsToWireframe(numPoints, cellPts) {
-    if (numPoints > 2) {
-      return numPoints * 4 - 6;
-    }
-
-    return 0;
-  },
-  polysToSurface: function polysToSurface(npts, cellPts) {
-    if (npts > 2) {
-      return (npts - 2) * 3;
-    }
-
-    return 0;
-  },
-  stripsToSurface: function stripsToSurface(npts, cellPts, offset) {
-    if (numPoints > 2) {
-      return (npts - 2) * 3;
-    }
-
-    return 0;
-  }
-};
 
 function _getFormatForDataArray(dataArray) {
   var format;
@@ -124,58 +80,11 @@ function _getFormatForDataArray(dataArray) {
   return format;
 }
 
-function getPrimitiveName(primType) {
-  switch (primType) {
-    case PrimitiveTypes.Points:
-      return 'points';
-
-    case PrimitiveTypes.Lines:
-      return 'lines';
-
-    case PrimitiveTypes.Triangles:
-    case PrimitiveTypes.TriangleEdges:
-      return 'polys';
-
-    case PrimitiveTypes.TriangleStripEdges:
-    case PrimitiveTypes.TriangleStrips:
-      return 'strips';
-
-    default:
-      return '';
-  }
-}
-
-function getOutputSize(cellArray, representation, inRepName) {
-  var countFunc = null;
-
-  if (representation === Representation.POINTS || inRepName === 'points') {
-    countFunc = cellCounters.anythingToPoints;
-  } else if (representation === Representation.WIREFRAME || inRepName === 'lines') {
-    countFunc = cellCounters["".concat(inRepName, "ToWireframe")];
-  } else {
-    countFunc = cellCounters["".concat(inRepName, "ToSurface")];
-  }
-
-  var array = cellArray.getData();
-  var size = array.length;
-  var caboCount = 0;
-
-  for (var index = 0; index < size;) {
-    caboCount += countFunc(array[index], array);
-    index += array[index] + 1;
-  }
-
-  return caboCount;
-}
-
-function packArray(cellArray, primType, representation, inArray, outputType, options) {
-  var result = {
-    elementCount: 0,
-    blockSize: 0,
-    stride: 0
-  };
+function packArray(indexBuffer, inArrayData, numComp, outputType, options) {
+  var result = {};
+  var flatSize = indexBuffer.getFlatSize();
 
-  if (!cellArray.getData() || !cellArray.getData().length) {
+  if (!flatSize) {
     return result;
   } // setup shift and scale
 
@@ -201,130 +110,56 @@ function packArray(cellArray, primType, representation, inArray, outputType, opt
   }
 
   var packExtra = Object.prototype.hasOwnProperty.call(options, 'packExtra') ? options.packExtra : false;
-  var pointData = inArray.getData();
   var addAPoint;
-  var cellBuilders = {
-    // easy, every input point becomes an output point
-    anythingToPoints: function anythingToPoints(numPoints, cellPts, offset, cellId) {
-      for (var i = 0; i < numPoints; ++i) {
-        addAPoint(cellPts[offset + i], cellId);
-      }
-    },
-    linesToWireframe: function linesToWireframe(numPoints, cellPts, offset, cellId) {
-      // for lines we add a bunch of segments
-      for (var i = 0; i < numPoints - 1; ++i) {
-        addAPoint(cellPts[offset + i], cellId);
-        addAPoint(cellPts[offset + i + 1], cellId);
-      }
-    },
-    polysToWireframe: function polysToWireframe(numPoints, cellPts, offset, cellId) {
-      // for polys we add a bunch of segments and close it
-      if (numPoints > 2) {
-        for (var i = 0; i < numPoints; ++i) {
-          addAPoint(cellPts[offset + i], cellId);
-          addAPoint(cellPts[offset + (i + 1) % numPoints], cellId);
-        }
-      }
-    },
-    stripsToWireframe: function stripsToWireframe(numPoints, cellPts, offset, cellId) {
-      if (numPoints > 2) {
-        // for strips we add a bunch of segments and close it
-        for (var i = 0; i < numPoints - 1; ++i) {
-          addAPoint(cellPts[offset + i], cellId);
-          addAPoint(cellPts[offset + i + 1], cellId);
-        }
-
-        for (var _i = 0; _i < numPoints - 2; _i++) {
-          addAPoint(cellPts[offset + _i], cellId);
-          addAPoint(cellPts[offset + _i + 2], cellId);
-        }
-      }
-    },
-    polysToSurface: function polysToSurface(npts, cellPts, offset, cellId) {
-      for (var i = 0; i < npts - 2; i++) {
-        addAPoint(cellPts[offset + 0], cellId);
-        addAPoint(cellPts[offset + i + 1], cellId);
-        addAPoint(cellPts[offset + i + 2], cellId);
-      }
-    },
-    stripsToSurface: function stripsToSurface(npts, cellPts, offset, cellId) {
-      for (var i = 0; i < npts - 2; i++) {
-        addAPoint(cellPts[offset + i], cellId);
-        addAPoint(cellPts[offset + i + 1 + i % 2], cellId);
-        addAPoint(cellPts[offset + i + 1 + (i + 1) % 2], cellId);
-      }
-    }
-  };
-  var inRepName = getPrimitiveName(primType);
-  var func = null;
-
-  if (representation === Representation.POINTS || primType === PrimitiveTypes.Points) {
-    func = cellBuilders.anythingToPoints;
-  } else if (representation === Representation.WIREFRAME || primType === PrimitiveTypes.Lines) {
-    func = cellBuilders["".concat(inRepName, "ToWireframe")];
-  } else {
-    func = cellBuilders["".concat(inRepName, "ToSurface")];
-  }
-
-  var array = cellArray.getData();
-  var size = array.length;
-  var caboCount = getOutputSize(cellArray, representation, inRepName);
   var vboidx = 0;
-  var numComp = inArray.getNumberOfComponents();
-  var packedVBO = newTypedArray(outputType, caboCount * (numComp + (packExtra ? 1 : 0))); // pick the right function based on point versus cell data
+  var stride = numComp + (packExtra ? 1 : 0);
+  var packedVBO = newTypedArray(outputType, flatSize * stride); // pick the right function based on point versus cell data
 
-  var getData = function getData(ptId, cellId) {
-    return pointData[ptId];
-  };
+  var flatIdMap = indexBuffer.getFlatIdToPointId();
 
   if (options.cellData) {
-    getData = function getData(ptId, cellId) {
-      return pointData[cellId];
-    };
+    flatIdMap = indexBuffer.getFlatIdToCellId();
   } // add data based on number of components
 
 
   if (numComp === 1) {
-    addAPoint = function addAPointFunc(i, cellid) {
-      packedVBO[vboidx++] = scale[0] * getData(i, cellid) + shift[0];
+    addAPoint = function addAPointFunc(i) {
+      packedVBO[vboidx++] = scale[0] * inArrayData[i] + shift[0];
     };
   } else if (numComp === 2) {
-    addAPoint = function addAPointFunc(i, cellid) {
-      packedVBO[vboidx++] = scale[0] * getData(i * 2, cellid * 2) + shift[0];
-      packedVBO[vboidx++] = scale[1] * getData(i * 2 + 1, cellid * 2 + 1) + shift[1];
+    addAPoint = function addAPointFunc(i) {
+      packedVBO[vboidx++] = scale[0] * inArrayData[i] + shift[0];
+      packedVBO[vboidx++] = scale[1] * inArrayData[i + 1] + shift[1];
     };
   } else if (numComp === 3 && !packExtra) {
-    addAPoint = function addAPointFunc(i, cellid) {
-      packedVBO[vboidx++] = scale[0] * getData(i * 3, cellid * 3) + shift[0];
-      packedVBO[vboidx++] = scale[1] * getData(i * 3 + 1, cellid * 3 + 1) + shift[1];
-      packedVBO[vboidx++] = scale[2] * getData(i * 3 + 2, cellid * 3 + 2) + shift[2];
+    addAPoint = function addAPointFunc(i) {
+      packedVBO[vboidx++] = scale[0] * inArrayData[i] + shift[0];
+      packedVBO[vboidx++] = scale[1] * inArrayData[i + 1] + shift[1];
+      packedVBO[vboidx++] = scale[2] * inArrayData[i + 2] + shift[2];
     };
   } else if (numComp === 3 && packExtra) {
-    addAPoint = function addAPointFunc(i, cellid) {
-      packedVBO[vboidx++] = scale[0] * getData(i * 3, cellid * 3) + shift[0];
-      packedVBO[vboidx++] = scale[1] * getData(i * 3 + 1, cellid * 3 + 1) + shift[1];
-      packedVBO[vboidx++] = scale[2] * getData(i * 3 + 2, cellid * 3 + 2) + shift[2];
+    addAPoint = function addAPointFunc(i) {
+      packedVBO[vboidx++] = scale[0] * inArrayData[i] + shift[0];
+      packedVBO[vboidx++] = scale[1] * inArrayData[i + 1] + shift[1];
+      packedVBO[vboidx++] = scale[2] * inArrayData[i + 2] + shift[2];
       packedVBO[vboidx++] = scale[3] * 1.0 + shift[3];
     };
   } else if (numComp === 4) {
-    addAPoint = function addAPointFunc(i, cellid) {
-      packedVBO[vboidx++] = scale[0] * getData(i * 4, cellid * 4) + shift[0];
-      packedVBO[vboidx++] = scale[1] * getData(i * 4 + 1, cellid * 4 + 1) + shift[1];
-      packedVBO[vboidx++] = scale[2] * getData(i * 4 + 2, cellid * 4 + 2) + shift[2];
-      packedVBO[vboidx++] = scale[3] * getData(i * 4 + 3, cellid * 4 + 3) + shift[3];
+    addAPoint = function addAPointFunc(i) {
+      packedVBO[vboidx++] = scale[0] * inArrayData[i] + shift[0];
+      packedVBO[vboidx++] = scale[1] * inArrayData[i + 1] + shift[1];
+      packedVBO[vboidx++] = scale[2] * inArrayData[i + 2] + shift[2];
+      packedVBO[vboidx++] = scale[3] * inArrayData[i + 3] + shift[3];
     };
-  }
+  } // for each entry in the flat array process it
 
-  var cellId = options.cellOffset;
 
-  for (var index = 0; index < size;) {
-    func(array[index], array, index + 1, cellId);
-    index += array[index] + 1;
-    cellId++;
+  for (var index = 0; index < flatSize; index++) {
+    var inArrayId = numComp * flatIdMap[index];
+    addAPoint(inArrayId);
   }
 
   result.nativeArray = packedVBO;
-  result.elementCount = caboCount;
   return result;
 }
 
@@ -337,75 +172,26 @@ function getNormal(pointData, i0, i1, i2) {
   return result;
 }
 
-function generateNormals(cellArray, primType, representation, inArray) {
-  if (!cellArray.getData() || !cellArray.getData().length) {
-    return null;
-  }
+function generateNormals(cellArray, pointArray) {
+  var pointData = pointArray.getData();
+  var cellArrayData = cellArray.getData();
 
-  var pointData = inArray.getData();
-  var addAPoint;
-  var cellBuilders = {
-    polysToPoints: function polysToPoints(numPoints, cellPts, offset) {
-      var normal = getNormal(pointData, cellPts[offset], cellPts[offset + 1], cellPts[offset + 2]);
+  if (!cellArrayData || !pointData) {
+    return null;
+  } // return a cellArray of normals
 
-      for (var i = 0; i < numPoints; ++i) {
-        addAPoint(normal);
-      }
-    },
-    polysToWireframe: function polysToWireframe(numPoints, cellPts, offset) {
-      // for polys we add a bunch of segments and close it
-      // compute the normal
-      var normal = getNormal(pointData, cellPts[offset], cellPts[offset + 1], cellPts[offset + 2]);
-
-      for (var i = 0; i < numPoints; ++i) {
-        addAPoint(normal);
-        addAPoint(normal);
-      }
-    },
-    polysToSurface: function polysToSurface(npts, cellPts, offset) {
-      if (npts < 3) {
-        // ignore degenerate triangles
-        vtkDebugMacro('skipping degenerate triangle');
-      } else {
-        // compute the normal
-        var normal = getNormal(pointData, cellPts[offset], cellPts[offset + 1], cellPts[offset + 2]);
-
-        for (var i = 0; i < npts - 2; i++) {
-          addAPoint(normal);
-          addAPoint(normal);
-          addAPoint(normal);
-        }
-      }
-    }
-  };
-  var primName = getPrimitiveName(primType);
-  var func = null;
-
-  if (representation === Representation.POINTS) {
-    func = cellBuilders["".concat(primName, "ToPoints")];
-  } else if (representation === Representation.WIREFRAME) {
-    func = cellBuilders["".concat(primName, "ToWireframe")];
-  } else {
-    func = cellBuilders["".concat(primName, "ToSurface")];
-  }
 
-  var caboCount = getOutputSize(cellArray, representation, primName);
+  var packedVBO = new Int8Array(cellArray.getNumberOfCells() * 4);
+  var size = cellArrayData.length;
   var vboidx = 0;
-  var packedVBO = new Int8Array(caboCount * 4);
 
-  addAPoint = function addAPointFunc(normal) {
+  for (var index = 0; index < size;) {
+    var normal = getNormal(pointData, cellArrayData[index + 1], cellArrayData[index + 2], cellArrayData[index + 3]);
     packedVBO[vboidx++] = 127 * normal[0];
     packedVBO[vboidx++] = 127 * normal[1];
     packedVBO[vboidx++] = 127 * normal[2];
     packedVBO[vboidx++] = 127;
-  };
-
-  var array = cellArray.getData();
-  var size = array.length;
-
-  for (var index = 0; index < size;) {
-    func(array[index], array, index + 1);
-    index += array[index] + 1;
+    index += cellArrayData[index] + 1;
   }
 
   return packedVBO;
@@ -422,14 +208,37 @@ function vtkWebGPUBufferManager(publicAPI, model) {
     // if a dataArray is provided set the nativeArray
     if (req.dataArray && !req.nativeArray) {
       req.nativeArray = req.dataArray.getData();
-    } // create one
+    }
 
+    var buffer;
+    var gpuUsage; // handle index buffers
+
+    if (req.usage === BufferUsage.Index) {
+      // todo change to FlattenedIndex to be more clear
+      buffer = vtkWebGPUIndexBuffer.newInstance({
+        label: req.label
+      });
+      buffer.setDevice(model.device);
+      /* eslint-disable no-bitwise */
+
+      gpuUsage = GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST;
+      /* eslint-enable no-bitwise */
+
+      buffer.buildIndexBuffer(req);
+      buffer.createAndWrite(req.nativeArray, gpuUsage);
+      buffer.setArrayInformation([{
+        format: req.format
+      }]);
+    } // create one if not done already
+
+
+    if (!buffer) {
+      buffer = vtkWebGPUBuffer.newInstance({
+        label: req.label
+      });
+      buffer.setDevice(model.device);
+    } // handle uniform buffers
 
-    var buffer = vtkWebGPUBuffer.newInstance({
-      label: req.label
-    });
-    buffer.setDevice(model.device);
-    var gpuUsage = null; // handle uniform buffers
 
     if (req.usage === BufferUsage.UniformArray) {
       /* eslint-disable no-bitwise */
@@ -463,7 +272,7 @@ function vtkWebGPUBufferManager(publicAPI, model) {
     if (req.usage === BufferUsage.PointArray) {
       gpuUsage = GPUBufferUsage.VERTEX;
       var arrayType = vtkWebGPUTypes.getNativeTypeFromBufferFormat(req.format);
-      var result = packArray(req.cells, req.primitiveType, req.representation, req.dataArray, arrayType, {
+      var result = packArray(req.indexBuffer, req.dataArray.getData(), req.dataArray.getNumberOfComponents(), arrayType, {
         packExtra: req.packExtra,
         shift: req.shift,
         scale: req.scale,
@@ -474,19 +283,29 @@ function vtkWebGPUBufferManager(publicAPI, model) {
       buffer.setStrideInBytes(vtkWebGPUTypes.getByteStrideFromBufferFormat(req.format));
       buffer.setArrayInformation([{
         offset: 0,
-        format: req.format
+        format: req.format,
+        interpolation: req.cellData ? 'flat' : 'perspective'
       }]);
     } // handle normals from points, snorm8x4
 
 
     if (req.usage === BufferUsage.NormalsFromPoints) {
       gpuUsage = GPUBufferUsage.VERTEX;
-      var normals = generateNormals(req.cells, req.primitiveType, req.representation, req.dataArray);
-      buffer.createAndWrite(normals, gpuUsage);
+
+      var _arrayType = vtkWebGPUTypes.getNativeTypeFromBufferFormat(req.format);
+
+      var normals = generateNormals(req.cells, req.dataArray);
+
+      var _result = packArray(req.indexBuffer, normals, 4, _arrayType, {
+        cellData: true
+      });
+
+      buffer.createAndWrite(_result.nativeArray, gpuUsage);
       buffer.setStrideInBytes(vtkWebGPUTypes.getByteStrideFromBufferFormat(req.format));
       buffer.setArrayInformation([{
         offset: 0,
-        format: req.format
+        format: req.format,
+        interpolation: 'flat'
       }]);
     }
 
@@ -518,17 +337,15 @@ function vtkWebGPUBufferManager(publicAPI, model) {
     return _createBuffer(req);
   };
 
-  publicAPI.getBufferForPointArray = function (dataArray, cells, primitiveType, representation) {
+  publicAPI.getBufferForPointArray = function (dataArray, indexBuffer) {
     var format = _getFormatForDataArray(dataArray);
 
     var buffRequest = {
-      hash: "PA".concat(representation, "P").concat(primitiveType, "D").concat(dataArray.getMTime(), "C").concat(cells.getMTime()).concat(format),
+      hash: "".concat(dataArray.getMTime(), "I").concat(indexBuffer.getMTime()).concat(format),
       usage: BufferUsage.PointArray,
       format: format,
       dataArray: dataArray,
-      cells: cells,
-      primitiveType: primitiveType,
-      representation: representation
+      indexBuffer: indexBuffer
     };
     return publicAPI.getBuffer(buffRequest);
   };

package/Rendering/WebGPU/CellArrayMapper.js

@@ -121,9 +121,11 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   model.shaderReplacements.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
 
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
-    if (vertexInput.hasAttribute('normalMC')) {
+    var normalBuffer = vertexInput.getBuffer('normalMC');
+
+    if (normalBuffer) {
       var vDesc = pipeline.getShaderDescription('vertex');
-      vDesc.addOutput('vec3<f32>', 'normalVC');
+      vDesc.addOutput('vec3<f32>', 'normalVC', normalBuffer.getArrayInformation()[0].interpolation);
       var code = vDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  output.normalVC = normalize((rendererUBO.WCVCNormals * mapperUBO.MCWCNormals * normalMC).xyz);']).result;
       vDesc.setCode(code);
@@ -165,9 +167,10 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       return;
     }
 
-    if (!vertexInput.hasAttribute('colorVI')) return;
+    var colorBuffer = vertexInput.getBuffer('colorVI');
+    if (!colorBuffer) return;
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addOutput('vec4<f32>', 'color');
+    vDesc.addOutput('vec4<f32>', 'color', colorBuffer.getArrayInformation()[0].interpolation);
     var code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Color::Impl', ['  output.color = colorVI;']).result;
     vDesc.setCode(code);
@@ -276,35 +279,46 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     }
 
     var vertexInput = model.vertexInput;
-    var hash = "R".concat(representation, "P").concat(primType); // hash = all things that can change the values on the buffer
+    var points = pd.getPoints();
+    var indexBuffer; // get the flat mapping indexBuffer for the cells
+
+    if (cells) {
+      var buffRequest = {
+        hash: "R".concat(representation, "P").concat(primType).concat(cells.getMTime()),
+        usage: BufferUsage.Index,
+        cells: cells,
+        numberOfPoints: points.getNumberOfPoints(),
+        primitiveType: primType,
+        representation: representation
+      };
+      indexBuffer = device.getBufferManager().getBuffer(buffRequest);
+      vertexInput.setIndexBuffer(indexBuffer);
+    } else {
+      vertexInput.setIndexBuffer(null);
+    } // hash = all things that can change the values on the buffer
     // since mtimes are unique we can use
-    // - cells mtime - because cells drive how we pack
-    // - rep (point/wireframe/surface) - again because of packing
+    // - indexBuffer mtime - because cells drive how we pack
     // - relevant dataArray mtime - the source data
     // - shift - not currently captured
     // - scale - not currently captured
     // - format
     // - usage
     // - packExtra - covered by format
-    // - prim type (vert/lines/polys/strips) - covered by cells mtime
     // points
 
-    var points = pd.getPoints();
 
     if (points) {
       var shift = model.WebGPUActor.getBufferShift(model.WebGPURenderer);
-      var buffRequest = {
-        hash: "".concat(hash).concat(points.getMTime()).concat(cells.getMTime()).concat(shift.join(), "float32x4"),
+      var _buffRequest = {
+        hash: "".concat(points.getMTime(), "I").concat(indexBuffer.getMTime()).concat(shift.join(), "float32x4"),
         usage: BufferUsage.PointArray,
         format: 'float32x4',
         dataArray: points,
-        cells: cells,
-        primitiveType: primType,
-        representation: representation,
+        indexBuffer: indexBuffer,
         shift: shift,
         packExtra: true
       };
-      var buff = device.getBufferManager().getBuffer(buffRequest);
+      var buff = device.getBufferManager().getBuffer(_buffRequest);
       vertexInput.addBuffer(buff, ['vertexBC']);
     } else {
       vertexInput.removeBufferIfPresent('vertexBC');
@@ -315,30 +329,29 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
     if (usage === BufferUsage.Triangles || usage === BufferUsage.Strips) {
       var normals = pd.getPointData().getNormals();
-      var _buffRequest = {
+      var _buffRequest2 = {
         format: 'snorm8x4',
-        cells: cells,
-        representation: representation,
-        primitiveType: primType,
+        indexBuffer: indexBuffer,
         packExtra: true,
         shift: 0,
         scale: 127
       };
 
       if (normals) {
-        _buffRequest.hash = "".concat(hash).concat(normals.getMTime()).concat(cells.getMTime(), "snorm8x4");
-        _buffRequest.dataArray = normals;
-        _buffRequest.usage = BufferUsage.PointArray;
+        _buffRequest2.hash = "".concat(normals.getMTime(), "I").concat(indexBuffer.getMTime(), "snorm8x4");
+        _buffRequest2.dataArray = normals;
+        _buffRequest2.usage = BufferUsage.PointArray;
 
-        var _buff = device.getBufferManager().getBuffer(_buffRequest);
+        var _buff = device.getBufferManager().getBuffer(_buffRequest2);
 
         vertexInput.addBuffer(_buff, ['normalMC']);
       } else if (primType === PrimitiveTypes.Triangles) {
-        _buffRequest.hash = "".concat(hash).concat(points.getMTime()).concat(cells.getMTime(), "snorm8x4");
-        _buffRequest.dataArray = points;
-        _buffRequest.usage = BufferUsage.NormalsFromPoints;
+        _buffRequest2.hash = "PFN".concat(points.getMTime(), "I").concat(indexBuffer.getMTime(), "snorm8x4");
+        _buffRequest2.dataArray = points;
+        _buffRequest2.cells = cells;
+        _buffRequest2.usage = BufferUsage.NormalsFromPoints;
 
-        var _buff2 = device.getBufferManager().getBuffer(_buffRequest);
+        var _buff2 = device.getBufferManager().getBuffer(_buffRequest2);
 
         vertexInput.addBuffer(_buff2, ['normalMC']);
       } else {
@@ -362,19 +375,17 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
           haveCellScalars = true;
         }
 
-        var _buffRequest2 = {
+        var _buffRequest3 = {
           usage: BufferUsage.PointArray,
           format: 'unorm8x4',
-          hash: "".concat(hash).concat(haveCellScalars).concat(c.getMTime()).concat(cells.getMTime(), "unorm8x4"),
+          hash: "".concat(haveCellScalars).concat(c.getMTime(), "I").concat(indexBuffer.getMTime(), "unorm8x4"),
           dataArray: c,
-          cells: cells,
-          primitiveType: primType,
-          representation: representation,
+          indexBuffer: indexBuffer,
           cellData: haveCellScalars,
           cellOffset: 0
         };
 
-        var _buff3 = device.getBufferManager().getBuffer(_buffRequest2);
+        var _buff3 = device.getBufferManager().getBuffer(_buffRequest3);
 
         vertexInput.addBuffer(_buff3, ['colorVI']);
         haveColors = true;
@@ -394,7 +405,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     }
 
     if (tcoords && !edges) {
-      var _buff4 = device.getBufferManager().getBufferForPointArray(tcoords, cells, primType, representation);
+      var _buff4 = device.getBufferManager().getBufferForPointArray(tcoords, vertexInput.getIndexBuffer());
 
       vertexInput.addBuffer(_buff4, ['tcoord']);
     } else {

package/Rendering/WebGPU/IndexBuffer.js

@@ -0,0 +1,397 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import macro from '../../macros.js';
+import Constants from './BufferManager/Constants.js';
+import vtkProperty from '../Core/Property.js';
+import vtkWebGPUBuffer from './Buffer.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; }
+var Representation = vtkProperty.Representation;
+var PrimitiveTypes = Constants.PrimitiveTypes; // Simulate a small map of pointId to flatId for a cell. The original code
+// used a map and was 2.6x slower (4.7 to 1.9 seconds). Using two fixed
+// length arrays with a count is so much faster even with the required for
+// loops and if statements. This only works as we know the usage is
+// restricted to clear(), set() get() and has() so the count is always
+// incrmenting except for clear where it goes back to 0. Performance
+// improvement is probably due to this appoach not hitting the heap but wow
+// it is so much faster. Code that adds to these vectors checks against 9 to
+// make sure there is room. Switching to test against vec.length -1 results
+// in a small performance hit, so if you change 10, search for 9 in this
+// small class and change those as well.
+
+var _LimitedMap = /*#__PURE__*/function () {
+  function _LimitedMap() {
+    _classCallCheck(this, _LimitedMap);
+
+    this.keys = new Uint32Array(10);
+    this.values = new Uint32Array(10);
+    this.count = 0;
+  }
+
+  _createClass(_LimitedMap, [{
+    key: "clear",
+    value: function clear() {
+      this.count = 0;
+    }
+  }, {
+    key: "has",
+    value: function has(key) {
+      for (var i = 0; i < this.count; i++) {
+        if (this.keys[i] === key) {
+          return true;
+        }
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      for (var i = 0; i < this.count; i++) {
+        if (this.keys[i] === key) {
+          return this.values[i];
+        }
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      if (this.count < 9) {
+        this.keys[this.count] = key;
+        this.values[this.count++] = value;
+      }
+    }
+  }]);
+
+  return _LimitedMap;
+}();
+
+function getPrimitiveName(primType) {
+  switch (primType) {
+    case PrimitiveTypes.Points:
+      return 'points';
+
+    case PrimitiveTypes.Lines:
+      return 'lines';
+
+    case PrimitiveTypes.Triangles:
+    case PrimitiveTypes.TriangleEdges:
+      return 'polys';
+
+    case PrimitiveTypes.TriangleStripEdges:
+    case PrimitiveTypes.TriangleStrips:
+      return 'strips';
+
+    default:
+      return '';
+  }
+}
+
+function _getOrAddFlatId(state, ptId, cellId) {
+  var flatId = state.pointIdToFlatId[ptId];
+
+  if (flatId < 0) {
+    flatId = state.flatId;
+    state.pointIdToFlatId[ptId] = flatId;
+    state.flatIdToPointId[state.flatId] = ptId;
+    state.flatIdToCellId[state.flatId] = cellId;
+    state.flatId++;
+  }
+
+  return flatId;
+}
+
+function fillCell(ptIds, cellId, state) {
+  var numPtIds = ptIds.length; // are any points already marked for this cell? If so use that as the provoking point
+
+  for (var ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    var _ptId = ptIds[ptIdx];
+
+    if (state.cellProvokedMap.has(_ptId)) {
+      state.ibo[state.iboId++] = state.cellProvokedMap.get(_ptId); // insert remaining ptIds (they do not need to provoke)
+
+      for (var ptIdx2 = ptIdx + 1; ptIdx2 < ptIdx + numPtIds; ptIdx2++) {
+        _ptId = ptIds[ptIdx2 % numPtIds];
+
+        var _flatId = _getOrAddFlatId(state, _ptId, cellId); // add to ibo
+
+
+        state.ibo[state.iboId++] = _flatId;
+      } // all done now
+
+
+      return;
+    }
+  } // else have any of the points not been used yet? (not in provokedPointIds)
+
+
+  for (var _ptIdx = 0; _ptIdx < numPtIds; _ptIdx++) {
+    var _ptId2 = ptIds[_ptIdx];
+
+    if (!state.provokedPointIds[_ptId2]) {
+      var _flatId2 = _getOrAddFlatId(state, _ptId2, cellId); // mark provoking and add to ibo
+
+
+      state.provokedPointIds[_ptId2] = 1;
+      state.cellProvokedMap.set(_ptId2, _flatId2); // when provoking always set the cellId as an original non-provoking value
+      // will have been stored and we need to overwrite that
+
+      state.flatIdToCellId[_flatId2] = cellId;
+      state.ibo[state.iboId++] = _flatId2; // insert remaining ptIds (they do not need to provoke)
+
+      for (var _ptIdx2 = _ptIdx + 1; _ptIdx2 < _ptIdx + numPtIds; _ptIdx2++) {
+        _ptId2 = ptIds[_ptIdx2 % numPtIds];
+        _flatId2 = _getOrAddFlatId(state, _ptId2, cellId); // add to ibo
+
+        state.ibo[state.iboId++] = _flatId2;
+      } // all done now
+
+
+      return;
+    }
+  } // if we got here then none of the ptIds could be used to provoke
+  // so just duplicate the first one
+
+
+  var ptId = ptIds[0];
+  var flatId = state.flatId;
+  state.cellProvokedMap.set(ptId, flatId);
+  state.flatIdToPointId[state.flatId] = ptId;
+  state.flatIdToCellId[state.flatId] = cellId;
+  state.flatId++; // add to ibo
+
+  state.ibo[state.iboId++] = flatId; // insert remaining ptIds (they do not need to provoke)
+
+  for (var _ptIdx3 = 1; _ptIdx3 < numPtIds; _ptIdx3++) {
+    ptId = ptIds[_ptIdx3];
+    flatId = _getOrAddFlatId(state, ptId, cellId); // add to ibo
+
+    state.ibo[state.iboId++] = flatId;
+  }
+}
+
+function countCell(ptIds, cellId, state) {
+  var numPtIds = ptIds.length;
+  state.iboSize += numPtIds; // are any points already marked for this cell? If so use that as the provoking point
+
+  for (var ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    var ptId = ptIds[ptIdx];
+
+    if (state.cellProvokedMap.has(ptId)) {
+      return;
+    }
+  } // else have any of the points not been used yet? (not in provokedPointIds)
+
+
+  for (var _ptIdx4 = 0; _ptIdx4 < numPtIds; _ptIdx4++) {
+    var _ptId3 = ptIds[_ptIdx4];
+
+    if (!state.provokedPointIds[_ptId3]) {
+      state.provokedPointIds[_ptId3] = 1;
+      state.cellProvokedMap.set(_ptId3, 1);
+      return;
+    }
+  } // if we got here then none of the ptIds could be used to provoke
+
+
+  state.cellProvokedMap.set(ptIds[0], 1);
+  state.extraPoints++;
+}
+
+var processCell;
+
+var _single = new Uint32Array(1);
+
+var _double = new Uint32Array(2);
+
+var _triple = new Uint32Array(3);
+
+var _indexCellBuilders = {
+  // easy, every input point becomes an output point
+  anythingToPoints: function anythingToPoints(numPoints, cellPts, offset, cellId, state) {
+    for (var i = 0; i < numPoints; ++i) {
+      _single[0] = cellPts[offset + i];
+      processCell(_single, cellId, state);
+    }
+  },
+  linesToWireframe: function linesToWireframe(numPoints, cellPts, offset, cellId, state) {
+    // for lines we add a bunch of segments
+    for (var i = 0; i < numPoints - 1; ++i) {
+      _double[0] = cellPts[offset + i];
+      _double[1] = cellPts[offset + i + 1];
+      processCell(_double, cellId, state);
+    }
+  },
+  polysToWireframe: function polysToWireframe(numPoints, cellPts, offset, cellId, state) {
+    // for polys we add a bunch of segments and close it
+    if (numPoints > 2) {
+      for (var i = 0; i < numPoints; ++i) {
+        _double[0] = cellPts[offset + i];
+        _double[1] = cellPts[offset + (i + 1) % numPoints];
+        processCell(_double, cellId, state);
+      }
+    }
+  },
+  stripsToWireframe: function stripsToWireframe(numPoints, cellPts, offset, cellId, state) {
+    if (numPoints > 2) {
+      // for strips we add a bunch of segments and close it
+      for (var i = 0; i < numPoints - 1; ++i) {
+        _double[0] = cellPts[offset + i];
+        _double[1] = cellPts[offset + i + 1];
+        processCell(_double, cellId, state);
+      }
+
+      for (var _i = 0; _i < numPoints - 2; _i++) {
+        _double[0] = cellPts[offset + _i];
+        _double[1] = cellPts[offset + _i + 2];
+        processCell(_double, cellId, state);
+      }
+    }
+  },
+  polysToSurface: function polysToSurface(npts, cellPts, offset, cellId, state) {
+    for (var i = 0; i < npts - 2; i++) {
+      _triple[0] = cellPts[offset];
+      _triple[1] = cellPts[offset + i + 1];
+      _triple[2] = cellPts[offset + i + 2];
+      processCell(_triple, cellId, state);
+    }
+  },
+  stripsToSurface: function stripsToSurface(npts, cellPts, offset, cellId, state) {
+    for (var i = 0; i < npts - 2; i++) {
+      _triple[0] = cellPts[offset + i];
+      _triple[1] = cellPts[offset + i + 1 + i % 2];
+      _triple[2] = cellPts[offset + i + 1 + (i + 1) % 2];
+      processCell(_triple, cellId, state);
+    }
+  }
+}; // ----------------------------------------------------------------------------
+// vtkWebGPUIndexBufferManager methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUIndexBuffer(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkWebGPUIndexBuffer');
+
+  publicAPI.buildIndexBuffer = function (req) {
+    var cellArray = req.cells;
+    var primitiveType = req.primitiveType;
+    var representation = req.representation;
+    var cellOffset = req.cellOffset;
+    var array = cellArray.getData();
+    var cellArraySize = array.length;
+    var inRepName = getPrimitiveName(primitiveType);
+    var numPts = req.numberOfPoints;
+    var state = {
+      provokedPointIds: new Uint8Array(numPts),
+      // size is good
+      extraPoints: 0,
+      iboSize: 0,
+      flatId: 0,
+      iboId: 0,
+      cellProvokedMap: new _LimitedMap()
+    };
+    var func = null;
+
+    if (representation === Representation.POINTS || primitiveType === PrimitiveTypes.Points) {
+      func = _indexCellBuilders.anythingToPoints;
+    } else if (representation === Representation.WIREFRAME || primitiveType === PrimitiveTypes.Lines) {
+      func = _indexCellBuilders["".concat(inRepName, "ToWireframe")];
+    } else {
+      func = _indexCellBuilders["".concat(inRepName, "ToSurface")];
+    } // first we count how many extra provoking points we need
+
+
+    processCell = countCell;
+    var cellId = cellOffset || 0;
+
+    for (var cellArrayIndex = 0; cellArrayIndex < cellArraySize;) {
+      state.cellProvokedMap.clear();
+      func(array[cellArrayIndex], array, cellArrayIndex + 1, cellId, state);
+      cellArrayIndex += array[cellArrayIndex] + 1;
+      cellId++;
+    } // then we allocate the remaining structures
+    // (we pick the best size to save space and transfer costs)
+
+
+    if (numPts <= 0xffff) {
+      state.flatIdToPointId = new Uint16Array(numPts + state.extraPoints);
+    } else {
+      state.flatIdToPointId = new Uint32Array(numPts + state.extraPoints);
+    }
+
+    if (numPts + state.extraPoints < 0x8fff) {
+      state.pointIdToFlatId = new Int16Array(numPts);
+    } else {
+      state.pointIdToFlatId = new Int32Array(numPts);
+    }
+
+    if (numPts + state.extraPoints <= 0xffff) {
+      state.ibo = new Uint16Array(state.iboSize);
+      req.format = 'uint16';
+    } else {
+      state.ibo = new Uint32Array(state.iboSize);
+      req.format = 'uint32';
+    }
+
+    if (cellId <= 0xffff) {
+      state.flatIdToCellId = new Uint16Array(numPts + state.extraPoints);
+    } else {
+      state.flatIdToCellId = new Uint32Array(numPts + state.extraPoints);
+    }
+
+    state.pointIdToFlatId.fill(-1);
+    state.provokedPointIds.fill(0); // and fill them in
+
+    processCell = fillCell;
+    cellId = cellOffset || 0;
+
+    for (var _cellArrayIndex = 0; _cellArrayIndex < cellArraySize;) {
+      state.cellProvokedMap.clear();
+      func(array[_cellArrayIndex], array, _cellArrayIndex + 1, cellId, state);
+      _cellArrayIndex += array[_cellArrayIndex] + 1;
+      cellId++;
+    }
+
+    delete state.provokedPointIds;
+    delete state.pointIdToFlatId; // store the results we need
+
+    req.nativeArray = state.ibo;
+    model.flatIdToPointId = state.flatIdToPointId;
+    model.flatIdToCellId = state.flatIdToCellId;
+    model.flatSize = state.flatId;
+    model.indexCount = state.iboId;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  flatIdToPointId: null,
+  flatIdToCellId: null,
+  flatSize: 0,
+  indexCount: 0
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+
+  vtkWebGPUBuffer.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['flatIdToPointId', 'flatIdToCellId', 'flatSize', 'indexCount']);
+  vtkWebGPUIndexBuffer(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+
+var vtkWebGPUIndexBuffer$1 = _objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, Constants);
+
+export { vtkWebGPUIndexBuffer$1 as default, extend, newInstance };

package/Rendering/WebGPU/RenderEncoder.js

@@ -1,7 +1,7 @@
 import { newInstance as newInstance$1, obj, get, setGet } from '../../macros.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 
-var forwarded = ['setBindGroup', 'setVertexBuffer', 'draw']; // ----------------------------------------------------------------------------
+var forwarded = ['setBindGroup', 'setIndexBuffer', 'setVertexBuffer', 'draw', 'drawIndexed']; // ----------------------------------------------------------------------------
 // vtkWebGPURenderEncoder methods
 // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/SimpleMapper.js

@@ -179,7 +179,13 @@ function vtkWebGPUSimpleMapper(publicAPI, model) {
     renderEncoder.activateBindGroup(model.bindGroup); // bind the vertex input
 
     pipeline.bindVertexInput(renderEncoder, model.vertexInput);
-    renderEncoder.draw(model.numberOfVertices, model.numberOfInstances, 0, 0);
+    var indexBuffer = model.vertexInput.getIndexBuffer();
+
+    if (indexBuffer) {
+      renderEncoder.drawIndexed(indexBuffer.getIndexCount(), model.numberOfInstances, 0, 0, 0);
+    } else {
+      renderEncoder.draw(model.numberOfVertices, model.numberOfInstances, 0, 0);
+    }
   };
 
   publicAPI.getBindables = function () {

package/Rendering/WebGPU/VertexInput.js

@@ -158,6 +158,10 @@ function vtkWebGPUVertexInput(publicAPI, model) {
     for (var i = 0; i < model.inputs.length; i++) {
       renderEncoder.setVertexBuffer(i, model.inputs[i].buffer.getHandle());
     }
+
+    if (model.indexBuffer) {
+      renderEncoder.setIndexBuffer(model.indexBuffer.getHandle(), model.indexBuffer.getArrayInformation()[0].format);
+    }
   };
 
   publicAPI.getReady = function () {};
@@ -177,7 +181,8 @@ function vtkWebGPUVertexInput(publicAPI, model) {
 var DEFAULT_VALUES = {
   inputs: null,
   bindingDescriptions: false,
-  attributeDescriptions: null
+  attributeDescriptions: null,
+  indexBuffer: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -188,7 +193,7 @@ function extend(publicAPI, model) {
   model.bindingDescriptions = [];
   model.attributeDescriptions = [];
   model.inputs = [];
-  setGet(publicAPI, model, ['created', 'device', 'handle']); // For more macro methods, see "Sources/macros.js"
+  setGet(publicAPI, model, ['created', 'device', 'handle', 'indexBuffer']); // For more macro methods, see "Sources/macros.js"
   // Object specific methods
 
   vtkWebGPUVertexInput(publicAPI, model);

package/Rendering/WebGPU/VolumePass.js

@@ -256,17 +256,27 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   publicAPI.renderDepthBounds = function (renNode, viewNode) {
     publicAPI.updateDepthPolyData(renNode);
     var pd = model._boundsPoly;
-    var cells = pd.getPolys(); // points
-
     var points = pd.getPoints();
+    var cells = pd.getPolys();
     var buffRequest = {
+      hash: "vp".concat(cells.getMTime()),
+      usage: BufferUsage.Index,
+      cells: cells,
+      numberOfPoints: points.getNumberOfPoints(),
+      primitiveType: PrimitiveTypes.Triangles,
+      representation: Representation.SURFACE
+    };
+    var indexBuffer = viewNode.getDevice().getBufferManager().getBuffer(buffRequest);
+
+    model._mapper.getVertexInput().setIndexBuffer(indexBuffer); // points
+
+
+    buffRequest = {
       usage: BufferUsage.PointArray,
       format: 'float32x4',
       hash: "vp".concat(points.getMTime()).concat(cells.getMTime()),
       dataArray: points,
-      cells: cells,
-      primitiveType: PrimitiveTypes.Triangles,
-      representation: Representation.SURFACE,
+      indexBuffer: indexBuffer,
       packExtra: true
     };
     var buff = viewNode.getDevice().getBufferManager().getBuffer(buffRequest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "24.5.6",
+  "version": "24.6.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",