view3d-core 1.0.0

package/dist/index.js

@@ -0,0 +1,644 @@
+import * as e from "three";
+import t from "gsap";
+import { I as i, J as n, a as r, O as a, T as c, L as h, C as l, f as p, E as d, t as g, w as f, K as y } from "./SerializationPlugin-CBr1GY5q.js";
+import { A, k, u, m, G, M, o, q, P, v, S, s, Z, a1, V, X, a0, W, U, N, Q, _, Y, R, $ } from "./SerializationPlugin-CBr1GY5q.js";
+class b {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(e2, t2) {
+    this.listeners.has(e2) || this.listeners.set(e2, /* @__PURE__ */ new Set());
+    const s2 = { callback: t2, once: false };
+    return this.listeners.get(e2).add(s2), () => {
+      var _a;
+      (_a = this.listeners.get(e2)) == null ? void 0 : _a.delete(s2);
+    };
+  }
+  once(e2, t2) {
+    this.listeners.has(e2) || this.listeners.set(e2, /* @__PURE__ */ new Set());
+    const s2 = { callback: t2, once: true };
+    return this.listeners.get(e2).add(s2), () => {
+      var _a;
+      (_a = this.listeners.get(e2)) == null ? void 0 : _a.delete(s2);
+    };
+  }
+  off(e2, t2) {
+    if (!t2) return void this.listeners.delete(e2);
+    const s2 = this.listeners.get(e2);
+    if (s2) {
+      for (const e3 of s2) if (e3.callback === t2) {
+        s2.delete(e3);
+        break;
+      }
+    }
+  }
+  emit(e2, t2) {
+    const s2 = this.listeners.get(e2);
+    if (!s2) return;
+    const i2 = [];
+    for (const e3 of s2) {
+      try {
+        e3.callback(t2);
+      } catch (e4) {
+      }
+      e3.once && i2.push(e3);
+    }
+    for (const e3 of i2) s2.delete(e3);
+  }
+  hasListeners(e2) {
+    const t2 = this.listeners.get(e2);
+    return void 0 !== t2 && t2.size > 0;
+  }
+  listenerCount(e2) {
+    var _a;
+    return ((_a = this.listeners.get(e2)) == null ? void 0 : _a.size) ?? 0;
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+  dispose() {
+    this.removeAllListeners();
+  }
+}
+class w {
+  constructor(t2) {
+    this.events = t2, this._envBackground = null, this._environmentEnabled = false, this.envMapChangeCallbacks = [], this.ssrMeshList = [], this.scene = new e.Scene(), this.scene.name = "MainScene";
+  }
+  get envBackground() {
+    return this._envBackground;
+  }
+  set envBackground(e2) {
+    this._envBackground = e2, this.updateEnvironment(), this.envMapChangeCallbacks.forEach((e3) => e3());
+  }
+  get environmentEnabled() {
+    return this._environmentEnabled;
+  }
+  set environmentEnabled(e2) {
+    this._environmentEnabled = e2, this.updateEnvironment();
+  }
+  updateEnvironment() {
+    this.scene.environment = this._environmentEnabled ? this._envBackground : null;
+  }
+  onEnvMapChange(e2) {
+    return this.envMapChangeCallbacks.push(e2), () => {
+      const t2 = this.envMapChangeCallbacks.indexOf(e2);
+      t2 > -1 && this.envMapChangeCallbacks.splice(t2, 1);
+    };
+  }
+  setBackground(e2) {
+    this.scene.background = e2, this.events.emit("scene:background:change", { background: e2 });
+  }
+  setSkybox(t2) {
+    return new Promise((s2, i2) => {
+      new e.CubeTextureLoader().load(t2, (e2) => {
+        this.scene.background = e2, this.events.emit("scene:background:change", { background: e2 }), s2(e2);
+      }, void 0, i2);
+    });
+  }
+  setEnvironmentMap(t2) {
+    return new Promise((s2, i2) => {
+      new e.CubeTextureLoader().load(t2, (e2) => {
+        this.envBackground = e2, s2(e2);
+      }, void 0, i2);
+    });
+  }
+  add(...e2) {
+    for (const t2 of e2) this.scene.add(t2), this.events.emit("object:added", { object: t2, parent: this.scene });
+  }
+  remove(...e2) {
+    for (const t2 of e2) this.scene.remove(t2), this.events.emit("object:removed", { object: t2, parent: this.scene });
+  }
+  getObjectByName(e2) {
+    return this.scene.getObjectByName(e2);
+  }
+  getObjectById(e2) {
+    return this.scene.getObjectById(e2);
+  }
+  traverse(e2) {
+    this.scene.traverse(e2);
+  }
+  getMeshes() {
+    const t2 = [];
+    return this.scene.traverse((s2) => {
+      s2 instanceof e.Mesh && t2.push(s2);
+    }), t2;
+  }
+  getLights() {
+    const t2 = [];
+    return this.scene.traverse((s2) => {
+      s2 instanceof e.Light && t2.push(s2);
+    }), t2;
+  }
+  clear() {
+    for (; this.scene.children.length > 0; ) {
+      const e2 = this.scene.children[0];
+      this.scene.remove(e2), this.events.emit("object:removed", { object: e2, parent: this.scene });
+    }
+  }
+  dispose() {
+    this.scene.traverse((t2) => {
+      var _a;
+      t2 instanceof e.Mesh && ((_a = t2.geometry) == null ? void 0 : _a.dispose(), Array.isArray(t2.material) ? t2.material.forEach((e2) => {
+        e2.dispose(), "map" in e2 && e2.map && e2.map.dispose();
+      }) : t2.material && (t2.material.dispose(), "map" in t2.material && t2.material.map && t2.material.map.dispose()));
+    }), this.clear(), this.envMapChangeCallbacks = [], this.ssrMeshList.length = 0;
+  }
+}
+const x = { fov: 50, near: 0.1, far: 1e5, position: { x: 10, y: 10, z: 10 } };
+class E {
+  constructor(t2, s2, i2) {
+    this.container = t2, this.events = s2, this.config = { ...x, ...i2 };
+    const n2 = t2.clientWidth / t2.clientHeight;
+    this.camera = new e.PerspectiveCamera(this.config.fov, n2, this.config.near, this.config.far), this.camera.name = "MainCamera", this.camera.position.set(this.config.position.x, this.config.position.y, this.config.position.z);
+  }
+  get position() {
+    return this.camera.position;
+  }
+  get fov() {
+    return this.camera.fov;
+  }
+  set fov(e2) {
+    this.camera.fov = e2, this.camera.updateProjectionMatrix(), this.events.emit("camera:change", { camera: this.camera });
+  }
+  get near() {
+    return this.camera.near;
+  }
+  set near(e2) {
+    this.camera.near = e2, this.camera.updateProjectionMatrix(), this.events.emit("camera:change", { camera: this.camera });
+  }
+  get far() {
+    return this.camera.far;
+  }
+  set far(e2) {
+    this.camera.far = e2, this.camera.updateProjectionMatrix(), this.events.emit("camera:change", { camera: this.camera });
+  }
+  setPosition(e2, t2, s2) {
+    this.camera.position.set(e2, t2, s2), this.events.emit("camera:change", { camera: this.camera });
+  }
+  lookAt(t2) {
+    t2 instanceof e.Vector3 ? this.camera.lookAt(t2) : this.camera.lookAt(t2.x, t2.y, t2.z), this.events.emit("camera:change", { camera: this.camera });
+  }
+  updateAspect() {
+    this.camera.aspect = this.container.clientWidth / this.container.clientHeight, this.camera.updateProjectionMatrix();
+  }
+  getWorldDirection() {
+    const t2 = new e.Vector3();
+    return this.camera.getWorldDirection(t2), t2;
+  }
+  getTargetPoint(e2) {
+    const t2 = this.getWorldDirection();
+    return this.camera.position.clone().add(t2.multiplyScalar(e2));
+  }
+  getConfig() {
+    return { fov: this.camera.fov, near: this.camera.near, far: this.camera.far, position: { x: this.camera.position.x, y: this.camera.position.y, z: this.camera.position.z } };
+  }
+  applyConfig(e2) {
+    void 0 !== e2.fov && (this.camera.fov = e2.fov), void 0 !== e2.near && (this.camera.near = e2.near), void 0 !== e2.far && (this.camera.far = e2.far), e2.position && this.camera.position.set(e2.position.x, e2.position.y, e2.position.z), this.camera.updateProjectionMatrix(), this.events.emit("camera:change", { camera: this.camera });
+  }
+  dispose() {
+  }
+}
+const C = { pixelRatio: "undefined" != typeof window ? window.devicePixelRatio : 1, antialias: true, alpha: true, logarithmicDepthBuffer: true, preserveDrawingBuffer: false, powerPreference: "high-performance", toneMapping: e.NoToneMapping, toneMappingExposure: 1, outputColorSpace: e.SRGBColorSpace, shadowMapEnabled: false, shadowMapType: e.PCFSoftShadowMap };
+class z {
+  constructor(t2, s2, i2) {
+    this.container = t2, this.events = s2, this.config = { ...C, ...i2 }, this.renderer = new e.WebGLRenderer({ antialias: this.config.antialias, alpha: this.config.alpha, logarithmicDepthBuffer: this.config.logarithmicDepthBuffer, preserveDrawingBuffer: this.config.preserveDrawingBuffer, powerPreference: this.config.powerPreference }), this.renderer.setSize(t2.clientWidth, t2.clientHeight), this.renderer.setPixelRatio(this.config.pixelRatio), this.renderer.toneMapping = this.config.toneMapping, this.renderer.toneMappingExposure = this.config.toneMappingExposure, this.renderer.outputColorSpace = this.config.outputColorSpace, this.renderer.shadowMap.enabled = this.config.shadowMapEnabled, this.renderer.shadowMap.type = this.config.shadowMapType, t2.appendChild(this.renderer.domElement);
+  }
+  get domElement() {
+    return this.renderer.domElement;
+  }
+  get pixelRatio() {
+    return this.renderer.getPixelRatio();
+  }
+  set pixelRatio(e2) {
+    this.renderer.setPixelRatio(e2), this.config.pixelRatio = e2;
+  }
+  getSize() {
+    const t2 = new e.Vector2();
+    return this.renderer.getSize(t2), { width: t2.x, height: t2.y };
+  }
+  setSize(e2, t2) {
+    this.renderer.setSize(e2, t2), this.events.emit("resize", { width: e2, height: t2 });
+  }
+  updateSize() {
+    const e2 = this.container.clientWidth, t2 = this.container.clientHeight;
+    this.setSize(e2, t2);
+  }
+  render(e2, t2) {
+    this.renderer.render(e2, t2);
+  }
+  getScreenshot(e2 = "image/png", t2 = 0.9) {
+    return this.renderer.domElement.toDataURL(e2, t2);
+  }
+  setShadowMapEnabled(e2) {
+    this.renderer.shadowMap.enabled = e2, this.config.shadowMapEnabled = e2;
+  }
+  setShadowMapType(e2) {
+    this.renderer.shadowMap.type = e2, this.config.shadowMapType = e2;
+  }
+  setToneMapping(e2, t2) {
+    this.renderer.toneMapping = e2, this.config.toneMapping = e2, void 0 !== t2 && (this.renderer.toneMappingExposure = t2, this.config.toneMappingExposure = t2);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  applyConfig(e2) {
+    void 0 !== e2.pixelRatio && (this.pixelRatio = e2.pixelRatio), void 0 !== e2.toneMapping && (this.renderer.toneMapping = e2.toneMapping, this.config.toneMapping = e2.toneMapping), void 0 !== e2.toneMappingExposure && (this.renderer.toneMappingExposure = e2.toneMappingExposure, this.config.toneMappingExposure = e2.toneMappingExposure), void 0 !== e2.shadowMapEnabled && this.setShadowMapEnabled(e2.shadowMapEnabled), void 0 !== e2.shadowMapType && this.setShadowMapType(e2.shadowMapType);
+  }
+  getInfo() {
+    return this.renderer.info;
+  }
+  resetInfo() {
+    this.renderer.info.reset();
+  }
+  dispose() {
+    this.renderer.dispose(), this.renderer.forceContextLoss(), this.renderer.domElement.parentNode && this.renderer.domElement.parentNode.removeChild(this.renderer.domElement);
+  }
+}
+const L = { autoResize: true, fps: null, autoStart: true };
+class I {
+  constructor(t2) {
+    this.animationId = null, this._isRunning = false, this.frameCallbacks = /* @__PURE__ */ new Set(), this.fpsInterval = 0, this.lastFrameTime = 0, this.resizeHandler = null, this.animate = () => {
+      if (!this._isRunning) return;
+      this.animationId = requestAnimationFrame(this.animate);
+      const e2 = performance.now();
+      if (this.fpsInterval > 0) {
+        const t4 = e2 - this.lastFrameTime;
+        if (t4 < this.fpsInterval) return;
+        this.lastFrameTime = e2 - t4 % this.fpsInterval;
+      }
+      const t3 = this.clock.getDelta(), s2 = this.clock.getElapsedTime();
+      this.events.emit("render:before", { delta: t3, elapsed: s2 });
+      for (const e3 of this.frameCallbacks) try {
+        e3(t3, s2);
+      } catch (e4) {
+      }
+      this.render(), this.events.emit("render:after", { delta: t3, elapsed: s2 });
+    }, this.config = { ...L, ...t2 }, this.container = t2.container, this.events = new b(), this.clock = new e.Clock(false), this.sceneManager = new w(this.events), this.cameraManager = new E(this.container, this.events, t2.camera), this.sceneManager.scene.add(this.cameraManager.camera), this.rendererManager = new z(this.container, this.events, t2.renderer), void 0 !== this.config.fps && null !== this.config.fps && this.config.fps > 0 && (this.fpsInterval = 1e3 / this.config.fps), this.config.autoResize && this.setupAutoResize(), this.events.emit("engine:ready", void 0), this.config.autoStart && this.start();
+  }
+  get scene() {
+    return this.sceneManager.scene;
+  }
+  get camera() {
+    return this.cameraManager.camera;
+  }
+  get renderer() {
+    return this.rendererManager.renderer;
+  }
+  get domElement() {
+    return this.rendererManager.domElement;
+  }
+  get isRunning() {
+    return this._isRunning;
+  }
+  setupAutoResize() {
+    this.resizeHandler = () => this.resize(), window.addEventListener("resize", this.resizeHandler);
+  }
+  start() {
+    this._isRunning || (this._isRunning = true, this.clock.start(), this.lastFrameTime = performance.now(), this.events.emit("engine:start", void 0), this.animate());
+  }
+  stop() {
+    this._isRunning && (this._isRunning = false, this.clock.stop(), null !== this.animationId && (cancelAnimationFrame(this.animationId), this.animationId = null), this.events.emit("engine:stop", void 0));
+  }
+  render() {
+    this.rendererManager.render(this.scene, this.camera);
+  }
+  resize() {
+    const e2 = this.container.clientWidth, t2 = this.container.clientHeight;
+    this.cameraManager.updateAspect(), this.rendererManager.setSize(e2, t2), this.events.emit("resize", { width: e2, height: t2 });
+  }
+  onUpdate(e2) {
+    return this.frameCallbacks.add(e2), () => {
+      this.frameCallbacks.delete(e2);
+    };
+  }
+  screenshot(e2, t2) {
+    return this.render(), this.rendererManager.getScreenshot(e2, t2);
+  }
+  setFPS(e2) {
+    this.config.fps = e2, this.fpsInterval = null !== e2 && e2 > 0 ? 1e3 / e2 : 0;
+  }
+  getFPS() {
+    return this.fpsInterval > 0 ? 1e3 / this.fpsInterval : 0;
+  }
+  dispose() {
+    this.events.emit("engine:dispose", void 0), this.stop(), this.resizeHandler && (window.removeEventListener("resize", this.resizeHandler), this.resizeHandler = null), this.frameCallbacks.clear(), this.sceneManager.dispose(), this.cameraManager.dispose(), this.rendererManager.dispose(), this.events.dispose();
+  }
+}
+let T = "/draco/";
+const _D = class _D {
+  constructor(e2) {
+    this.progressList = [], this.commonFrameList = [], this.mixerList = [], this.shaderList = [], this.getDistanceScalePoint = i, this.getBestViewTarget = n, this.config = e2, this.engine = new I({ container: e2.container, ...e2.engine, autoStart: false }), this.events = this.engine.events, this.plugins = new r({ engine: this.engine, events: this.events }), this.installCorePlugins(), this.engine.onUpdate((e3, t2) => {
+      this.onUpdate(e3, t2);
+    }), e2.sceneParams && this.restoreScene(e2.sceneParams), e2.meshListParams && e2.meshListParams.forEach((e3) => {
+      this.setModelFromInfo(e3.rootInfo, e3.group);
+    }), e2.skyParams && (this.setSky(e2.skyParams), this.setGlobalEnvBackground(e2.skyParams)), false !== e2.autoStart && this.engine.start();
+  }
+  static get dracoPath() {
+    return T;
+  }
+  static set dracoPath(e2) {
+    T = e2;
+  }
+  get THREE() {
+    return e;
+  }
+  get gsap() {
+    return t;
+  }
+  get scene() {
+    return this.engine.scene;
+  }
+  get camera() {
+    return this.engine.camera;
+  }
+  get renderer() {
+    return this.engine.renderer;
+  }
+  get viewer() {
+    const e2 = this.plugins.get("orbit-controller"), t2 = this.plugins.get("transform-controller"), s2 = this.plugins.get("composer"), i2 = this.plugins.get("css-renderer"), n2 = this.plugins.get("editor"), r2 = this.plugins.get("loader"), a2 = this.plugins.get("gui");
+    return { scene: this.scene, camera: this.camera, renderer: this.renderer, controls: e2 == null ? void 0 : e2.controls, transformControls: t2 == null ? void 0 : t2.controls, Composer: s2, CSS2DObject: i2 == null ? void 0 : i2.CSS2DObject, CSS3DObject: i2 == null ? void 0 : i2.CSS3DObject, MixerList: this.mixerList, ShaderList: this.shaderList, CommonFrameList: this.commonFrameList, handler: n2, modelControls: r2, currentInfo: n2 == null ? void 0 : n2.currentInfo, GUI: a2 == null ? void 0 : a2.gui, renderSceneResize: () => this.engine.resize(), destroySceneRender: () => this.dispose(), saveSceneEditor: () => this.saveSceneEditor() };
+  }
+  installCorePlugins() {
+    this.plugins.use(new a()), this.plugins.use(new c());
+    const e2 = new h({ dracoPath: _D.dracoPath });
+    this.plugins.use(e2), this.plugins.use(new l()), this.plugins.use(new p()), this.plugins.use(new d()), this.plugins.use(new g({ grid: { enabled: true, size: 100, divisions: 100, colorCenterLine: 4473924, colorGrid: 8947848 }, axes: { enabled: true, size: 5 }, stats: { enabled: false, mode: 0 }, viewHelper: { enabled: false, size: 128, position: "bottom-right" }, box3Helper: { enabled: false, color: 16776960 } }));
+    const t2 = this.config.gui;
+    true !== (t2 == null ? void 0 : t2.useProxy) && this.plugins.use(new f({ autoPlace: (t2 == null ? void 0 : t2.autoPlace) ?? true, width: (t2 == null ? void 0 : t2.width) ?? 300, useProxy: (t2 == null ? void 0 : t2.useProxy) ?? false }));
+  }
+  onUpdate(e2, t2) {
+    this.mixerList.forEach((e3) => {
+      var _a;
+      (_a = e3.mixerRender) == null ? void 0 : _a.call(e3);
+    }), this.shaderList.forEach((e3) => {
+      var _a;
+      (_a = e3.ShaderAnimateRender) == null ? void 0 : _a.call(e3);
+    }), this.commonFrameList.forEach((e3) => {
+      var _a;
+      (_a = e3.frameAnimationRender) == null ? void 0 : _a.call(e3);
+    });
+    const s2 = this.plugins.get("composer");
+    s2 && s2.render();
+  }
+  use(e2) {
+    return this.plugins.use(e2), this;
+  }
+  setModelFromInfo(e2, t2 = null) {
+    const s2 = this.plugins.get("loader");
+    if (!s2) throw new Error("Loader plugin not installed");
+    const i2 = s2.loadModel(e2), n2 = i2.complete;
+    i2.complete = (t3) => {
+      t3.rootInfo = e2, this.scene.add(t3), n2(t3);
+    };
+    const r2 = { loaderService: i2, rootInfo: e2, params: t2 };
+    return this.progressList.push(r2), r2;
+  }
+  setSky(e2) {
+    this.engine.sceneManager.setSkybox(e2);
+  }
+  setGlobalEnvBackground(e2) {
+    this.engine.sceneManager.setEnvironmentMap(e2).then(() => {
+      this.engine.sceneManager.environmentEnabled = true;
+    });
+  }
+  setCss2dDOM(e2, t2) {
+    const s2 = this.plugins.get("css-renderer");
+    if (!s2) throw new Error("CSS Renderer plugin not installed");
+    e2.style.pointerEvents = "auto";
+    return s2.addCSS2D(e2, t2);
+  }
+  setCss3dDOM(e2, t2) {
+    const s2 = this.plugins.get("css-renderer");
+    if (!s2) throw new Error("CSS Renderer plugin not installed");
+    return s2.addCSS3D(e2, t2);
+  }
+  getSceneEvent(e2, t2) {
+    const s2 = this.plugins.get("editor");
+    if (!s2) return;
+    const i2 = s2.handleClick(e2);
+    i2 && t2(i2);
+  }
+  getRawSceneEvent() {
+    const t2 = new e.Raycaster(), s2 = new e.Vector2();
+    return { raycaster: t2, getIntersects: (e2, i2) => {
+      const n2 = this.renderer.domElement.getBoundingClientRect();
+      return s2.x = (e2.clientX - n2.left) / n2.width * 2 - 1, s2.y = -(e2.clientY - n2.top) / n2.height * 2 + 1, t2.setFromCamera(s2, this.camera), t2.intersectObjects(i2, true);
+    } };
+  }
+  setGsapAnimation(e2, s2, i2 = {}) {
+    return t.to(e2, { ...s2, duration: 2, ease: "none", repeat: 0, yoyo: false, yoyoEase: true, ...i2 });
+  }
+  setModelAnimationPlay(t2) {
+    if (!t2.animationPlayParams || !t2.animations) return null;
+    const { speed: s2, actionIndexs: i2, startTime: n2, loop: r2 } = t2.animationPlayParams, a2 = new e.Clock(), o2 = new e.AnimationMixer(t2), c2 = t2.animations.filter((e2, t3) => i2[t3]).map((t3) => {
+      const i3 = o2.clipAction(t3);
+      return i3.loop = r2 ? e.LoopRepeat : e.LoopOnce, i3.time = n2, i3.timeScale = s2, i3.clampWhenFinished = true, i3.play(), i3;
+    });
+    return t2.mixerRender = () => {
+      o2.update(a2.getDelta());
+    }, this.mixerList.push(o2), { mixer: o2, actions: c2 };
+  }
+  removeModelAnimation(e2) {
+    const t2 = this.mixerList.findIndex((t3) => t3 === e2 || t3.mixerRender === e2.mixerRender);
+    t2 > -1 && this.mixerList.splice(t2, 1);
+  }
+  setCurveAnimation(e2, t2 = 1) {
+    const s2 = this.commonFrameList, i2 = { id: Date.now(), curve: e2, time: 0, pause: false, speed: t2, frameCallback: null, frameEndCallback: null, start: function() {
+      s2.includes(this) || s2.push(this), this.pause = false;
+    }, destroy: function() {
+      const e3 = s2.indexOf(this);
+      e3 > -1 && s2.splice(e3, 1);
+    }, frameAnimationRender: () => {
+      var _a, _b;
+      if (i2.pause) return;
+      if (i2.time += i2.speed / 1e3, i2.time > 1 || i2.time < 0) return i2.time = i2.time > 1 ? 1 : 0, i2.pause = true, void ((_a = i2.frameEndCallback) == null ? void 0 : _a.call(i2));
+      const t3 = e2.getPointAt(i2.time);
+      (_b = i2.frameCallback) == null ? void 0 : _b.call(i2, t3);
+    } };
+    return i2;
+  }
+  setOutlinePass(e2 = []) {
+    const t2 = this.plugins.get("composer");
+    t2 && t2.setOutlineObjects(e2);
+  }
+  setSceneControlMode(e2) {
+    const t2 = this.plugins.get("editor");
+    t2 && t2.setMode(e2);
+  }
+  setTransformControlsProperty(e2, t2) {
+    const s2 = this.plugins.get("transform-controller");
+    s2 && s2.controls.hasOwnProperty(e2) && (s2.controls[e2] = t2);
+  }
+  getObjectViews(e2, t2) {
+    return y(e2, t2 ?? this.camera.fov);
+  }
+  getSceneCurveList() {
+    return this.scene.children.filter((e2) => e2.isCurveMesh).map((e2) => {
+      var _a, _b;
+      return { path: e2.curvePath || ((_b = (_a = e2.geometry) == null ? void 0 : _a.parameters) == null ? void 0 : _b.path), mesh: e2 };
+    });
+  }
+  saveSceneEditor() {
+    if (this.config.saveCallback) {
+      const e2 = {}, t2 = [];
+      this.config.saveCallback(e2, t2);
+    }
+  }
+  restoreScene(e2) {
+  }
+  getSceneEditorImage(e2) {
+    return Array.isArray(e2) ? this.engine.screenshot(e2[0], e2[1]) : this.engine.screenshot(e2 == null ? void 0 : e2.type, e2 == null ? void 0 : e2.quality);
+  }
+  refreshGUI() {
+    const e2 = this.plugins.get("gui");
+    e2 && e2.updateDisplay();
+  }
+  setGUIDomPosition(e2) {
+    const t2 = this.plugins.get("gui");
+    if (!t2 || !t2.domElement) return null;
+    const s2 = t2.domElement;
+    return e2.appendChild(s2), { GUIDom: s2, remove: () => {
+      s2.parentElement === e2 && e2.removeChild(s2);
+    } };
+  }
+  setOperateOption(e2, t2) {
+    const s2 = this.plugins.get("editor"), i2 = this.plugins.get("gizmo");
+    switch (e2) {
+      case "stats":
+        i2 && i2.setStatsVisible(t2);
+        break;
+      case "axes":
+        i2 && i2.setAxesVisible(t2);
+        break;
+      case "grid":
+        i2 && i2.setGridVisible(t2);
+        break;
+      case "openKey":
+        s2 && (s2.config.enableKeyboard = t2);
+    }
+  }
+  setSceneFromClassify(e2) {
+    this.scene.children.forEach((e3) => {
+      e3.rootInfo;
+    });
+  }
+  pointSyncTransform(e2, t2) {
+    const s2 = e2.clone();
+    return s2.applyMatrix4(t2.matrixWorld), s2;
+  }
+  meshGroupCloneMaterial(e2) {
+    e2.traverse((e3) => {
+      if (e3.isMesh) {
+        const t2 = e3, s2 = t2;
+        s2.isCloneMaterial || (s2.originMaterial = t2.material, t2.material = Array.isArray(t2.material) ? t2.material.map((e4) => e4.clone()) : t2.material.clone(), s2.isCloneMaterial = true);
+      }
+    });
+  }
+  changeMeshMaterial(e2, t2) {
+    e2.traverse((e3) => {
+      if (e3.isMesh) {
+        const s2 = e3;
+        (Array.isArray(s2.material) ? s2.material : [s2.material]).forEach((e4) => {
+          Object.entries(t2).forEach(([t3, s3]) => {
+            t3 in e4 && ("color" === t3 || "emissive" === t3 ? e4[t3].set(s3) : e4[t3] = s3);
+          }), e4.needsUpdate = true;
+        });
+      }
+    });
+  }
+  changeMeshTransform(e2, t2) {
+    const s2 = e2;
+    if (!s2.meshRevertTransform) {
+      const t3 = e2.position.clone(), i2 = e2.rotation.clone(), n2 = e2.scale.clone();
+      s2.meshRevertTransform = () => {
+        e2.position.copy(t3), e2.rotation.copy(i2), e2.scale.copy(n2);
+      };
+    }
+    t2.position && e2.position.set(t2.position.x ?? e2.position.x, t2.position.y ?? e2.position.y, t2.position.z ?? e2.position.z), t2.rotation && e2.rotation.set(t2.rotation.x ?? e2.rotation.x, t2.rotation.y ?? e2.rotation.y, t2.rotation.z ?? e2.rotation.z), t2.scale && e2.scale.set(t2.scale.x ?? e2.scale.x, t2.scale.y ?? e2.scale.y, t2.scale.z ?? e2.scale.z);
+  }
+  setGsapMeshAction(e2, s2, i2, n2) {
+    const { query: r2 } = n2;
+    s2.position && i2.position && (e2.position.set(s2.position.x, s2.position.y, s2.position.z), t.to(e2.position, { x: i2.position.x, y: i2.position.y, z: i2.position.z, ...r2 })), s2.rotation && i2.rotation && (e2.rotation.set(s2.rotation.x, s2.rotation.y, s2.rotation.z), t.to(e2.rotation, { x: i2.rotation.x, y: i2.rotation.y, z: i2.rotation.z, ...r2 })), s2.scale && i2.scale && (e2.scale.set(s2.scale.x, s2.scale.y, s2.scale.z), t.to(e2.scale, { x: i2.scale.x, y: i2.scale.y, z: i2.scale.z, ...r2 }));
+  }
+  start() {
+    this.engine.start();
+  }
+  stop() {
+    this.engine.stop();
+  }
+  dispose() {
+    this.plugins.dispose(), this.engine.dispose(), this.progressList = [], this.mixerList = [], this.shaderList = [], this.commonFrameList = [];
+  }
+};
+_D.THREE = e;
+_D.gsap = t;
+let D = _D;
+function j(e2) {
+  var _a;
+  (_a = e2.geometry) == null ? void 0 : _a.dispose(), Array.isArray(e2.material) ? e2.material.forEach(B) : e2.material && B(e2.material);
+}
+function B(e2) {
+  e2.dispose();
+  const t2 = e2;
+  t2.map && t2.map.dispose(), t2.lightMap && t2.lightMap.dispose(), t2.bumpMap && t2.bumpMap.dispose(), t2.normalMap && t2.normalMap.dispose(), t2.specularMap && t2.specularMap.dispose(), t2.envMap && t2.envMap.dispose(), t2.alphaMap && t2.alphaMap.dispose(), t2.aoMap && t2.aoMap.dispose(), t2.displacementMap && t2.displacementMap.dispose(), t2.emissiveMap && t2.emissiveMap.dispose(), t2.gradientMap && t2.gradientMap.dispose(), t2.metalnessMap && t2.metalnessMap.dispose(), t2.roughnessMap && t2.roughnessMap.dispose();
+}
+function O(e2) {
+  e2.traverse((e3) => {
+    e3.isMesh && j(e3);
+  });
+}
+function F(t2) {
+  for (t2.traverse((e2) => {
+    e2.isMesh && j(e2);
+  }); t2.children.length > 0; ) t2.remove(t2.children[0]);
+  t2.background instanceof e.Texture && t2.background.dispose(), t2.environment && t2.environment.dispose();
+}
+export {
+  A as AnimationPlugin,
+  p as CSSRendererPlugin,
+  E as CameraManager,
+  l as ComposerPlugin,
+  k as DrawingPlugin,
+  d as EditorPlugin,
+  I as Engine,
+  u as EnvironmentPlugin,
+  b as EventEmitter,
+  f as GUIPlugin,
+  m as GeoMapPlugin,
+  G as GeometryPlugin,
+  g as GizmoPlugin,
+  h as LoaderPlugin,
+  M as MaterialPlugin,
+  a as OrbitControllerPlugin,
+  o as ParticlePlugin,
+  q as PhysicsPlugin,
+  P as Plugin,
+  r as PluginManager,
+  z as RendererManager,
+  w as SceneManager,
+  v as SerializationPlugin,
+  S as ShaderPlugin,
+  s as TextPlugin,
+  D as ThreeEditor,
+  c as TransformControllerPlugin,
+  Z as clamp,
+  a1 as createBox3Helper,
+  V as createRaycaster,
+  X as degToRad,
+  B as disposeMaterial,
+  j as disposeMesh,
+  O as disposeObject,
+  F as disposeScene,
+  n as getBestViewTarget,
+  i as getDistanceScalePoint,
+  a0 as getObjectBox3,
+  y as getObjectViews,
+  W as getPointAtDistance,
+  U as getRootModel,
+  N as getWebGLMouse,
+  Q as getWebGLMouseFromContainer,
+  _ as lerp,
+  Y as radToDeg,
+  R as raycastObjects,
+  $ as smoothstep
+};
+//# sourceMappingURL=index.js.map