@kitware/vtk.js 24.5.4 → 24.6.0

package/Rendering/WebGPU/BufferManager.js

@@ -1,18 +1,18 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { newInstance as newInstance$1, obj, setGet, 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; // the webgpu constants all show up as undefined
+var BufferUsage = Constants.BufferUsage;
+var vtkErrorMacro = vtkErrorMacro$1;
+var VtkDataTypes = vtkDataArray.VtkDataTypes; // the webgpu constants all show up as undefined
 
 /* eslint-disable no-undef */
 // ----------------------------------------------------------------------------
@@ -20,100 +20,71 @@ var vtkDebugMacro = vtkDebugMacro$1; // the webgpu constants all show up as unde
 // ----------------------------------------------------------------------------
 
 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;
-    }
+function _getFormatForDataArray(dataArray) {
+  var format;
 
-    return 0;
-  },
-  stripsToWireframe: function stripsToWireframe(numPoints, cellPts) {
-    if (numPoints > 2) {
-      return numPoints * 4 - 6;
-    }
+  switch (dataArray.getDataType()) {
+    case VtkDataTypes.UNSIGNED_CHAR:
+      format = 'uint8';
+      break;
 
-    return 0;
-  },
-  polysToSurface: function polysToSurface(npts, cellPts) {
-    if (npts > 2) {
-      return (npts - 2) * 3;
-    }
+    case VtkDataTypes.FLOAT:
+      format = 'float32';
+      break;
 
-    return 0;
-  },
-  stripsToSurface: function stripsToSurface(npts, cellPts, offset) {
-    if (numPoints > 2) {
-      return (npts - 2) * 3;
-    }
+    case VtkDataTypes.UNSIGNED_INT:
+      format = 'uint32';
+      break;
 
-    return 0;
-  }
-};
-
-function getPrimitiveName(primType) {
-  switch (primType) {
-    case PrimitiveTypes.Points:
-      return 'points';
+    case VtkDataTypes.INT:
+      format = 'sint32';
+      break;
 
-    case PrimitiveTypes.Lines:
-      return 'lines';
+    case VtkDataTypes.DOUBLE:
+      format = 'float32';
+      break;
 
-    case PrimitiveTypes.Triangles:
-    case PrimitiveTypes.TriangleEdges:
-      return 'polys';
+    case VtkDataTypes.UNSIGNED_SHORT:
+      format = 'uint16';
+      break;
 
-    case PrimitiveTypes.TriangleStripEdges:
-    case PrimitiveTypes.TriangleStrips:
-      return 'strips';
+    case VtkDataTypes.SHORT:
+      format = 'sin16';
+      break;
 
     default:
-      return '';
+      format = 'float32';
+      break;
   }
-}
 
-function getOutputSize(cellArray, representation, inRepName) {
-  var countFunc = null;
+  switch (dataArray.getNumberOfComponents()) {
+    case 2:
+      format += 'x2';
+      break;
 
-  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")];
-  }
+    case 3:
+      // only 32bit types support x3
+      if (!format.contains('32')) {
+        vtkErrorMacro("unsupported x3 type for ".concat(format));
+      }
 
-  var array = cellArray.getData();
-  var size = array.length;
-  var caboCount = 0;
+      format += 'x3';
+      break;
 
-  for (var index = 0; index < size;) {
-    caboCount += countFunc(array[index], array);
-    index += array[index] + 1;
+    case 4:
+      format += 'x4';
+      break;
   }
 
-  return caboCount;
+  return format;
 }
 
-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
 
@@ -139,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;
 }
 
@@ -275,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;
@@ -360,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
 
 
-    var buffer = vtkWebGPUBuffer.newInstance({
-      label: req.label
-    });
-    buffer.setDevice(model.device);
-    var gpuUsage = null; // handle uniform buffers
+    if (!buffer) {
+      buffer = vtkWebGPUBuffer.newInstance({
+        label: req.label
+      });
+      buffer.setDevice(model.device);
+    } // handle uniform buffers
+
 
     if (req.usage === BufferUsage.UniformArray) {
       /* eslint-disable no-bitwise */
@@ -401,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,
@@ -412,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'
       }]);
     }
 
@@ -443,27 +324,32 @@ function vtkWebGPUBufferManager(publicAPI, model) {
   } // is the buffer already present?
 
 
-  publicAPI.hasBuffer = function (req) {
-    if (req.owner) {
-      // if a matching buffer already exists then return true
-      var hash = req.time + req.format + req.usage + req.hash;
-      return model.device.hasCachedObject(req.owner, hash);
-    }
-
-    return false;
+  publicAPI.hasBuffer = function (hash) {
+    return model.device.hasCachedObject(hash);
   };
 
   publicAPI.getBuffer = function (req) {
     // if we have a source the get/create/cache the buffer
-    if (req.owner) {
-      // if a matching buffer already exists then return it
-      var hash = req.time + req.format + req.usage + req.hash;
-      return model.device.getCachedObject(req.owner, hash, _createBuffer, req);
+    if (req.hash) {
+      return model.device.getCachedObject(req.hash, _createBuffer, req);
     }
 
     return _createBuffer(req);
   };
 
+  publicAPI.getBufferForPointArray = function (dataArray, indexBuffer) {
+    var format = _getFormatForDataArray(dataArray);
+
+    var buffRequest = {
+      hash: "".concat(dataArray.getMTime(), "I").concat(indexBuffer.getMTime()).concat(format),
+      usage: BufferUsage.PointArray,
+      format: format,
+      dataArray: dataArray,
+      indexBuffer: indexBuffer
+    };
+    return publicAPI.getBuffer(buffRequest);
+  };
+
   publicAPI.getFullScreenQuadBuffer = function () {
     if (model.fullScreenQuadBuffer) {
       return model.fullScreenQuadBuffer;