service-flow-designer 0.0.1-beta.0 → 0.0.1-beta.2

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/inversify.config.js

@@ -0,0 +1,62 @@
+import "../../../../../reflect-metadata@0.1.14/node_modules/reflect-metadata/Reflect.js";
+import { Container } from "../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js";
+import "../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js";
+import "../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js";
+import "../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js";
+import { ComponentManager } from "./ComponentManager.js";
+import { ResourcePool } from "./components/framegraph/ResourcePool.js";
+import { FrameGraphSystem } from "./components/framegraph/System.js";
+import { GeometryComponent } from "./components/geometry/GeometryComponent.js";
+import { GeometrySystem } from "./components/geometry/System.js";
+import { MaterialComponent } from "./components/material/MaterialComponent.js";
+import { MaterialSystem } from "./components/material/System.js";
+import { CullableComponent } from "./components/mesh/CullableComponent.js";
+import { MeshComponent } from "./components/mesh/MeshComponent.js";
+import { MeshSystem } from "./components/mesh/System.js";
+import { CopyPass } from "./components/renderer/passes/CopyPass.js";
+import { PixelPickingPass } from "./components/renderer/passes/PixelPickingPass.js";
+import { RenderPass } from "./components/renderer/passes/RenderPass.js";
+import { RendererSystem } from "./components/renderer/System.js";
+import { HierarchyComponent } from "./components/scenegraph/HierarchyComponent.js";
+import { NameComponent } from "./components/scenegraph/NameComponent.js";
+import { SceneGraphSystem } from "./components/scenegraph/System.js";
+import { TransformComponent } from "./components/scenegraph/TransformComponent.js";
+import { IDENTIFIER } from "./identifier.js";
+import { ConfigService } from "./services/config/ConfigService.js";
+import { InteractorService } from "./services/interactor/IteractorService.js";
+import ShaderModuleService from "./services/shader-module/ShaderModuleService.js";
+var container = new Container();
+container.bind(IDENTIFIER.ShaderModuleService).to(ShaderModuleService).inSingletonScope();
+container.bind(IDENTIFIER.NameComponentManager).toConstantValue(new ComponentManager(NameComponent));
+container.bind(IDENTIFIER.HierarchyComponentManager).toConstantValue(new ComponentManager(HierarchyComponent));
+container.bind(IDENTIFIER.TransformComponentManager).toConstantValue(new ComponentManager(TransformComponent));
+container.bind(IDENTIFIER.MeshComponentManager).toConstantValue(new ComponentManager(MeshComponent));
+container.bind(IDENTIFIER.CullableComponentManager).toConstantValue(new ComponentManager(CullableComponent));
+container.bind(IDENTIFIER.GeometryComponentManager).toConstantValue(new ComponentManager(GeometryComponent));
+container.bind(IDENTIFIER.MaterialComponentManager).toConstantValue(new ComponentManager(MaterialComponent));
+function createWorldContainer() {
+  var worldContainer = new Container();
+  worldContainer.parent = container;
+  worldContainer.bind(IDENTIFIER.Systems).to(SceneGraphSystem).inSingletonScope().whenTargetNamed(IDENTIFIER.SceneGraphSystem);
+  worldContainer.bind(IDENTIFIER.Systems).to(FrameGraphSystem).inSingletonScope().whenTargetNamed(IDENTIFIER.FrameGraphSystem);
+  worldContainer.bind(IDENTIFIER.Systems).to(MeshSystem).inSingletonScope().whenTargetNamed(IDENTIFIER.MeshSystem);
+  worldContainer.bind(IDENTIFIER.Systems).to(GeometrySystem).inSingletonScope().whenTargetNamed(IDENTIFIER.GeometrySystem);
+  worldContainer.bind(IDENTIFIER.Systems).to(MaterialSystem).inSingletonScope().whenTargetNamed(IDENTIFIER.MaterialSystem);
+  worldContainer.bind(IDENTIFIER.Systems).to(RendererSystem).inSingletonScope().whenTargetNamed(IDENTIFIER.RendererSystem);
+  worldContainer.bind(IDENTIFIER.ResourcePool).to(ResourcePool).inSingletonScope();
+  worldContainer.bind(IDENTIFIER.ConfigService).to(ConfigService).inSingletonScope();
+  worldContainer.bind(IDENTIFIER.InteractorService).to(InteractorService).inSingletonScope();
+  worldContainer.bind(IDENTIFIER.RenderPass).to(RenderPass).inSingletonScope().whenTargetNamed(RenderPass.IDENTIFIER);
+  worldContainer.bind(IDENTIFIER.RenderPass).to(CopyPass).inSingletonScope().whenTargetNamed(CopyPass.IDENTIFIER);
+  worldContainer.bind(IDENTIFIER.RenderPass).to(PixelPickingPass).inSingletonScope().whenTargetNamed(PixelPickingPass.IDENTIFIER);
+  worldContainer.bind(IDENTIFIER.RenderPassFactory).toFactory(function(context) {
+    return function(name) {
+      return context.container.getNamed(IDENTIFIER.RenderPass, name);
+    };
+  });
+  return worldContainer;
+}
+export {
+  container,
+  createWorldContainer
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/services/config/ConfigService.js

@@ -0,0 +1,29 @@
+import _classCallCheck from "../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js";
+import { injectable } from "../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js";
+var _dec, _class, _temp;
+var ConfigService = (_dec = injectable(), _dec(_class = (_temp = /* @__PURE__ */ function() {
+  function ConfigService2() {
+    _classCallCheck(this, ConfigService2);
+    this.config = void 0;
+  }
+  _createClass(ConfigService2, [{
+    key: "get",
+    value: function get() {
+      return this.config;
+    }
+  }, {
+    key: "set",
+    value: function set(config) {
+      this.config = config;
+    }
+  }]);
+  return ConfigService2;
+}(), _temp)) || _class);
+export {
+  ConfigService
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/services/interactor/IteractorService.js

@@ -0,0 +1,49 @@
+import _classCallCheck from "../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js";
+import { injectable } from "../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js";
+var _dec, _class;
+var IInteractorEvent;
+(function(IInteractorEvent2) {
+  IInteractorEvent2["PANSTART"] = "PANSTART";
+  IInteractorEvent2["PANEND"] = "PANEND";
+  IInteractorEvent2["PANMOVE"] = "PANMOVE";
+  IInteractorEvent2["PINCH"] = "PINCH";
+  IInteractorEvent2["KEYDOWN"] = "KEYDOWN";
+  IInteractorEvent2["KEYUP"] = "KEYUP";
+  IInteractorEvent2["HOVER"] = "HOVER";
+})(IInteractorEvent || (IInteractorEvent = {}));
+var InteractorService = (_dec = injectable(), _dec(_class = /* @__PURE__ */ function() {
+  function InteractorService2() {
+    _classCallCheck(this, InteractorService2);
+  }
+  _createClass(InteractorService2, [{
+    key: "listen",
+    value: function listen(canvas) {
+    }
+  }, {
+    key: "on",
+    value: function on(event, args) {
+    }
+  }, {
+    key: "connect",
+    value: function connect() {
+    }
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+    }
+  }]);
+  return InteractorService2;
+}()) || _class);
+export {
+  IInteractorEvent,
+  InteractorService
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/services/shader-module/ShaderModuleService.js

@@ -0,0 +1,136 @@
+import _defineProperty from "../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/defineProperty.js";
+import _classCallCheck from "../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js";
+import { injectable } from "../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js";
+import "../../../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js";
+import { extractUniforms } from "../../utils/shader-module.js";
+import { uniq } from "../../utils/uniq.js";
+var _dec, _class, _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 pickingFrag = "varying vec4 v_PickingResult;\nuniform vec4 u_HighlightColor : [0, 0, 0, 0];\nuniform float u_PickingStage : 0.0;\n\n#define PICKING_ENCODE 1.0\n#define PICKING_HIGHLIGHT 2.0\n#define COLOR_SCALE 1. / 255.\n\n/*\n * Returns highlight color if this item is selected.\n */\nvec4 filterHighlightColor(vec4 color) {\n  bool selected = bool(v_PickingResult.a);\n\n  if (selected) {\n    vec4 highLightColor = u_HighlightColor * COLOR_SCALE;\n\n    float highLightAlpha = highLightColor.a;\n    float highLightRatio = highLightAlpha / (highLightAlpha + color.a * (1.0 - highLightAlpha));\n\n    vec3 resultRGB = mix(color.rgb, highLightColor.rgb, highLightRatio);\n    return vec4(resultRGB, color.a);\n  } else {\n    return color;\n  }\n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nvec4 filterPickingColor(vec4 color) {\n  vec3 pickingColor = v_PickingResult.rgb;\n  if (u_PickingStage == PICKING_ENCODE && length(pickingColor) < 0.001) {\n    discard;\n  }\n  return u_PickingStage == PICKING_ENCODE ? vec4(pickingColor, step(0.001,color.a)): color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 filterColor(vec4 color) {\n  return filterPickingColor(filterHighlightColor(color));\n}\n";
+var pickingVert = "attribute vec3 a_PickingColor;\nvarying vec4 v_PickingResult;\n\nuniform vec3 u_PickingColor : [0, 0, 0];\nuniform vec4 u_HighlightColor : [0, 0, 0, 0];\nuniform float u_PickingStage : 0.0;\nuniform float u_PickingThreshold : 1.0;\nuniform float u_PickingBuffer: 0.0;\n\n#define PICKING_ENCODE 1.0\n#define PICKING_HIGHLIGHT 2.0\n#define COLOR_SCALE 1. / 255.\n\nbool isVertexPicked(vec3 vertexColor) {\n  return\n    abs(vertexColor.r - u_PickingColor.r) < u_PickingThreshold &&\n    abs(vertexColor.g - u_PickingColor.g) < u_PickingThreshold &&\n    abs(vertexColor.b - u_PickingColor.b) < u_PickingThreshold;\n}\n\nvoid setPickingColor(vec3 pickingColor) {\n  // compares only in highlight stage\n  v_PickingResult.a = float((u_PickingStage == PICKING_HIGHLIGHT) && isVertexPicked(pickingColor));\n\n  // Stores the picking color so that the fragment shader can render it during picking\n  v_PickingResult.rgb = pickingColor * COLOR_SCALE;\n}\n\nfloat setPickingSize(float x) {\n   return u_PickingStage == PICKING_ENCODE ? x + u_PickingBuffer : x;\n}";
+var sdf2dFrag = "/**\n * 2D signed distance field functions\n * @see http://www.iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm\n */\n\nfloat ndot(vec2 a, vec2 b ) { return a.x*b.x - a.y*b.y; }\n\nfloat sdCircle(vec2 p, float r) {\n  return length(p) - r;\n}\n\nfloat sdEquilateralTriangle(vec2 p) {\n  float k = sqrt(3.0);\n  p.x = abs(p.x) - 1.0;\n  p.y = p.y + 1.0/k;\n  if( p.x + k*p.y > 0.0 ) p = vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;\n  p.x -= clamp( p.x, -2.0, 0.0 );\n  return -length(p)*sign(p.y);\n}\n\nfloat sdBox(vec2 p, vec2 b) {\n  vec2 d = abs(p)-b;\n  return length(max(d,vec2(0))) + min(max(d.x,d.y),0.0);\n}\n\nfloat sdPentagon(vec2 p, float r) {\n  vec3 k = vec3(0.809016994,0.587785252,0.726542528);\n  p.x = abs(p.x);\n  p -= 2.0*min(dot(vec2(-k.x,k.y),p),0.0)*vec2(-k.x,k.y);\n  p -= 2.0*min(dot(vec2( k.x,k.y),p),0.0)*vec2( k.x,k.y);\n  p -= vec2(clamp(p.x,-r*k.z,r*k.z),r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdHexagon(vec2 p, float r) {\n  vec3 k = vec3(-0.866025404,0.5,0.577350269);\n  p = abs(p);\n  p -= 2.0*min(dot(k.xy,p),0.0)*k.xy;\n  p -= vec2(clamp(p.x, -k.z*r, k.z*r), r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdOctogon(vec2 p, float r) {\n  vec3 k = vec3(-0.9238795325, 0.3826834323, 0.4142135623 );\n  p = abs(p);\n  p -= 2.0*min(dot(vec2( k.x,k.y),p),0.0)*vec2( k.x,k.y);\n  p -= 2.0*min(dot(vec2(-k.x,k.y),p),0.0)*vec2(-k.x,k.y);\n  p -= vec2(clamp(p.x, -k.z*r, k.z*r), r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdHexagram(vec2 p, float r) {\n  vec4 k=vec4(-0.5,0.8660254038,0.5773502692,1.7320508076);\n  p = abs(p);\n  p -= 2.0*min(dot(k.xy,p),0.0)*k.xy;\n  p -= 2.0*min(dot(k.yx,p),0.0)*k.yx;\n  p -= vec2(clamp(p.x,r*k.z,r*k.w),r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdRhombus(vec2 p, vec2 b) {\n  vec2 q = abs(p);\n  float h = clamp((-2.0*ndot(q,b)+ndot(b,b))/dot(b,b),-1.0,1.0);\n  float d = length( q - 0.5*b*vec2(1.0-h,1.0+h) );\n  return d * sign( q.x*b.y + q.y*b.x - b.x*b.y );\n}\n\nfloat sdVesica(vec2 p, float r, float d) {\n  p = abs(p);\n  float b = sqrt(r*r-d*d); // can delay this sqrt\n  return ((p.y-b)*d>p.x*b)\n          ? length(p-vec2(0.0,b))\n          : length(p-vec2(-d,0.0))-r;\n}";
+var precisionRegExp = /precision\s+(high|low|medium)p\s+float/;
+var globalDefaultprecision = "#ifdef GL_FRAGMENT_PRECISION_HIGH\n precision highp float;\n #else\n precision mediump float;\n#endif\n";
+var includeRegExp = /#pragma include (["^+"]?["\ "[a-zA-Z_0-9](.*)"]*?)/g;
+var ShaderModuleService = (_dec = injectable(), _dec(_class = (_temp = /* @__PURE__ */ function() {
+  function ShaderModuleService2() {
+    _classCallCheck(this, ShaderModuleService2);
+    this.moduleCache = {};
+    this.rawContentCache = {};
+  }
+  _createClass(ShaderModuleService2, [{
+    key: "registerBuiltinModules",
+    value: function registerBuiltinModules() {
+      this.destroy();
+      this.registerModule("picking", {
+        vs: pickingVert,
+        fs: pickingFrag
+      });
+      this.registerModule("sdf2d", {
+        vs: "",
+        fs: sdf2dFrag
+      });
+    }
+  }, {
+    key: "registerModule",
+    value: function registerModule(moduleName, moduleParams) {
+      if (this.rawContentCache[moduleName]) {
+        return;
+      }
+      var _moduleParams$vs = moduleParams.vs, vs = _moduleParams$vs === void 0 ? "" : _moduleParams$vs, _moduleParams$fs = moduleParams.fs, fs = _moduleParams$fs === void 0 ? "" : _moduleParams$fs, declaredUniforms = moduleParams.uniforms;
+      var _extractUniforms = extractUniforms(vs), extractedVS = _extractUniforms.content, vsUniforms = _extractUniforms.uniforms;
+      var _extractUniforms2 = extractUniforms(fs), extractedFS = _extractUniforms2.content, fsUniforms = _extractUniforms2.uniforms;
+      this.rawContentCache[moduleName] = {
+        fs: extractedFS,
+        uniforms: _objectSpread(_objectSpread(_objectSpread({}, vsUniforms), fsUniforms), declaredUniforms),
+        vs: extractedVS
+      };
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.moduleCache = {};
+      this.rawContentCache = {};
+    }
+  }, {
+    key: "getModule",
+    value: function getModule(moduleName) {
+      var _this = this;
+      if (this.moduleCache[moduleName]) {
+        return this.moduleCache[moduleName];
+      }
+      var rawVS = this.rawContentCache[moduleName].vs || "";
+      var rawFS = this.rawContentCache[moduleName].fs || "";
+      var _this$processModule = this.processModule(rawVS, [], "vs"), vs = _this$processModule.content, vsIncludeList = _this$processModule.includeList;
+      var _this$processModule2 = this.processModule(rawFS, [], "fs"), fs = _this$processModule2.content, fsIncludeList = _this$processModule2.includeList;
+      var compiledFs = fs;
+      var uniforms = uniq(vsIncludeList.concat(fsIncludeList).concat(moduleName)).reduce(function(prev, cur) {
+        return _objectSpread(_objectSpread({}, prev), _this.rawContentCache[cur].uniforms);
+      }, {});
+      if (!precisionRegExp.test(fs)) {
+        compiledFs = globalDefaultprecision + fs;
+      }
+      this.moduleCache[moduleName] = {
+        fs: compiledFs.trim(),
+        uniforms,
+        vs: vs.trim()
+      };
+      return this.moduleCache[moduleName];
+    }
+  }, {
+    key: "processModule",
+    value: function processModule(rawContent, includeList, type) {
+      var _this2 = this;
+      var compiled = rawContent.replace(includeRegExp, function(_, strMatch) {
+        var includeOpt = strMatch.split(" ");
+        var includeName = includeOpt[0].replace(/"/g, "");
+        if (includeList.indexOf(includeName) > -1) {
+          return "";
+        }
+        var txt = _this2.rawContentCache[includeName][type];
+        includeList.push(includeName);
+        var _this2$processModule = _this2.processModule(txt || "", includeList, type), content = _this2$processModule.content;
+        return content;
+      });
+      return {
+        content: compiled,
+        includeList
+      };
+    }
+  }]);
+  return ShaderModuleService2;
+}(), _temp)) || _class);
+export {
+  ShaderModuleService as default
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/shape/AABB.js

@@ -0,0 +1,174 @@
+import _classCallCheck from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js";
+import { create, fromValues, sub, add, scale, copy } from "../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec3.js";
+var AABB = /* @__PURE__ */ function() {
+  function AABB2(center, halfExtents) {
+    _classCallCheck(this, AABB2);
+    this.center = void 0;
+    this.halfExtents = void 0;
+    this.min = create();
+    this.max = create();
+    this.update(center, halfExtents);
+  }
+  _createClass(AABB2, [{
+    key: "update",
+    value: function update(center, halfExtents) {
+      this.center = center || create();
+      this.halfExtents = halfExtents || fromValues(0.5, 0.5, 0.5);
+      this.min = sub(this.min, this.center, this.halfExtents);
+      this.max = add(this.max, this.center, this.halfExtents);
+    }
+  }, {
+    key: "setMinMax",
+    value: function setMinMax(min, max) {
+      add(this.center, max, min);
+      scale(this.center, this.center, 0.5);
+      sub(this.halfExtents, max, min);
+      scale(this.halfExtents, this.halfExtents, 0.5);
+      copy(this.min, min);
+      copy(this.max, max);
+    }
+  }, {
+    key: "getMin",
+    value: function getMin() {
+      return this.min;
+    }
+  }, {
+    key: "getMax",
+    value: function getMax() {
+      return this.max;
+    }
+  }, {
+    key: "add",
+    value: function add2(aabb) {
+      var tc = this.center;
+      var tcx = tc[0];
+      var tcy = tc[1];
+      var tcz = tc[2];
+      var th = this.halfExtents;
+      var thx = th[0];
+      var thy = th[1];
+      var thz = th[2];
+      var tminx = tcx - thx;
+      var tmaxx = tcx + thx;
+      var tminy = tcy - thy;
+      var tmaxy = tcy + thy;
+      var tminz = tcz - thz;
+      var tmaxz = tcz + thz;
+      var oc = aabb.center;
+      var ocx = oc[0];
+      var ocy = oc[1];
+      var ocz = oc[2];
+      var oh = aabb.halfExtents;
+      var ohx = oh[0];
+      var ohy = oh[1];
+      var ohz = oh[2];
+      var ominx = ocx - ohx;
+      var omaxx = ocx + ohx;
+      var ominy = ocy - ohy;
+      var omaxy = ocy + ohy;
+      var ominz = ocz - ohz;
+      var omaxz = ocz + ohz;
+      if (ominx < tminx) {
+        tminx = ominx;
+      }
+      if (omaxx > tmaxx) {
+        tmaxx = omaxx;
+      }
+      if (ominy < tminy) {
+        tminy = ominy;
+      }
+      if (omaxy > tmaxy) {
+        tmaxy = omaxy;
+      }
+      if (ominz < tminz) {
+        tminz = ominz;
+      }
+      if (omaxz > tmaxz) {
+        tmaxz = omaxz;
+      }
+      tc[0] = (tminx + tmaxx) * 0.5;
+      tc[1] = (tminy + tmaxy) * 0.5;
+      tc[2] = (tminz + tmaxz) * 0.5;
+      th[0] = (tmaxx - tminx) * 0.5;
+      th[1] = (tmaxy - tminy) * 0.5;
+      th[2] = (tmaxz - tminz) * 0.5;
+      this.min[0] = tminx;
+      this.min[1] = tminy;
+      this.min[2] = tminz;
+      this.max[0] = tmaxx;
+      this.max[1] = tmaxy;
+      this.max[2] = tmaxz;
+    }
+  }, {
+    key: "intersects",
+    value: function intersects(aabb) {
+      var aMax = this.getMax();
+      var aMin = this.getMin();
+      var bMax = aabb.getMax();
+      var bMin = aabb.getMin();
+      return aMin[0] <= bMax[0] && aMax[0] >= bMin[0] && aMin[1] <= bMax[1] && aMax[1] >= bMin[1] && aMin[2] <= bMax[2] && aMax[2] >= bMin[2];
+    }
+  }, {
+    key: "containsPoint",
+    value: function containsPoint(point) {
+      var min = this.getMin();
+      var max = this.getMax();
+      return !(point[0] < min[0] || point[0] > max[0] || point[1] < min[1] || point[1] > max[1] || point[2] < min[2] || point[2] > max[2]);
+    }
+    /**
+     * get n-vertex
+     * @param plane plane of CullingVolume
+     */
+  }, {
+    key: "getNegativeFarPoint",
+    value: function getNegativeFarPoint(plane) {
+      if (plane.pnVertexFlag === 273) {
+        return copy(create(), this.min);
+      } else if (plane.pnVertexFlag === 272) {
+        return fromValues(this.min[0], this.min[1], this.max[2]);
+      } else if (plane.pnVertexFlag === 257) {
+        return fromValues(this.min[0], this.max[1], this.min[2]);
+      } else if (plane.pnVertexFlag === 256) {
+        return fromValues(this.min[0], this.max[1], this.max[2]);
+      } else if (plane.pnVertexFlag === 17) {
+        return fromValues(this.max[0], this.min[1], this.min[2]);
+      } else if (plane.pnVertexFlag === 16) {
+        return fromValues(this.max[0], this.min[1], this.max[2]);
+      } else if (plane.pnVertexFlag === 1) {
+        return fromValues(this.max[0], this.max[1], this.min[2]);
+      } else {
+        return fromValues(this.max[0], this.max[1], this.max[2]);
+      }
+    }
+    /**
+     * get p-vertex
+     * @param plane plane of CullingVolume
+     */
+  }, {
+    key: "getPositiveFarPoint",
+    value: function getPositiveFarPoint(plane) {
+      if (plane.pnVertexFlag === 273) {
+        return copy(create(), this.max);
+      } else if (plane.pnVertexFlag === 272) {
+        return fromValues(this.max[0], this.max[1], this.min[2]);
+      } else if (plane.pnVertexFlag === 257) {
+        return fromValues(this.max[0], this.min[1], this.max[2]);
+      } else if (plane.pnVertexFlag === 256) {
+        return fromValues(this.max[0], this.min[1], this.min[2]);
+      } else if (plane.pnVertexFlag === 17) {
+        return fromValues(this.min[0], this.max[1], this.max[2]);
+      } else if (plane.pnVertexFlag === 16) {
+        return fromValues(this.min[0], this.max[1], this.min[2]);
+      } else if (plane.pnVertexFlag === 1) {
+        return fromValues(this.min[0], this.min[1], this.max[2]);
+      } else {
+        return fromValues(this.min[0], this.min[1], this.min[2]);
+      }
+    }
+  }]);
+  return AABB2;
+}();
+export {
+  AABB
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/shape/BoundingSphere.js

@@ -0,0 +1,2 @@
+import { create } from "../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec3.js";
+create();

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/shape/Frustum.js

@@ -0,0 +1,51 @@
+import _slicedToArray from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/slicedToArray.js";
+import _classCallCheck from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js";
+import { Plane } from "./Plane.js";
+import { set } from "../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec3.js";
+var Mask;
+(function(Mask2) {
+  Mask2[Mask2["OUTSIDE"] = 4294967295] = "OUTSIDE";
+  Mask2[Mask2["INSIDE"] = 0] = "INSIDE";
+  Mask2[Mask2["INDETERMINATE"] = 2147483647] = "INDETERMINATE";
+})(Mask || (Mask = {}));
+var Frustum = /* @__PURE__ */ function() {
+  function Frustum2(planes) {
+    _classCallCheck(this, Frustum2);
+    this.planes = [];
+    if (planes) {
+      this.planes = planes;
+    } else {
+      for (var i = 0; i < 6; i++) {
+        this.planes.push(new Plane());
+      }
+    }
+  }
+  _createClass(Frustum2, [{
+    key: "extractFromVPMatrix",
+    value: function extractFromVPMatrix(vpMatrix) {
+      var _vpMatrix = _slicedToArray(vpMatrix, 16), m0 = _vpMatrix[0], m1 = _vpMatrix[1], m2 = _vpMatrix[2], m3 = _vpMatrix[3], m4 = _vpMatrix[4], m5 = _vpMatrix[5], m6 = _vpMatrix[6], m7 = _vpMatrix[7], m8 = _vpMatrix[8], m9 = _vpMatrix[9], m10 = _vpMatrix[10], m11 = _vpMatrix[11], m12 = _vpMatrix[12], m13 = _vpMatrix[13], m14 = _vpMatrix[14], m15 = _vpMatrix[15];
+      set(this.planes[0].normal, m3 - m0, m7 - m4, m11 - m8);
+      this.planes[0].distance = -(m15 - m12);
+      set(this.planes[1].normal, m3 + m0, m7 + m4, m11 + m8);
+      this.planes[1].distance = -(m15 + m12);
+      set(this.planes[2].normal, m3 + m1, m7 + m5, m11 + m9);
+      this.planes[2].distance = -(m15 + m13);
+      set(this.planes[3].normal, m3 - m1, m7 - m5, m11 - m9);
+      this.planes[3].distance = -(m15 - m13);
+      set(this.planes[4].normal, m3 - m2, m7 - m6, m11 - m10);
+      this.planes[4].distance = -(m15 - m14);
+      set(this.planes[5].normal, m3 + m2, m7 + m6, m11 + m10);
+      this.planes[5].distance = -(m15 + m14);
+      this.planes.forEach(function(plane) {
+        plane.normalize();
+        plane.updatePNVertexFlag();
+      });
+    }
+  }]);
+  return Frustum2;
+}();
+export {
+  Frustum,
+  Mask
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/shape/Plane.js

@@ -0,0 +1,48 @@
+import _classCallCheck from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js";
+import { dot, len, scale, lerp, fromValues } from "../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec3.js";
+var Plane = /* @__PURE__ */ function() {
+  function Plane2(distance, normal) {
+    _classCallCheck(this, Plane2);
+    this.distance = void 0;
+    this.normal = void 0;
+    this.pnVertexFlag = void 0;
+    this.distance = distance || 0;
+    this.normal = normal || fromValues(0, 1, 0);
+    this.updatePNVertexFlag();
+  }
+  _createClass(Plane2, [{
+    key: "updatePNVertexFlag",
+    value: function updatePNVertexFlag() {
+      this.pnVertexFlag = (Number(this.normal[0] >= 0) << 8) + (Number(this.normal[1] >= 0) << 4) + Number(this.normal[2] >= 0);
+    }
+  }, {
+    key: "distanceToPoint",
+    value: function distanceToPoint(point) {
+      return dot(point, this.normal) - this.distance;
+    }
+  }, {
+    key: "normalize",
+    value: function normalize() {
+      var invLen = 1 / len(this.normal);
+      scale(this.normal, this.normal, invLen);
+      this.distance *= invLen;
+    }
+  }, {
+    key: "intersectsLine",
+    value: function intersectsLine(start, end, point) {
+      var d0 = this.distanceToPoint(start);
+      var d1 = this.distanceToPoint(end);
+      var t = d0 / (d0 - d1);
+      var intersects = t >= 0 && t <= 1;
+      if (intersects && point) {
+        lerp(point, start, end, t);
+      }
+      return intersects;
+    }
+  }]);
+  return Plane2;
+}();
+export {
+  Plane
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/shape/Ray.js

@@ -0,0 +1,6 @@
+import { create } from "../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec3.js";
+create();
+create();
+create();
+create();
+create();

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/utils/aabb.js

@@ -0,0 +1,35 @@
+import { AABB } from "../shape/AABB.js";
+import { fromValues } from "../../../../../../gl-matrix@3.4.3/node_modules/gl-matrix/esm/vec3.js";
+function generateAABBFromVertices(positions) {
+  var aabb = new AABB();
+  var min = fromValues(positions[0], positions[1], positions[2]);
+  var max = fromValues(positions[0], positions[1], positions[2]);
+  for (var i = 3; i < positions.length; ) {
+    var x = positions[i++];
+    var y = positions[i++];
+    var z = positions[i++];
+    if (x < min[0]) {
+      min[0] = x;
+    }
+    if (y < min[1]) {
+      min[1] = y;
+    }
+    if (z < min[2]) {
+      min[2] = z;
+    }
+    if (x > max[0]) {
+      max[0] = x;
+    }
+    if (y > max[1]) {
+      max[1] = y;
+    }
+    if (z > max[2]) {
+      max[2] = z;
+    }
+  }
+  aabb.setMinMax(min, max);
+  return aabb;
+}
+export {
+  generateAABBFromVertices
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/utils/is-typedarray.js

@@ -0,0 +1,44 @@
+import _typeof from "../../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/typeof.js";
+var MAX_SAFE_INTEGER = 9007199254740991;
+var argsTag = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var funcTag = "[object Function]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+var objectProto = Object.prototype;
+var objectToString = objectProto.toString;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+}
+function isLength(value) {
+  return typeof value === "number" && value > -1 && value % 1 === 0 && value <= MAX_SAFE_INTEGER;
+}
+function isObjectLike(value) {
+  return !!value && _typeof(value) === "object";
+}
+var isTypedArray = baseIsTypedArray;
+export {
+  isTypedArray
+};

package/dist/es/node_modules/.pnpm/@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/utils/isSafari.js

@@ -0,0 +1,4 @@
+var isSafari = typeof navigator !== "undefined" && /Version\/[\d\.]+.*Safari/.test(navigator.userAgent);
+export {
+  isSafari
+};