service-flow-designer 0.0.1-beta.1 → 0.0.1-beta.4

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/components/geometry/GeometryComponent.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const defineProperty = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/defineProperty.js");
+const classCallCheck = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const createClass = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js");
+const assertThisInitialized = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js");
+const inherits = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/inherits.js");
+const possibleConstructorReturn = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js");
+const getPrototypeOf = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js");
+const ComponentManager = require("../../ComponentManager.js");
+const isTypedarray = require("../../utils/is-typedarray.js");
+const vec4 = require("../../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec4.js");
+const mat3 = require("../../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/mat3.js");
+const vec3 = require("../../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec3.js");
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (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 = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+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 {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+var GeometryComponent = /* @__PURE__ */ function(_Component) {
+  inherits(GeometryComponent2, _Component);
+  var _super = _createSuper(GeometryComponent2);
+  function GeometryComponent2(data) {
+    var _this;
+    classCallCheck(this, GeometryComponent2);
+    _this = _super.call(this, data);
+    _this.dirty = true;
+    _this.attributes = [];
+    _this.indices = void 0;
+    _this.indicesBuffer = void 0;
+    _this.vertexCount = 0;
+    _this.maxInstancedCount = void 0;
+    _this.aabb = void 0;
+    _this.entity = void 0;
+    Object.assign(assertThisInitialized(_this), data);
+    return _this;
+  }
+  createClass(GeometryComponent2, [{
+    key: "setAttribute",
+    value: function setAttribute(name, data, descriptor, bufferGetter) {
+      var existed = this.attributes.find(function(a) {
+        return a.name === name;
+      });
+      if (!existed) {
+        this.attributes.push(_objectSpread(_objectSpread({
+          dirty: true,
+          name,
+          data
+        }, descriptor), {}, {
+          bufferGetter
+        }));
+      } else {
+        existed.data = data;
+        existed.dirty = true;
+      }
+      this.dirty = true;
+      return this;
+    }
+  }, {
+    key: "setIndex",
+    value: function setIndex(data) {
+      this.indices = new Uint32Array(
+        // @ts-ignore
+        data.buffer ? data.buffer : data
+      );
+      this.dirty = true;
+      return this;
+    }
+    /**
+     * when merge all the geometries into one, we need to transform every vertex's position
+     * and every face's normal
+     */
+  }, {
+    key: "applyMatrix",
+    value: function applyMatrix(matrix) {
+      var positionAttribute = this.attributes.find(function(_ref) {
+        var name = _ref.name;
+        return name === "position";
+      });
+      var normalAttribute = this.attributes.find(function(_ref2) {
+        var name = _ref2.name;
+        return name === "normal";
+      });
+      if (positionAttribute) {
+        positionAttribute.dirty = true;
+        if (positionAttribute.data && positionAttribute.data.length) {
+          for (var i = 0; i < positionAttribute.data.length; i += 3) {
+            var position = vec4.fromValues(
+              // @ts-ignore
+              positionAttribute.data[i],
+              // @ts-ignore
+              positionAttribute.data[i + 1],
+              // @ts-ignore
+              positionAttribute.data[i + 2],
+              1
+            );
+            vec4.transformMat4(position, position, matrix);
+            if (isTypedarray.isTypedArray(positionAttribute.data)) {
+              positionAttribute.data.set([position[0], position[1], position[2]], i);
+            } else {
+              positionAttribute.data[i] = position[0];
+              positionAttribute.data[i + 1] = position[1];
+              positionAttribute.data[i + 2] = position[2];
+            }
+          }
+        }
+      }
+      if (normalAttribute) {
+        var normalMatrix = mat3.normalFromMat4(mat3.create(), matrix);
+        if (normalAttribute.data && normalAttribute.data.length) {
+          for (var _i = 0; _i < normalAttribute.data.length; _i += 3) {
+            var normal = vec3.fromValues(
+              // @ts-ignore
+              normalAttribute.data[_i],
+              // @ts-ignore
+              normalAttribute.data[_i + 1],
+              // @ts-ignore
+              normalAttribute.data[_i + 2]
+            );
+            vec3.transformMat3(normal, normal, normalMatrix);
+            vec3.normalize(normal, normal);
+            if (isTypedarray.isTypedArray(normalAttribute.data)) {
+              normalAttribute.data.set([normal[0], normal[1], normal[2]], _i);
+            } else {
+              normalAttribute.data[_i] = normal[0];
+              normalAttribute.data[_i + 1] = normal[1];
+              normalAttribute.data[_i + 2] = normal[2];
+            }
+          }
+        }
+      }
+    }
+  }]);
+  return GeometryComponent2;
+}(ComponentManager.Component);
+exports.GeometryComponent = GeometryComponent;

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/components/geometry/System.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/regenerator/index.js");
+const asyncToGenerator = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js");
+const initializerDefineProperty = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js");
+const classCallCheck = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const createClass = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js");
+const applyDecoratedDescriptor = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js");
+require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js");
+const injectable = require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js");
+require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js");
+const inject = require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js");
+require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js");
+require("../../index.js");
+const identifier = require("../../identifier.js");
+const gl = require("../renderer/gl.js");
+const Entity = require("../../Entity.js");
+var _dec, _dec2, _dec3, _class, _class2, _descriptor, _descriptor2, _temp;
+var GeometrySystem = (_dec = injectable.injectable(), _dec2 = inject.inject(identifier.IDENTIFIER.GeometryComponentManager), _dec3 = inject.inject(identifier.IDENTIFIER.RenderEngine), _dec(_class = (_class2 = (_temp = /* @__PURE__ */ function() {
+  function GeometrySystem2() {
+    classCallCheck(this, GeometrySystem2);
+    initializerDefineProperty(this, "geometry", _descriptor, this);
+    initializerDefineProperty(this, "engine", _descriptor2, this);
+  }
+  createClass(GeometrySystem2, [{
+    key: "execute",
+    value: function() {
+      var _execute = asyncToGenerator(/* @__PURE__ */ index.mark(function _callee() {
+        var _this = this;
+        return index.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                this.geometry.forEach(function(entity, component) {
+                  if (component.dirty) {
+                    component.attributes.forEach(function(attribute) {
+                      if (attribute.dirty && attribute.data) {
+                        if (!attribute.buffer) {
+                          attribute.buffer = _this.engine.createBuffer({
+                            data: attribute.data,
+                            type: gl.gl.FLOAT
+                          });
+                        } else {
+                          var _attribute$buffer;
+                          (_attribute$buffer = attribute.buffer) === null || _attribute$buffer === void 0 ? void 0 : _attribute$buffer.subData({
+                            data: attribute.data,
+                            // TODO: support offset in subdata
+                            offset: 0
+                          });
+                        }
+                        attribute.dirty = false;
+                      }
+                    });
+                    if (component.indices) {
+                      if (!component.indicesBuffer) {
+                        component.indicesBuffer = _this.engine.createElements({
+                          data: component.indices,
+                          count: component.indices.length,
+                          type: gl.gl.UNSIGNED_INT,
+                          usage: gl.gl.STATIC_DRAW
+                        });
+                      } else {
+                        component.indicesBuffer.subData({
+                          data: component.indices,
+                          offset: 0
+                        });
+                      }
+                    }
+                    component.dirty = false;
+                  }
+                });
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function execute() {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  }, {
+    key: "tearDown",
+    value: function tearDown() {
+      this.geometry.forEach(function(_, geometry) {
+        if (geometry.indicesBuffer) {
+          geometry.indicesBuffer.destroy();
+        }
+        geometry.attributes.forEach(function(attribute) {
+          if (attribute.buffer) {
+            attribute.buffer.destroy();
+          }
+        });
+      });
+      this.geometry.clear();
+    }
+    /**
+     * @see https://threejs.org/docs/#api/en/core/BufferGeometry
+     */
+  }, {
+    key: "createBufferGeometry",
+    value: function createBufferGeometry() {
+      var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        vertexCount: 3
+      }, vertexCount = _ref.vertexCount;
+      var entity = Entity.createEntity();
+      return this.geometry.create(entity, {
+        vertexCount
+      });
+    }
+    /**
+     * @see https://threejs.org/docs/#api/en/core/InstancedBufferGeometry
+     */
+  }, {
+    key: "createInstancedBufferGeometry",
+    value: function createInstancedBufferGeometry(_ref2) {
+      var maxInstancedCount = _ref2.maxInstancedCount, vertexCount = _ref2.vertexCount;
+      var entity = Entity.createEntity();
+      return this.geometry.create(entity, {
+        maxInstancedCount,
+        vertexCount
+      });
+    }
+  }]);
+  return GeometrySystem2;
+}(), _temp), _descriptor = applyDecoratedDescriptor(_class2.prototype, "geometry", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = applyDecoratedDescriptor(_class2.prototype, "engine", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class2)) || _class);
+exports.GeometrySystem = GeometrySystem;

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/components/material/MaterialComponent.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const defineProperty = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/defineProperty.js");
+const classCallCheck = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const createClass = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js");
+const assertThisInitialized = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js");
+const inherits = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/inherits.js");
+const possibleConstructorReturn = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js");
+const getPrototypeOf = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js");
+require("../../index.js");
+const ComponentManager = require("../../ComponentManager.js");
+const gl = require("../renderer/gl.js");
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (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 = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+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 {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+var MaterialComponent = /* @__PURE__ */ function(_Component) {
+  inherits(MaterialComponent2, _Component);
+  var _super = _createSuper(MaterialComponent2);
+  function MaterialComponent2(data) {
+    var _this;
+    classCallCheck(this, MaterialComponent2);
+    _this = _super.call(this, data);
+    _this.vertexShaderGLSL = void 0;
+    _this.fragmentShaderGLSL = void 0;
+    _this.defines = {};
+    _this.dirty = true;
+    _this.uniforms = [];
+    _this.cull = {
+      enable: true,
+      face: gl.gl.BACK
+    };
+    _this.depth = {
+      enable: true
+    };
+    _this.blend = void 0;
+    _this.entity = void 0;
+    _this.type = void 0;
+    Object.assign(assertThisInitialized(_this), data);
+    return _this;
+  }
+  createClass(MaterialComponent2, [{
+    key: "setDefines",
+    value: function setDefines(defines) {
+      this.defines = _objectSpread(_objectSpread({}, this.defines), defines);
+      return this;
+    }
+  }, {
+    key: "setCull",
+    value: function setCull(cull) {
+      this.cull = cull;
+      return this;
+    }
+  }, {
+    key: "setDepth",
+    value: function setDepth(depth) {
+      this.depth = depth;
+      return this;
+    }
+  }, {
+    key: "setBlend",
+    value: function setBlend(blend) {
+      this.blend = blend;
+      return this;
+    }
+  }, {
+    key: "setUniform",
+    value: function setUniform(name, data) {
+      var _this2 = this;
+      if (typeof name !== "string") {
+        Object.keys(name).forEach(function(key) {
+          return _this2.setUniform(key, name[key]);
+        });
+        return this;
+      }
+      var existedUniform = this.uniforms.find(function(u) {
+        return u.name === name;
+      });
+      if (!existedUniform) {
+        this.uniforms.push({
+          name,
+          dirty: true,
+          data
+        });
+      } else {
+        existedUniform.dirty = true;
+        existedUniform.data = data;
+      }
+      this.dirty = true;
+      return this;
+    }
+  }]);
+  return MaterialComponent2;
+}(ComponentManager.Component);
+exports.MaterialComponent = MaterialComponent;

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/components/material/System.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const defineProperty = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/defineProperty.js");
+const index = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/regenerator/index.js");
+const asyncToGenerator = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js");
+const initializerDefineProperty = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js");
+const classCallCheck = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const createClass = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js");
+const applyDecoratedDescriptor = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js");
+require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js");
+const injectable = require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js");
+require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js");
+const inject = require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js");
+require("../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js");
+require("../../index.js");
+const identifier = require("../../identifier.js");
+const Entity = require("../../Entity.js");
+var _dec, _dec2, _dec3, _dec4, _class, _class2, _descriptor, _descriptor2, _descriptor3, _temp;
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (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 = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+var MaterialSystem = (_dec = injectable.injectable(), _dec2 = inject.inject(identifier.IDENTIFIER.MaterialComponentManager), _dec3 = inject.inject(identifier.IDENTIFIER.RenderEngine), _dec4 = inject.inject(identifier.IDENTIFIER.ShaderModuleService), _dec(_class = (_class2 = (_temp = /* @__PURE__ */ function() {
+  function MaterialSystem2() {
+    classCallCheck(this, MaterialSystem2);
+    initializerDefineProperty(this, "material", _descriptor, this);
+    initializerDefineProperty(this, "engine", _descriptor2, this);
+    initializerDefineProperty(this, "shaderModule", _descriptor3, this);
+  }
+  createClass(MaterialSystem2, [{
+    key: "execute",
+    value: function() {
+      var _execute = asyncToGenerator(/* @__PURE__ */ index.mark(function _callee() {
+        return index.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+      function execute() {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  }, {
+    key: "tearDown",
+    value: function tearDown() {
+      this.material.clear();
+    }
+    /**
+     * @see https://threejs.org/docs/#api/en/materials/ShaderMaterial
+     */
+  }, {
+    key: "createShaderMaterial",
+    value: function createShaderMaterial(params) {
+      var entity = Entity.createEntity();
+      var vertexShaderGLSL = params.vertexShader;
+      var fragmentShaderGLSL = params.fragmentShader;
+      var uniforms = [];
+      if (!this.engine.supportWebGPU) {
+        var moduleName = "material-".concat(entity);
+        this.shaderModule.registerModule(moduleName, {
+          vs: params.vertexShader,
+          fs: params.fragmentShader
+        });
+        var materialModule = this.shaderModule.getModule(moduleName);
+        vertexShaderGLSL = materialModule.vs;
+        fragmentShaderGLSL = materialModule.fs;
+        if (materialModule.uniforms) {
+          uniforms = Object.keys(materialModule.uniforms).map(function(uniformName) {
+            return {
+              dirty: true,
+              name: uniformName,
+              // @ts-ignore
+              data: materialModule.uniforms[uniformName]
+            };
+          });
+        }
+      }
+      return this.material.create(entity, _objectSpread(_objectSpread({
+        vertexShaderGLSL,
+        fragmentShaderGLSL
+      }, params), {}, {
+        uniforms
+      }));
+    }
+  }]);
+  return MaterialSystem2;
+}(), _temp), _descriptor = applyDecoratedDescriptor(_class2.prototype, "material", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = applyDecoratedDescriptor(_class2.prototype, "engine", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = applyDecoratedDescriptor(_class2.prototype, "shaderModule", [_dec4], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class2)) || _class);
+exports.MaterialSystem = MaterialSystem;

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/components/mesh/CullableComponent.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const classCallCheck = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const assertThisInitialized = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js");
+const inherits = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/inherits.js");
+const possibleConstructorReturn = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js");
+const getPrototypeOf = require("../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js");
+const ComponentManager = require("../../ComponentManager.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 {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+exports.Strategy = void 0;
+(function(Strategy) {
+  Strategy[Strategy["Standard"] = 0] = "Standard";
+})(exports.Strategy || (exports.Strategy = {}));
+var CullableComponent = /* @__PURE__ */ function(_Component) {
+  inherits(CullableComponent2, _Component);
+  var _super = _createSuper(CullableComponent2);
+  function CullableComponent2(data) {
+    var _this;
+    classCallCheck(this, CullableComponent2);
+    _this = _super.call(this, data);
+    _this.strategy = exports.Strategy.Standard;
+    _this.visibilityPlaneMask = 0;
+    _this.visible = false;
+    Object.assign(assertThisInitialized(_this), data);
+    return _this;
+  }
+  return CullableComponent2;
+}(ComponentManager.Component);
+exports.CullableComponent = CullableComponent;