@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/WebGPU/IndexBuffer.js

@@ -1,16 +1,16 @@
-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 { m as macro } from '../../macros2.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; }
+const {
+  Representation
+} = vtkProperty;
+const {
+  PrimitiveTypes
+} = Constants;
 
-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
+// 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
@@ -21,80 +21,56 @@ var PrimitiveTypes = Constants.PrimitiveTypes; // Simulate a small map of pointI
 // 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);
-
+class _LimitedMap {
+  constructor() {
     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;
-        }
+  clear() {
+    this.count = 0;
+  }
+  has(key) {
+    for (let 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;
+  }
+  get(key) {
+    for (let 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 undefined;
+  }
+  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];
-
+  let flatId = state.pointIdToFlatId[ptId];
   if (flatId < 0) {
     flatId = state.flatId;
     state.pointIdToFlatId[ptId] = flatId;
@@ -102,191 +78,178 @@ function _getOrAddFlatId(state, ptId, cellId) {
     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
-
-
+  const numPtIds = ptIds.length;
+  // are any points already marked for this cell? If so use that as the provoking point
+  for (let ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    let 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 (let ptIdx2 = ptIdx + 1; ptIdx2 < ptIdx + numPtIds; ptIdx2++) {
+        ptId = ptIds[ptIdx2 % numPtIds];
+        const 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
+  // else have any of the points not been used yet? (not in provokedPointIds)
+  for (let ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    let ptId = ptIds[ptIdx];
+    if (!state.provokedPointIds[ptId]) {
+      let flatId = _getOrAddFlatId(state, ptId, cellId);
+      // mark provoking and add to ibo
+      state.provokedPointIds[ptId] = 1;
+      state.cellProvokedMap.set(ptId, flatId);
+      // 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
-
-
+      state.flatIdToCellId[flatId] = cellId;
+      state.ibo[state.iboId++] = flatId;
+
+      // insert remaining ptIds (they do not need to provoke)
+      for (let ptIdx2 = ptIdx + 1; ptIdx2 < ptIdx + numPtIds; ptIdx2++) {
+        ptId = ptIds[ptIdx2 % numPtIds];
+        flatId = _getOrAddFlatId(state, ptId, cellId);
+        // add to ibo
+        state.ibo[state.iboId++] = flatId;
+      }
+      // 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;
+  // if we got here then none of the ptIds could be used to provoke
+  // so just duplicate the first one
+  let ptId = ptIds[0];
+  let 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)
+  state.flatId++;
 
-  for (var _ptIdx3 = 1; _ptIdx3 < numPtIds; _ptIdx3++) {
-    ptId = ptIds[_ptIdx3];
-    flatId = _getOrAddFlatId(state, ptId, cellId); // add to ibo
+  // add to ibo
+  state.ibo[state.iboId++] = flatId;
 
+  // insert remaining ptIds (they do not need to provoke)
+  for (let ptIdx2 = 1; ptIdx2 < numPtIds; ptIdx2++) {
+    ptId = ptIds[ptIdx2];
+    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];
+  const numPtIds = ptIds.length;
+  state.iboSize += numPtIds;
 
+  // are any points already marked for this cell? If so use that as the provoking point
+  for (let ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    const 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);
+  // else have any of the points not been used yet? (not in provokedPointIds)
+  for (let ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    const ptId = ptIds[ptIdx];
+    if (!state.provokedPointIds[ptId]) {
+      state.provokedPointIds[ptId] = 1;
+      state.cellProvokedMap.set(ptId, 1);
       return;
     }
-  } // if we got here then none of the ptIds could be used to provoke
-
-
+  }
+  // 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 = {
+let processCell;
+const _single = new Uint32Array(1);
+const _double = new Uint32Array(2);
+const _triple = new Uint32Array(3);
+const _indexCellBuilders = {
   // easy, every input point becomes an output point
-  anythingToPoints: function anythingToPoints(numPoints, cellPts, offset, cellId, state) {
-    for (var i = 0; i < numPoints; ++i) {
+  anythingToPoints(numPoints, cellPts, offset, cellId, state) {
+    for (let i = 0; i < numPoints; ++i) {
       _single[0] = cellPts[offset + i];
       processCell(_single, cellId, state);
     }
   },
-  linesToWireframe: function linesToWireframe(numPoints, cellPts, offset, cellId, state) {
+  linesToWireframe(numPoints, cellPts, offset, cellId, state) {
     // for lines we add a bunch of segments
-    for (var i = 0; i < numPoints - 1; ++i) {
+    for (let 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) {
+  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) {
+      for (let 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) {
+  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) {
+      for (let 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];
+      for (let 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++) {
+  polysToSurface(npts, cellPts, offset, cellId, state) {
+    for (let 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++) {
+  stripsToSurface(npts, cellPts, offset, cellId, state) {
+    for (let 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 = {
+  publicAPI.buildIndexBuffer = req => {
+    const cellArray = req.cells;
+    const primitiveType = req.primitiveType;
+    const representation = req.representation;
+    const cellOffset = req.cellOffset;
+    const array = cellArray.getData();
+    const cellArraySize = array.length;
+    const inRepName = getPrimitiveName(primitiveType);
+    const numPts = req.numberOfPoints;
+    const state = {
       provokedPointIds: new Uint8Array(numPts),
       // size is good
       extraPoints: 0,
@@ -295,41 +258,37 @@ function vtkWebGPUIndexBuffer(publicAPI, model) {
       iboId: 0,
       cellProvokedMap: new _LimitedMap()
     };
-    var func = null;
-
+    let 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")];
+      func = _indexCellBuilders[`${inRepName}ToWireframe`];
     } else {
-      func = _indexCellBuilders["".concat(inRepName, "ToSurface")];
-    } // first we count how many extra provoking points we need
-
+      func = _indexCellBuilders[`${inRepName}ToSurface`];
+    }
 
+    // first we count how many extra provoking points we need
     processCell = countCell;
-    var cellId = cellOffset || 0;
-
-    for (var cellArrayIndex = 0; cellArrayIndex < cellArraySize;) {
+    let cellId = cellOffset || 0;
+    for (let 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)
-
+    }
 
+    // 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';
@@ -337,61 +296,68 @@ function vtkWebGPUIndexBuffer(publicAPI, model) {
       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
+    state.provokedPointIds.fill(0);
 
+    // and fill them in
     processCell = fillCell;
     cellId = cellOffset || 0;
-
-    for (var _cellArrayIndex = 0; _cellArrayIndex < cellArraySize;) {
+    for (let cellArrayIndex = 0; cellArrayIndex < cellArraySize;) {
       state.cellProvokedMap.clear();
-      func(array[_cellArrayIndex], array, _cellArrayIndex + 1, cellId, state);
-      _cellArrayIndex += array[_cellArrayIndex] + 1;
+      func(array[cellArrayIndex], array, cellArrayIndex + 1, cellId, state);
+      cellArrayIndex += array[cellArrayIndex] + 1;
       cellId++;
     }
-
     delete state.provokedPointIds;
-    delete state.pointIdToFlatId; // store the results we need
+    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 = {
+const 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
+  let 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); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
-var vtkWebGPUIndexBuffer$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkWebGPUIndexBuffer$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkWebGPUIndexBuffer$1 as default, extend, newInstance };