opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/renderers/webgpu/WebGPURenderPipelines.js

@@ -0,0 +1,275 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./WebGPURenderPipeline.js", "./WebGPUProgrammableStage.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./WebGPURenderPipeline.js"), require("./WebGPUProgrammableStage.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.WebGPURenderPipeline, global.WebGPUProgrammableStage);
+    global.WebGPURenderPipelines = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _WebGPURenderPipeline, _WebGPUProgrammableStage) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _WebGPURenderPipeline = _interopRequireDefault(_WebGPURenderPipeline);
+  _WebGPUProgrammableStage = _interopRequireDefault(_WebGPUProgrammableStage);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  var WebGPURenderPipelines = /*#__PURE__*/function () {
+    function WebGPURenderPipelines(renderer, properties, device, sampleCount, nodes) {
+      _classCallCheck(this, WebGPURenderPipelines);
+
+      this.renderer = renderer;
+      this.properties = properties;
+      this.device = device;
+      this.sampleCount = sampleCount;
+      this.nodes = nodes;
+      this.pipelines = [];
+      this.objectCache = new WeakMap();
+      this.stages = {
+        vertex: new Map(),
+        fragment: new Map()
+      };
+    }
+
+    _createClass(WebGPURenderPipelines, [{
+      key: "get",
+      value: function get(object) {
+        var device = this.device;
+        var properties = this.properties;
+        var material = object.material;
+        var materialProperties = properties.get(material);
+
+        var cache = this._getCache(object);
+
+        var currentPipeline;
+
+        if (this._needsUpdate(object, cache)) {
+          // get shader
+          var nodeBuilder = this.nodes.get(object); // programmable stages
+
+          var stageVertex = this.stages.vertex.get(nodeBuilder.vertexShader);
+
+          if (stageVertex === undefined) {
+            stageVertex = new _WebGPUProgrammableStage.default(device, nodeBuilder.vertexShader, 'vertex');
+            this.stages.vertex.set(nodeBuilder.vertexShader, stageVertex);
+          }
+
+          var stageFragment = this.stages.fragment.get(nodeBuilder.fragmentShader);
+
+          if (stageFragment === undefined) {
+            stageFragment = new _WebGPUProgrammableStage.default(device, nodeBuilder.fragmentShader, 'fragment');
+            this.stages.fragment.set(nodeBuilder.fragmentShader, stageFragment);
+          } // determine render pipeline
+
+
+          currentPipeline = this._acquirePipeline(stageVertex, stageFragment, object, nodeBuilder);
+          cache.currentPipeline = currentPipeline; // keep track of all pipelines which are used by a material
+
+          var materialPipelines = materialProperties.pipelines;
+
+          if (materialPipelines === undefined) {
+            materialPipelines = new Set();
+            materialProperties.pipelines = materialPipelines;
+          }
+
+          if (materialPipelines.has(currentPipeline) === false) {
+            materialPipelines.add(currentPipeline);
+            currentPipeline.usedTimes++;
+            stageVertex.usedTimes++;
+            stageFragment.usedTimes++;
+          } // dispose
+
+
+          if (materialProperties.disposeCallback === undefined) {
+            var disposeCallback = onMaterialDispose.bind(this);
+            materialProperties.disposeCallback = disposeCallback;
+            material.addEventListener('dispose', disposeCallback);
+          }
+        } else {
+          currentPipeline = cache.currentPipeline;
+        }
+
+        return currentPipeline;
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        this.pipelines = [];
+        this.objectCache = new WeakMap();
+        this.shaderModules = {
+          vertex: new Map(),
+          fragment: new Map()
+        };
+      }
+    }, {
+      key: "_acquirePipeline",
+      value: function _acquirePipeline(stageVertex, stageFragment, object, nodeBuilder) {
+        var pipeline;
+        var pipelines = this.pipelines; // check for existing pipeline
+
+        var cacheKey = this._computeCacheKey(stageVertex, stageFragment, object);
+
+        for (var i = 0, il = pipelines.length; i < il; i++) {
+          var preexistingPipeline = pipelines[i];
+
+          if (preexistingPipeline.cacheKey === cacheKey) {
+            pipeline = preexistingPipeline;
+            break;
+          }
+        }
+
+        if (pipeline === undefined) {
+          pipeline = new _WebGPURenderPipeline.default(this.device, this.renderer, this.sampleCount);
+          pipeline.init(cacheKey, stageVertex, stageFragment, object, nodeBuilder);
+          pipelines.push(pipeline);
+        }
+
+        return pipeline;
+      }
+    }, {
+      key: "_computeCacheKey",
+      value: function _computeCacheKey(stageVertex, stageFragment, object) {
+        var material = object.material;
+        var renderer = this.renderer;
+        var parameters = [stageVertex.id, stageFragment.id, material.transparent, material.blending, material.premultipliedAlpha, material.blendSrc, material.blendDst, material.blendEquation, material.blendSrcAlpha, material.blendDstAlpha, material.blendEquationAlpha, material.colorWrite, material.depthWrite, material.depthTest, material.depthFunc, material.stencilWrite, material.stencilFunc, material.stencilFail, material.stencilZFail, material.stencilZPass, material.stencilFuncMask, material.stencilWriteMask, material.side, this.sampleCount, renderer.getCurrentEncoding(), renderer.getCurrentColorFormat(), renderer.getCurrentDepthStencilFormat()];
+        return parameters.join();
+      }
+    }, {
+      key: "_getCache",
+      value: function _getCache(object) {
+        var cache = this.objectCache.get(object);
+
+        if (cache === undefined) {
+          cache = {};
+          this.objectCache.set(object, cache);
+        }
+
+        return cache;
+      }
+    }, {
+      key: "_releasePipeline",
+      value: function _releasePipeline(pipeline) {
+        if (--pipeline.usedTimes === 0) {
+          var pipelines = this.pipelines;
+          var i = pipelines.indexOf(pipeline);
+          pipelines[i] = pipelines[pipelines.length - 1];
+          pipelines.pop();
+
+          this._releaseStage(pipeline.stageVertex);
+
+          this._releaseStage(pipeline.stageFragment);
+        }
+      }
+    }, {
+      key: "_releaseStage",
+      value: function _releaseStage(stage) {
+        if (--stage.usedTimes === 0) {
+          var code = stage.code;
+          var type = stage.type;
+          this.stages[type].delete(code);
+        }
+      }
+    }, {
+      key: "_needsUpdate",
+      value: function _needsUpdate(object, cache) {
+        var material = object.material;
+        var needsUpdate = false; // check material state
+
+        if (cache.material !== material || cache.materialVersion !== material.version || cache.transparent !== material.transparent || cache.blending !== material.blending || cache.premultipliedAlpha !== material.premultipliedAlpha || cache.blendSrc !== material.blendSrc || cache.blendDst !== material.blendDst || cache.blendEquation !== material.blendEquation || cache.blendSrcAlpha !== material.blendSrcAlpha || cache.blendDstAlpha !== material.blendDstAlpha || cache.blendEquationAlpha !== material.blendEquationAlpha || cache.colorWrite !== material.colorWrite || cache.depthWrite !== material.depthWrite || cache.depthTest !== material.depthTest || cache.depthFunc !== material.depthFunc || cache.stencilWrite !== material.stencilWrite || cache.stencilFunc !== material.stencilFunc || cache.stencilFail !== material.stencilFail || cache.stencilZFail !== material.stencilZFail || cache.stencilZPass !== material.stencilZPass || cache.stencilFuncMask !== material.stencilFuncMask || cache.stencilWriteMask !== material.stencilWriteMask || cache.side !== material.side) {
+          cache.material = material;
+          cache.materialVersion = material.version;
+          cache.transparent = material.transparent;
+          cache.blending = material.blending;
+          cache.premultipliedAlpha = material.premultipliedAlpha;
+          cache.blendSrc = material.blendSrc;
+          cache.blendDst = material.blendDst;
+          cache.blendEquation = material.blendEquation;
+          cache.blendSrcAlpha = material.blendSrcAlpha;
+          cache.blendDstAlpha = material.blendDstAlpha;
+          cache.blendEquationAlpha = material.blendEquationAlpha;
+          cache.colorWrite = material.colorWrite;
+          cache.depthWrite = material.depthWrite;
+          cache.depthTest = material.depthTest;
+          cache.depthFunc = material.depthFunc;
+          cache.stencilWrite = material.stencilWrite;
+          cache.stencilFunc = material.stencilFunc;
+          cache.stencilFail = material.stencilFail;
+          cache.stencilZFail = material.stencilZFail;
+          cache.stencilZPass = material.stencilZPass;
+          cache.stencilFuncMask = material.stencilFuncMask;
+          cache.stencilWriteMask = material.stencilWriteMask;
+          cache.side = material.side;
+          needsUpdate = true;
+        } // check renderer state
+
+
+        var renderer = this.renderer;
+        var encoding = renderer.getCurrentEncoding();
+        var colorFormat = renderer.getCurrentColorFormat();
+        var depthStencilFormat = renderer.getCurrentDepthStencilFormat();
+
+        if (cache.sampleCount !== this.sampleCount || cache.encoding !== encoding || cache.colorFormat !== colorFormat || cache.depthStencilFormat !== depthStencilFormat) {
+          cache.sampleCount = this.sampleCount;
+          cache.encoding = encoding;
+          cache.colorFormat = colorFormat;
+          cache.depthStencilFormat = depthStencilFormat;
+          needsUpdate = true;
+        }
+
+        return needsUpdate;
+      }
+    }]);
+
+    return WebGPURenderPipelines;
+  }();
+
+  function onMaterialDispose(event) {
+    var properties = this.properties;
+    var material = event.target;
+    var materialProperties = properties.get(material);
+    material.removeEventListener('dispose', materialProperties.disposeCallback);
+    properties.remove(material); // remove references to pipelines
+
+    var pipelines = materialProperties.pipelines;
+
+    if (pipelines !== undefined) {
+      var _iterator = _createForOfIteratorHelper(pipelines),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var pipeline = _step.value;
+
+          this._releasePipeline(pipeline);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }
+
+  var _default = WebGPURenderPipelines;
+  _exports.default = _default;
+});