@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/WebGPU/CubeAxesActor.js

@@ -1,61 +1,70 @@
-import { newInstance as newInstance$1 } from '../../macros.js';
+import { n as newInstance$1 } from '../../macros2.js';
 import vtkCubeAxesActor from '../Core/CubeAxesActor.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUCubeAxesActor methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUCubeAxesActor(publicAPI, model) {
-  model.classHierarchy.push('vtkWebGPUCubeAxesActor'); // Builds myself.
+  model.classHierarchy.push('vtkWebGPUCubeAxesActor');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
       model.WebGPURenderWindow = model.WebGPURenderer.getParent();
-
       if (!model.CubeAxesActorHelper.getRenderable()) {
         model.CubeAxesActorHelper.setRenderable(model.renderable);
       }
-
       publicAPI.prepareNodes();
       publicAPI.addMissingNode(model.CubeAxesActorHelper.getTmActor());
       publicAPI.addMissingNode(model.renderable.getGridActor());
       publicAPI.removeUnusedNodes();
     }
   };
-
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  publicAPI.opaquePass = (prepass, renderPass) => {
     if (prepass) {
-      var camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
-      var tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
+      const camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
+      const tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
       model.CubeAxesActorHelper.updateAPISpecificData([tsize.usize, tsize.vsize], camera, model.WebGPURenderWindow.getRenderable());
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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
   vtkViewNode.extend(publicAPI, model, initialValues);
-  model.CubeAxesActorHelper = vtkCubeAxesActor.newCubeAxesActorHelper(); // Object methods
+  model.CubeAxesActorHelper = vtkCubeAxesActor.newCubeAxesActorHelper();
 
+  // Object methods
   vtkWebGPUCubeAxesActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUCubeAxesActor'); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPUCubeAxesActor');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkCubeAxesActor', newInstance);
 
 export { index as default, extend, newInstance };

package/Rendering/WebGPU/Device.js

@@ -1,20 +1,8 @@
-import _typeof from '@babel/runtime/helpers/typeof';
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-import _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
-import _get from '@babel/runtime/helpers/get';
-import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
-import _wrapNativeSuper from '@babel/runtime/helpers/wrapNativeSuper';
-import { newInstance as newInstance$1, obj, setGet, get } from '../../macros.js';
+import { n as newInstance$1, o as obj, e as setGet, g as get } from '../../macros2.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUTextureManager from './TextureManager.js';
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 /**
  * provide a simple WeakRefMap class to share device objects based on
  * hash values so that buffers/textures etc can be shared betwen mappers.
@@ -23,205 +11,159 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
  */
 
 /* eslint-disable no-undef */
-
-var WeakRefMap = /*#__PURE__*/function (_Map) {
-  _inherits(WeakRefMap, _Map);
-
-  var _super = _createSuper(WeakRefMap);
-
-  function WeakRefMap() {
-    var _thisSuper, _thisSuper2, _this;
-
-    _classCallCheck(this, WeakRefMap);
-
-    _this = _super.call(this);
-    _this.registry = new FinalizationRegistry(function (key) {
-      var entry = _get((_thisSuper = _assertThisInitialized(_this), _getPrototypeOf(WeakRefMap.prototype)), "get", _thisSuper).call(_thisSuper, key);
-
-      if (entry && entry.deref && entry.deref() === undefined) _get((_thisSuper2 = _assertThisInitialized(_this), _getPrototypeOf(WeakRefMap.prototype)), "delete", _thisSuper2).call(_thisSuper2, key);
+class WeakRefMap extends Map {
+  constructor() {
+    super();
+    this.registry = new FinalizationRegistry(key => {
+      const entry = super.get(key);
+      if (entry && entry.deref && entry.deref() === undefined) super.delete(key);
     });
-    return _this;
   }
-
-  _createClass(WeakRefMap, [{
-    key: "getValue",
-    value: function getValue(key) {
-      var entry = _get(_getPrototypeOf(WeakRefMap.prototype), "get", this).call(this, key);
-
-      if (entry) {
-        var value = entry.deref();
-        if (value !== undefined) return value;
-
-        _get(_getPrototypeOf(WeakRefMap.prototype), "delete", this).call(this, key);
-      }
-
-      return undefined;
+  getValue(key) {
+    const entry = super.get(key);
+    if (entry) {
+      const value = entry.deref();
+      if (value !== undefined) return value;
+      super.delete(key);
     }
-  }, {
-    key: "setValue",
-    value: function setValue(key, value) {
-      var entry;
-
-      if (value && _typeof(value) === 'object') {
-        entry = new WeakRef(value);
-        this.registry.register(value, key);
-
-        _get(_getPrototypeOf(WeakRefMap.prototype), "set", this).call(this, key, entry);
-      } // else entry is undefined
-
-
-      return entry;
+    return undefined;
+  }
+  setValue(key, value) {
+    let entry;
+    if (value && typeof value === 'object') {
+      entry = new WeakRef(value);
+      this.registry.register(value, key);
+      super.set(key, entry);
     }
-  }]);
-
-  return WeakRefMap;
-}( /*#__PURE__*/_wrapNativeSuper(Map));
+    // else entry is undefined
+    return entry;
+  }
+}
 /* eslint-enable no-undef */
+
 // ----------------------------------------------------------------------------
 // vtkWebGPUDevice methods
 // ----------------------------------------------------------------------------
-
 function vtkWebGPUDevice(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUDevice');
-
-  publicAPI.initialize = function (handle) {
+  publicAPI.initialize = handle => {
     model.handle = handle;
   };
-
-  publicAPI.createCommandEncoder = function () {
-    return model.handle.createCommandEncoder();
-  };
-
-  publicAPI.submitCommandEncoder = function (commandEncoder) {
+  publicAPI.createCommandEncoder = () => model.handle.createCommandEncoder();
+  publicAPI.submitCommandEncoder = commandEncoder => {
     model.handle.queue.submit([commandEncoder.finish()]);
   };
+  publicAPI.getShaderModule = sd => model.shaderCache.getShaderModule(sd);
 
-  publicAPI.getShaderModule = function (sd) {
-    return model.shaderCache.getShaderModule(sd);
-  };
   /* eslint-disable no-bitwise */
-
   /* eslint-disable no-undef */
-
-
-  publicAPI.getBindGroupLayout = function (val) {
+  publicAPI.getBindGroupLayout = val => {
     if (!val.entries) {
       return null;
-    } // add in basic required values if missing
-
+    }
 
-    for (var i = 0; i < val.entries.length; i++) {
-      var ent = val.entries[i];
+    // add in basic required values if missing
+    for (let i = 0; i < val.entries.length; i++) {
+      const ent = val.entries[i];
       ent.binding = ent.binding || 0;
       ent.visibility = ent.visibility || GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT;
-    } // do we already have one?
-
-
-    var sval = JSON.stringify(val);
+    }
 
-    for (var _i = 0; _i < model.bindGroupLayouts.length; _i++) {
-      if (model.bindGroupLayouts[_i].sval === sval) {
-        return model.bindGroupLayouts[_i].layout;
+    // do we already have one?
+    const sval = JSON.stringify(val);
+    for (let i = 0; i < model.bindGroupLayouts.length; i++) {
+      if (model.bindGroupLayouts[i].sval === sval) {
+        return model.bindGroupLayouts[i].layout;
       }
-    } // create one and store it
+    }
 
+    // create one and store it
+    const layout = model.handle.createBindGroupLayout(val);
 
-    var layout = model.handle.createBindGroupLayout(val); // we actually only store the stringified version
+    // we actually only store the stringified version
     // as that is what we always compare against
-
     model.bindGroupLayouts.push({
-      sval: sval,
-      layout: layout
+      sval,
+      layout
     });
     return layout;
   };
-
-  publicAPI.getBindGroupLayoutDescription = function (layout) {
-    for (var i = 0; i < model.bindGroupLayouts.length; i++) {
+  publicAPI.getBindGroupLayoutDescription = layout => {
+    for (let i = 0; i < model.bindGroupLayouts.length; i++) {
       if (model.bindGroupLayouts[i].layout === layout) {
         return model.bindGroupLayouts[i].sval;
       }
     }
-
     vtkErrorMacro('layout not found');
     console.trace();
     return null;
   };
-
-  publicAPI.getPipeline = function (hash) {
+  publicAPI.getPipeline = hash => {
     if (hash in model.pipelines) {
       return model.pipelines[hash];
     }
-
     return null;
   };
-
-  publicAPI.createPipeline = function (hash, pipeline) {
+  publicAPI.createPipeline = (hash, pipeline) => {
     pipeline.initialize(publicAPI, hash);
     model.pipelines[hash] = pipeline;
   };
+  publicAPI.onSubmittedWorkDone = () => model.handle.queue.onSubmittedWorkDone();
 
-  publicAPI.onSubmittedWorkDone = function () {
-    return model.handle.queue.onSubmittedWorkDone();
-  }; // The Device has an object cache that can be used to cache buffers,
+  // The Device has an object cache that can be used to cache buffers,
   // textures and other objects that can be shared. The basic approach is to
   // call getCachedObject with a request and a create function. The request
   // is based on a hash. The cache lookup just returns any entry that has a
   // matching hash. If a match isn't found then the create function is
   // called with any extra arguments.
-  // is the object already cached?
-
-
-  publicAPI.hasCachedObject = function (hash) {
-    return model.objectCache.getValue(hash);
-  };
 
+  // is the object already cached?
+  publicAPI.hasCachedObject = hash => model.objectCache.getValue(hash);
   publicAPI.getCachedObject = function (hash, creator) {
     if (!hash) {
       vtkErrorMacro('attempt to cache an object without a hash');
       return null;
     }
-
-    var existingValue = model.objectCache.getValue(hash);
-
+    const existingValue = model.objectCache.getValue(hash);
     if (existingValue) {
       return existingValue;
     }
-
     for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
       args[_key - 2] = arguments[_key];
     }
-
-    var createdObject = creator.apply(void 0, args);
+    const createdObject = creator(...args);
     model.objectCache.setValue(hash, createdObject);
     return createdObject;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   handle: null,
   pipelines: null,
   shaderCache: null,
   bindGroupLayouts: null,
   bufferManager: null,
   textureManager: null
-}; // ----------------------------------------------------------------------------
+};
 
+// ----------------------------------------------------------------------------
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   obj(publicAPI, model);
   setGet(publicAPI, model, ['handle']);
-  get(publicAPI, model, ['bufferManager', 'shaderCache', 'textureManager']); // this is a weak ref cache implementation, we create it without
+  get(publicAPI, model, ['bufferManager', 'shaderCache', 'textureManager']);
+
+  // this is a weak ref cache implementation, we create it without
   // an expirer (so it is strictly based on garbage collection and
   // objects are not held if there are no external references)
   // model.objectCache = new WeakLRUCache({ expirer: false });
-
   model.objectCache = new WeakRefMap();
   model.shaderCache = vtkWebGPUShaderCache.newInstance();
   model.shaderCache.setDevice(publicAPI);
@@ -230,17 +172,20 @@ function extend(publicAPI, model) {
   model.bufferManager.setDevice(publicAPI);
   model.textureManager = vtkWebGPUTextureManager.newInstance();
   model.textureManager.setDevice(publicAPI);
-  model.pipelines = {}; // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  model.pipelines = {};
 
+  // For more macro methods, see "Sources/macros.js"
+  // Object specific methods
   vtkWebGPUDevice(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUDevice'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPUDevice');
 
+// ----------------------------------------------------------------------------
 var vtkWebGPUDevice$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { WeakRefMap, vtkWebGPUDevice$1 as default, extend, newInstance };