@ridp/threejs 1.4.0 → 1.4.2

package/dist/packages/threejs/src/instance/threeIns.js

@@ -0,0 +1,369 @@
+var A = Object.defineProperty;
+var H = (p, e, t) => e in p ? A(p, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : p[e] = t;
+var i = (p, e, t) => H(p, typeof e != "symbol" ? e + "" : e, t);
+import { MathUtils as g, Scene as V, PerspectiveCamera as P, WebGLRenderer as q, Box3 as X, Vector3 as d, Box3Helper as Y } from "three";
+import { CSS3DRenderer as Z } from "../../../../node_modules/.pnpm/three@0.178.0/node_modules/three/examples/jsm/renderers/CSS3DRenderer.js";
+import j from "../../../../node_modules/.pnpm/three@0.178.0/node_modules/three/examples/jsm/libs/stats.module.js";
+import { createOrbitControl as B } from "../utils/helper.js";
+import { disposeThreeObject as _ } from "../utils/disposeObject.js";
+import "../utils/PredictiveLoader.js";
+import { version as N } from "../../package.json.js";
+const W = 50, k = 20, G = 20, C = {
+  TOP: "top",
+  // 俯视（从上往下）
+  RIGHT: "right",
+  // 侧视（从右往左）
+  LEFT: "left",
+  // 左侧视
+  ISO: "iso"
+  // 正斜视（等轴测视角）
+}, U = {
+  enableDamping: !0,
+  dampingFactor: 0.25,
+  screenSpacePanning: !1,
+  minDistance: 0.1,
+  maxDistance: 1e3,
+  maxPolarAngle: g.degToRad(60)
+};
+class $ {
+  /**
+   * 构造函数
+   * @param {string} selector - DOM 容器选择器
+   * @param {Object} option - 配置选项
+   * @param {boolean} [option.css3d=false] - 是否启用 CSS3D 渲染器
+   * @param {boolean} [option.stats=false] - 是否显示性能统计
+   * @param {string} [option.renderType='change'] - 渲染类型: 'loop' 或 'change'
+   * @param {boolean} [option.initListener=true] - 是否初始化事件监听器
+   * @param {number} [option.initialFov=50] - 初始相机 FOV 值
+   * @param {Object} [option.control] - 控制器配置
+   * @param {boolean} [option.control.init=true] - 是否初始化控制器
+   * @param {Object} [option.control.options={}] - 控制器选项
+   */
+  constructor(e, t) {
+    i(this, "isReady", !1);
+    i(this, "scene", null);
+    i(this, "camera", null);
+    i(this, "renderer", null);
+    i(this, "control", null);
+    i(this, "css3dRenderer", null);
+    i(this, "el", null);
+    i(this, "renderRequested", !1);
+    i(this, "selector", null);
+    i(this, "eventsListener", {});
+    i(this, "stats", null);
+    i(this, "isDispose", !1);
+    i(this, "version", "0.0.0");
+    i(this, "boxHelper", null);
+    i(this, "initOpt", {
+      css3d: !1,
+      stats: !1,
+      renderType: "change",
+      initListener: !0,
+      // 使用布尔值代替字符串
+      initialFov: 50,
+      // 初始 FOV 值，用于避免全屏切换时的累积误差
+      control: {
+        init: !0,
+        options: {}
+      }
+    });
+    /**
+     * 初始化场景
+     * @param {string} selector - DOM 容器选择器
+     */
+    i(this, "setup", (e) => {
+      if (this.isDispose = !1, this.selector = e, this.el = document.querySelector(e), !this.el) {
+        console.error(`ThreeIns: 找不到元素 ${e}`);
+        return;
+      }
+      const [t, l] = this.getTargetSize();
+      if (this.updateCameraFOV(t, l), this.camera.position.set(0, 0, 0), this.camera.lookAt(0, 0, 0), this.camera.updateProjectionMatrix(), this.renderer.setPixelRatio(window.devicePixelRatio), this.renderer.setSize(t, l), this.el.appendChild(this.renderer.domElement), this.initOpt.control && this.initOpt.control.init) {
+        this.control = B(this.camera, this.renderer.domElement);
+        const s = Object.assign(
+          U,
+          this.initOpt.control.options || {}
+        );
+        Object.keys(s).forEach((x) => {
+          this.control[x] = s[x];
+        });
+      }
+      setTimeout(() => {
+        this.isReady = !0;
+      }, k), this.initOpt.stats && this.initStats(), this.initOpt.css3d && this.initCss3dRenderer(), this.initOpt.renderType === "loop" ? this.animate() : this.initOpt.renderType === "change" && this.control && this.control.addEventListener(
+        "change",
+        this.requestRenderIfNotRequested
+      ), this.initListener();
+    });
+    /**
+     * WebGL 上下文丢失处理
+     * @param {Event} e - 事件对象
+     */
+    i(this, "onContextLost", (e) => {
+      e.preventDefault(), this.animationFrameId && cancelAnimationFrame(this.animationFrameId);
+    });
+    /**
+     * WebGL 上下文恢复处理
+     * @param {Event} e - 事件对象
+     */
+    i(this, "onContextRestored", (e) => {
+      e.preventDefault(), this.dispose(), setTimeout(() => {
+        this.setup(this.selector);
+      }, G);
+    });
+    /**
+     * 初始化事件监听器
+     */
+    i(this, "initListener", () => {
+      this.initOpt.initListener && window && window.addEventListener("resize", this.onResize, !1), this.renderer.domElement.addEventListener(
+        "webglcontextlost",
+        this.onContextLost,
+        !1
+      ), this.renderer.domElement.addEventListener(
+        "webglcontextrestored",
+        this.onContextRestored,
+        !1
+      );
+    });
+    /**
+     * 移除事件监听器
+     */
+    i(this, "removeListener", () => {
+      window && window.removeEventListener("resize", this.onResize, !1), this.renderer && this.renderer.domElement && (this.renderer.domElement.removeEventListener(
+        "webglcontextlost",
+        this.onContextLost,
+        !1
+      ), this.renderer.domElement.removeEventListener(
+        "webglcontextrestored",
+        this.onContextRestored,
+        !1
+      ));
+    });
+    /**
+     * 渲染循环（loop 模式）
+     */
+    i(this, "animate", () => {
+      this.isDispose || (this.initOpt.renderType === "loop" && this.onRender(), this.animationFrameId = requestAnimationFrame(this.animate));
+    });
+    /**
+     * 执行渲染
+     */
+    i(this, "onRender", () => {
+      this.isDispose || (this.renderRequested = !1, this.stats && this.stats.update(), this.control && this.control.update(), this.renderer.render(this.scene, this.camera), this.css3dRenderer && this.css3dRenderer.render(this.scene, this.camera), this.eventsListener.onRender && this.eventsListener.onRender.length && this.eventsListener.onRender.forEach((e) => e()));
+    });
+    /**
+     * 请求渲染（如果尚未请求）
+     */
+    i(this, "requestRenderIfNotRequested", () => {
+      this.renderRequested || (this.renderRequested = !0, requestAnimationFrame(() => {
+        this.onRender();
+      }));
+    });
+    /**
+     * 处理窗口大小变化（带防抖）
+     */
+    i(this, "onResize", () => {
+      this.resizeTimer && clearTimeout(this.resizeTimer), this.resizeTimer = setTimeout(() => {
+        const [e, t] = this.getTargetSize();
+        this.updateCameraFOV(e, t), this.camera.lookAt(this.scene.position), this.renderer.setSize(e, t), this.css3dRenderer && this.css3dRenderer.setSize(e, t), this.onRender();
+      }, W);
+    });
+    /**
+     * @deprecated 此方法已弃用，请使用 setView() 方法代替
+     *
+     * frameArea 仅为兼容旧版本保留，功能已被 setView() 完全覆盖
+     *
+     * 旧用法:
+     *   threeIns.frameArea(model, 1.0)
+     *
+     * 推荐用法:
+     *   threeIns.setView(model, ViewType.ISO, { scale: 1.0 })
+     *
+     * @param {Object3D} model - 要调整视角的 3D 模型对象
+     * @param {number} [scale=0.8] - 缩放比例，1=占满画布，0.5=50%，2.0=200%
+     * @returns {Object} 返回 setView 的结果
+     */
+    i(this, "frameArea", (e, t) => (console.warn(
+      `[ThreeIns] frameArea() 已弃用，建议使用 setView() 方法。
+旧用法: threeIns.frameArea(model, scale)
+新用法: threeIns.setView(model, ViewType.ISO, { scale })`
+    ), this.setView(e, C.ISO, { scale: t, animate: !1, showBox: !1 })));
+    /**
+     * 切换到指定视角
+     * 根据视角类型自动调整相机位置和朝向，支持缩放比例控制
+     *
+     * @param {Object3D} model - 3D 物体对象
+     * @param {string} viewType - 视角类型，使用 ViewType 枚举
+     *                          - 'top': 俯视（从上往下看 Y 轴正方向）
+     *                          - 'right': 侧视（从右往左看 X 轴正方向）
+     *                          - 'left': 左侧视（从左往右看 X 轴负方向）
+     *                          - 'iso': 正斜视（等轴测视角，45°角）
+     * @param {Object} [options] - 可选配置
+     * @param {number} [options.scale=1] - 缩放比例，控制模型在画布中的占比
+     * @param {Vector3} [options.offset] - 偏移量，调整观察中心点
+     * @param {boolean} [options.showBox=false] - 是否显示包围盒辅助线
+     * @param {number} [options.boxColor=0xffff00] - 包围盒颜色
+     * @param {boolean} [options.animate=true] - 是否使用动画过渡
+     * @param {number} [options.duration=1000] - 动画持续时间（毫秒）
+     * @returns {Object} 返回相机位置和模型信息
+     * @returns {Vector3} return.position - 相机位置
+     * @returns {Vector3} return.target - 相机观察目标点
+     * @returns {number} return.distance - 相机到模型的距离
+     *
+     * @example
+     * // 导入 ViewType 枚举
+     * import { ThreeIns, ViewType } from 'threejs';
+     *
+     * // 切换到俯视，模型占满画布
+     * threeIns.setView(model, ViewType.TOP);
+     *
+     * // 切换到等轴测，模型占画布的 80%
+     * threeIns.setView(model, ViewType.ISO, { scale: 0.8 });
+     *
+     * // 切换到斜视，显示包围盒，无动画
+     * threeIns.setView(model, ViewType.ISO, {
+     *   showBox: true,
+     *   animate: false
+     * });
+     *
+     * // 切换到侧视，自定义观察点
+     * threeIns.setView(model, ViewType.RIGHT, {
+     *   offset: new THREE.Vector3(0, 10, 0),
+     *   scale: 0.8
+     * });
+     *
+     * // 或者使用类静态属性（向后兼容）
+     * threeIns.setView(model, ThreeIns.ViewType.TOP);
+     */
+    i(this, "setView", (e, t, l = {}) => {
+      let s = l.scale || 0.8, x = l.offset || null, R = l.showBox || !1, y = l.boxColor || 16776960, z = l.animate !== void 0 ? l.animate : !0, M = l.duration || 1e3;
+      const F = new X().setFromObject(e);
+      let h = F.getCenter(new d());
+      x && h.add(x);
+      const T = {
+        top: new d(0, 1, 0),
+        // 从上往下：Y 轴正方向
+        right: new d(2, 1, 1).normalize(),
+        // 从右往左：X 轴正方向
+        left: new d(-2, 1, 1).normalize(),
+        // 从左往右：X 轴负方向
+        iso: new d(0, 1, 1).normalize()
+        // 等轴测：从对角线上方俯视
+      }, E = T[t] || T.iso, o = F.getSize(new d()), L = this.camera.aspect, n = g.degToRad(this.camera.fov * 0.5), S = g.degToRad(80), c = Math.min(Math.atan(Math.tan(n) * L), S);
+      let m;
+      if (t === "top") {
+        const r = o.x * 0.5 / (Math.tan(c) * s), a = o.z * 0.5 / (Math.tan(n) * s);
+        m = Math.max(r, a);
+      } else if (t === "right" || t === "left") {
+        const r = o.y * 0.5 / (Math.tan(n) * s), a = o.z * 0.5 / (Math.tan(n) * s);
+        m = Math.max(r, a);
+      } else {
+        const r = o.x * 0.5 / (Math.tan(c) * s), a = o.y * 0.5 / (Math.tan(n) * s), u = o.z * 0.5 / (Math.tan(n) * s);
+        m = Math.max(r, a, u);
+      }
+      const f = E.clone().multiplyScalar(m).add(h);
+      if (R && (console.log("📍 相机位置验证:"), console.log("  - 方向向量:", E), console.log("  - 距离:", m.toFixed(2)), console.log("  - 包围盒中心:", h), console.log("  - 计算公式: direction * distance + boxCenter"), console.log("  - 目标位置:", f), console.log("  - 实际相机与中心的距离:", f.clone().sub(h).length().toFixed(2))), R ? (this.boxHelper && (this.scene.remove(this.boxHelper), this.boxHelper = null), this.boxHelper = new Y(F, y), this.scene.add(this.boxHelper)) : this.boxHelper && (this.scene.remove(this.boxHelper), this.boxHelper = null), z) {
+        const r = this.camera.position.clone(), a = this.control ? this.control.target.clone() : new d(0, 0, 0), u = h, D = Date.now(), v = () => {
+          const I = Date.now() - D, b = Math.min(I / M, 1), O = 1 - Math.pow(1 - b, 3);
+          if (this.camera.position.lerpVectors(r, f, O), this.control) {
+            const w = new d();
+            w.lerpVectors(a, u, O), this.control.target.copy(w), this.camera.lookAt(w);
+          } else
+            this.camera.lookAt(h);
+          this.camera.updateProjectionMatrix(), b < 1 ? requestAnimationFrame(v) : (this.camera.position.copy(f), this.camera.lookAt(h), this.camera.updateProjectionMatrix(), this.control && (this.control.target.copy(h), this.control.update()), this.onRender());
+        };
+        v();
+      } else
+        this.camera.position.copy(f), this.camera.lookAt(h), this.camera.updateProjectionMatrix(), this.control && (this.control.target.copy(h), this.control.update()), this.onRender();
+      if (R) {
+        if (console.log("🎥 视角切换信息:"), console.log("  - 视角类型:", t), console.log("  - 相机位置:", f), console.log("  - 观察目标:", h), console.log("  - 方向向量:", E), console.log("  - 包围盒尺寸:", o), console.log("  - 包围盒中心:", F.getCenter(new d())), console.log("  - 水平 FOV:", g.radToDeg(c * 2).toFixed(2) + "°"), console.log("  - 垂直 FOV:", g.radToDeg(n * 2).toFixed(2) + "°"), console.log("  - 宽高比:", L.toFixed(4)), console.log("  - 模型宽度:", o.x.toFixed(2)), console.log("  - 模型高度:", o.y.toFixed(2)), console.log("  - 模型深度:", o.z.toFixed(2)), console.log("  - 传入的 scale 参数:", s), t === "top") {
+          const r = o.x * 0.5 / (Math.tan(c) * s), a = o.z * 0.5 / (Math.tan(n) * s);
+          console.log("  - 模型 X 尺寸 (宽度):", o.x.toFixed(2)), console.log("  - 模型 Z 尺寸 (深度):", o.z.toFixed(2)), console.log("  - tan(halfFovX):", Math.tan(c).toFixed(4)), console.log("  - tan(halfFovY):", Math.tan(n).toFixed(4)), console.log("  - X方向距离计算: (", (o.x * 0.5).toFixed(2), ") / (", Math.tan(c).toFixed(4), " *", s, ") =", r.toFixed(2)), console.log("  - Z方向距离计算: (", (o.z * 0.5).toFixed(2), ") / (", Math.tan(n).toFixed(4), " *", s, ") =", a.toFixed(2)), console.log("  - X方向距离 (scale=" + s + "):", r.toFixed(2)), console.log("  - Z方向距离 (scale=" + s + "):", a.toFixed(2));
+        } else if (t === "right" || t === "left") {
+          const r = o.y * 0.5 / (Math.tan(n) * s), a = o.z * 0.5 / (Math.tan(n) * s);
+          console.log("  - Y方向距离 (scale=" + s + "):", r.toFixed(2)), console.log("  - Z方向距离 (scale=" + s + "):", a.toFixed(2));
+        } else {
+          const r = o.x * 0.5 / (Math.tan(c) * s), a = o.y * 0.5 / (Math.tan(n) * s), u = o.z * 0.5 / (Math.tan(n) * s);
+          console.log("  - 模型 X 尺寸 (宽度):", o.x.toFixed(2)), console.log("  - 模型 Y 尺寸 (高度):", o.y.toFixed(2)), console.log("  - 模型 Z 尺寸 (深度):", o.z.toFixed(2)), console.log("  - tan(halfFovX):", Math.tan(c).toFixed(4)), console.log("  - tan(halfFovY):", Math.tan(n).toFixed(4)), console.log("  - X方向距离计算: (", (o.x * 0.5).toFixed(2), ") / (", Math.tan(c).toFixed(4), " *", s, ") =", r.toFixed(2)), console.log("  - Y方向距离计算: (", (o.y * 0.5).toFixed(2), ") / (", Math.tan(n).toFixed(4), " *", s, ") =", a.toFixed(2)), console.log("  - Z方向距离计算: (", (o.z * 0.5).toFixed(2), ") / (", Math.tan(n).toFixed(4), " *", s, ") =", u.toFixed(2)), console.log("  - X方向距离 (scale=" + s + "):", r.toFixed(2)), console.log("  - Y方向距离 (scale=" + s + "):", a.toFixed(2)), console.log("  - Z方向距离 (scale=" + s + "):", u.toFixed(2)), console.log("  - 最大距离 (Max):", Math.max(r, a, u).toFixed(2));
+        }
+        console.log("  - 最终距离:", m.toFixed(2)), console.log("  - 缩放比例:", s), console.log("  - 动画:", z ? "是 (" + M + "ms)" : "否");
+      }
+      return {
+        position: f,
+        target: h,
+        distance: m,
+        viewType: t
+      };
+    });
+    /**
+     * 注册事件监听器
+     * @param {string} event - 事件名称
+     * @param {Function} callback - 回调函数
+     * @returns {Function} 返回取消监听的函数
+     */
+    i(this, "on", (e, t) => !e || !t || typeof t != "function" ? (console.warn("ThreeIns.on: 无效的参数"), () => {
+    }) : (this.eventsListener[e] || (this.eventsListener[e] = []), this.eventsListener[e].push(t), () => this.off(e, t)));
+    this.isReady = !1, this.scene = new V({}), this.camera = new P(50, 1, 0.1, 2e3), this.renderer = new q({
+      antialias: !0,
+      alpha: !0,
+      precision: "mediump",
+      logarithmicDepthBuffer: !0
+    }), this.version = N, this.onContextLost = this.onContextLost.bind(this), this.onContextRestored = this.onContextRestored.bind(this), this.onResize = this.onResize.bind(this), this.animate = this.animate.bind(this), this.resizeTimer = null, this.animationFrameId = null, t && (this.initOpt = Object.assign(this.initOpt, t)), e && this.setup(e);
+  }
+  /**
+   * 更新相机 FOV 以适应容器尺寸
+   * @private
+   * @param {number} domW - 容器宽度
+   * @param {number} domH - 容器高度
+   */
+  updateCameraFOV(e, t) {
+    const l = this.initOpt.initialFov || 50, s = Math.tan(Math.PI / 180 * l / 2);
+    this.camera.aspect = e / t, this.camera.fov = 360 / Math.PI * Math.atan(s * (t / e)), this.camera.updateProjectionMatrix();
+  }
+  /**
+   * 初始化性能统计
+   */
+  initStats() {
+    this.stats = new j(), this.stats.dom.style.cssText = "position:absolute;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", this.el.appendChild(this.stats.dom);
+  }
+  /**
+   * 初始化 CSS3D 渲染器
+   */
+  initCss3dRenderer() {
+    this.css3dRenderer = new Z();
+    const [e, t] = this.getTargetSize();
+    this.css3dRenderer.setSize(e, t), this.css3dRenderer.domElement.style.position = "absolute", this.css3dRenderer.domElement.style.pointerEvents = "none", this.css3dRenderer.domElement.style.top = 0, this.css3dRenderer.domElement.style.left = 0, this.el.appendChild(this.css3dRenderer.domElement);
+  }
+  /**
+   * 获取目标容器尺寸
+   * 使用智能缓存策略：全屏时使用窗口尺寸，非全屏时使用元素尺寸
+   * @returns {[number, number]} [width, height]
+   */
+  getTargetSize() {
+    return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement ? [window.innerWidth, window.innerHeight] : this.el ? !document.body.contains(this.el) && (console.warn(`ThreeIns: 缓存的元素已失效，重新查询 ${this.selector}`), this.el = document.querySelector(this.selector), !this.el) ? [0, 0] : [this.el.clientWidth, this.el.clientHeight] : [0, 0];
+  }
+  /**
+   * 移除事件监听器
+   * @param {string} event - 事件名称
+   * @param {Function} [callback] - 可选的回调函数，如果不提供则移除该事件的所有监听器
+   */
+  off(e, t) {
+    if (!e) {
+      this.eventsListener = {};
+      return;
+    }
+    this.eventsListener[e] && (t ? this.eventsListener[e] = this.eventsListener[e].filter((l) => l !== t) : this.eventsListener[e] = []);
+  }
+  /**
+   * 清理所有资源
+   */
+  dispose() {
+    this.isDispose || (this.isDispose = !0, this.animationFrameId && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = null), this.resizeTimer && (clearTimeout(this.resizeTimer), this.resizeTimer = null), this.removeListener(), this.eventsListener = {}, this.stats && this.stats.dom && (this.stats.dom.remove(), this.stats = null), this.css3dRenderer && (this.css3dRenderer.domElement.remove(), this.css3dRenderer = null), this.boxHelper && (this.scene.remove(this.boxHelper), this.boxHelper = null), this.scene && (_(this.scene), this.scene = null), this.renderer && (this.renderer.dispose(), this.renderer.domElement && this.renderer.domElement.remove(), this.renderer = null), this.control && (this.control.dispose(), this.control = null), this.camera = null, this.el = null, this.selector = null, console.log("ThreeIns: 资源已清理完成"));
+  }
+}
+// 存储包围盒辅助器
+// 视角类型枚举（作为类静态属性引用，保持向后兼容）
+i($, "ViewType", C);
+export {
+  $ as ThreeIns,
+  C as ViewType
+};

package/dist/packages/threejs/src/utils/CacheMonitor.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class e{constructor(){this.stats={hits:0,misses:0,totalLoadTime:0,cacheSaveTime:0,errors:0},this.loadHistory=[]}recordHit(t){this.stats.hits++,this.stats.totalLoadTime+=t,this._recordHistory("hit",t)}recordMiss(t){this.stats.misses++,this.stats.totalLoadTime+=t,this._recordHistory("miss",t)}recordCacheSave(t){this.stats.cacheSaveTime+=t}recordError(t,s){this.stats.errors++,this._recordHistory("error",0,{path:t,error:s.message})}getHitRate(){const t=this.stats.hits+this.stats.misses;return t>0?(this.stats.hits/t*100).toFixed(2)+"%":"0%"}getAvgLoadTime(){const t=this.stats.hits+this.stats.misses;return t>0?(this.stats.totalLoadTime/t).toFixed(2)+"ms":"0ms"}getStats(){const t=this.stats.hits+this.stats.misses;return{命中率:this.getHitRate(),平均加载时间:this.getAvgLoadTime(),缓存命中数:this.stats.hits,缓存未命中数:this.stats.misses,总加载次数:t,总加载时间:this.stats.totalLoadTime.toFixed(2)+"ms",缓存保存时间:this.stats.cacheSaveTime.toFixed(2)+"ms",错误次数:this.stats.errors}}getHistory(t=10){return this.loadHistory.slice(-t)}reset(){this.stats={hits:0,misses:0,totalLoadTime:0,cacheSaveTime:0,errors:0},this.loadHistory=[]}_recordHistory(t,s,i={}){this.loadHistory.push({type:t,duration:s,timestamp:Date.now(),...i}),this.loadHistory.length>100&&this.loadHistory.shift()}logReport(){console.group("📊 缓存性能报告");const t=this.getStats();Object.entries(t).forEach(([s,i])=>{console.log(`${s}: ${i}`)}),console.groupEnd()}}const o=new e;exports.CacheMonitor=e;exports.cacheMonitor=o;

package/dist/packages/threejs/src/utils/CacheMonitor.js

@@ -0,0 +1,125 @@
+class e {
+  constructor() {
+    this.stats = {
+      hits: 0,
+      // 缓存命中次数
+      misses: 0,
+      // 缓存未命中次数
+      totalLoadTime: 0,
+      // 总加载时间(ms)
+      cacheSaveTime: 0,
+      // 缓存保存时间(ms)
+      errors: 0
+      // 错误次数
+    }, this.loadHistory = [];
+  }
+  /**
+   * 记录缓存命中
+   * @param {number} loadTime - 加载耗时(ms)
+   */
+  recordHit(t) {
+    this.stats.hits++, this.stats.totalLoadTime += t, this._recordHistory("hit", t);
+  }
+  /**
+   * 记录缓存未命中
+   * @param {number} loadTime - 加载耗时(ms)
+   */
+  recordMiss(t) {
+    this.stats.misses++, this.stats.totalLoadTime += t, this._recordHistory("miss", t);
+  }
+  /**
+   * 记录缓存保存时间
+   * @param {number} saveTime - 保存耗时(ms)
+   */
+  recordCacheSave(t) {
+    this.stats.cacheSaveTime += t;
+  }
+  /**
+   * 记录错误
+   * @param {string} path - 模型路径
+   * @param {Error} error - 错误对象
+   */
+  recordError(t, s) {
+    this.stats.errors++, this._recordHistory("error", 0, { path: t, error: s.message });
+  }
+  /**
+   * 计算缓存命中率
+   * @returns {string} 命中率百分比字符串
+   */
+  getHitRate() {
+    const t = this.stats.hits + this.stats.misses;
+    return t > 0 ? (this.stats.hits / t * 100).toFixed(2) + "%" : "0%";
+  }
+  /**
+   * 计算平均加载时间
+   * @returns {string} 平均加载时间(含单位)
+   */
+  getAvgLoadTime() {
+    const t = this.stats.hits + this.stats.misses;
+    return t > 0 ? (this.stats.totalLoadTime / t).toFixed(2) + "ms" : "0ms";
+  }
+  /**
+   * 获取完整的统计数据
+   * @returns {Object} 统计数据对象
+   */
+  getStats() {
+    const t = this.stats.hits + this.stats.misses;
+    return {
+      命中率: this.getHitRate(),
+      平均加载时间: this.getAvgLoadTime(),
+      缓存命中数: this.stats.hits,
+      缓存未命中数: this.stats.misses,
+      总加载次数: t,
+      总加载时间: this.stats.totalLoadTime.toFixed(2) + "ms",
+      缓存保存时间: this.stats.cacheSaveTime.toFixed(2) + "ms",
+      错误次数: this.stats.errors
+    };
+  }
+  /**
+   * 获取最近N条加载历史
+   * @param {number} count - 获取条数,默认 10
+   * @returns {Array} 历史记录数组
+   */
+  getHistory(t = 10) {
+    return this.loadHistory.slice(-t);
+  }
+  /**
+   * 清空统计数据
+   */
+  reset() {
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      totalLoadTime: 0,
+      cacheSaveTime: 0,
+      errors: 0
+    }, this.loadHistory = [];
+  }
+  /**
+   * 内部方法: 记录历史
+   * @private
+   */
+  _recordHistory(t, s, i = {}) {
+    this.loadHistory.push({
+      type: t,
+      duration: s,
+      timestamp: Date.now(),
+      ...i
+    }), this.loadHistory.length > 100 && this.loadHistory.shift();
+  }
+  /**
+   * 打印统计报告到控制台
+   */
+  logReport() {
+    console.group("📊 缓存性能报告");
+    const t = this.getStats();
+    Object.entries(t).forEach(([s, i]) => {
+      console.log(`${s}: ${i}`);
+    }), console.groupEnd();
+  }
+}
+const r = new e();
+export {
+  e as CacheMonitor,
+  r as cacheMonitor
+};

package/dist/packages/threejs/src/utils/ImageLoader.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("three"),d=require("../../../../node_modules/.pnpm/three@0.178.0/node_modules/three/examples/jsm/loaders/EXRLoader.cjs"),u=require("../../../../node_modules/.pnpm/three@0.178.0/node_modules/three/examples/jsm/loaders/RGBELoader.cjs"),i={};async function l(r,n){if(!n)return;if(i[n]){const e=i[n];r.environment=e;return}let o=t(n);return new Promise((e,a)=>{o.load(n,e,void 0,a)}).then(e=>{e.mapping=c.EquirectangularReflectionMapping,r.environment=e,i[n]=e}).catch(e=>{console.log("  =====> e:",e)})}async function s(r){let n=t(r);return new Promise((o,e)=>{n.load(r,o,void 0,e)})}function t(r){return r.split(".").pop()==="exr"?new d.EXRLoader:new u.RGBELoader}exports.ImageLoader=s;exports.initEnvImage=l;

package/dist/packages/threejs/src/utils/ImageLoader.js

@@ -0,0 +1,33 @@
+import { EquirectangularReflectionMapping as c } from "three";
+import { EXRLoader as d } from "../../../../node_modules/.pnpm/three@0.178.0/node_modules/three/examples/jsm/loaders/EXRLoader.js";
+import { RGBELoader as m } from "../../../../node_modules/.pnpm/three@0.178.0/node_modules/three/examples/jsm/loaders/RGBELoader.js";
+const i = {};
+async function s(o, n) {
+  if (!n) return;
+  if (i[n]) {
+    const e = i[n];
+    o.environment = e;
+    return;
+  }
+  let r = t(n);
+  return new Promise((e, a) => {
+    r.load(n, e, void 0, a);
+  }).then((e) => {
+    e.mapping = c, o.environment = e, i[n] = e;
+  }).catch((e) => {
+    console.log("  =====> e:", e);
+  });
+}
+async function g(o) {
+  let n = t(o);
+  return new Promise((r, e) => {
+    n.load(o, r, void 0, e);
+  });
+}
+function t(o) {
+  return o.split(".").pop() === "exr" ? new d() : new m();
+}
+export {
+  g as ImageLoader,
+  s as initEnvImage
+};

package/dist/packages/threejs/src/utils/PredictiveLoader.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("../hooks/useGLTFLoader.cjs");class c{constructor(e={}){this.options={maxPreloadCount:e.maxPreloadCount||5,preloadDelay:e.preloadDelay||1e3,enableLearning:e.enableLearning!==!1},this.loadHistory=new Map,this.loadSequence=[],this.associations=new Map,this.preloadQueue=new Set,this.isPreloading=!1,this.loader=null,this.getLoader=()=>(this.loader||(this.loader=d.useGLTFLoader()),this.loader)}recordLoad(e,s){const t=Date.now(),o=this.loadHistory.get(e)||{count:0,lastLoadTime:0,versions:new Set};o.count++,o.lastLoadTime=t,o.versions.add(s),this.loadHistory.set(e,o),this.loadSequence.push({path:e,timestamp:t}),this.loadSequence.length>100&&this.loadSequence.shift(),this.options.enableLearning&&this.loadSequence.length>=2&&this._learnAssociations(e),this._triggerPredictivePreload(e,s)}_learnAssociations(e){const t=this.loadSequence.length-1;for(let o=Math.max(0,t-10);o<t;o++){const{path:a}=this.loadSequence[o];if(this.loadSequence[t].timestamp-this.loadSequence[o].timestamp<5*60*1e3&&a!==e){this.associations.has(a)||this.associations.set(a,new Map);const i=this.associations.get(a),n=i.get(e)||0;i.set(e,n+1)}}}_triggerPredictivePreload(e,s){setTimeout(()=>{const t=this.predictNext(e);this.preload(t,s)},this.options.preloadDelay)}predictNext(e){const s=new Map,t=this.associations.get(e);t&&t.forEach((i,n)=>{s.set(n,(s.get(n)||0)+i*2)});const o=Array.from(this.loadHistory.values()).reduce((i,n)=>i+n.count,0)/(this.loadHistory.size||1);this.loadHistory.forEach((i,n)=>{if(n!==e){const l=i.count/o;s.set(n,(s.get(n)||0)+l)}});const a=this.loadSequence.slice(-10);return new Set(a.map(i=>i.path)).forEach(i=>{i!==e&&s.set(i,(s.get(i)||0)+.5)}),Array.from(s.entries()).sort((i,n)=>n[1]-i[1]).slice(0,this.options.maxPreloadCount).map(([i])=>i)}async preload(e,s="latest"){if(this.isPreloading)return;this.isPreloading=!0;const{asyncFetch:t}=this.getLoader(),o=e.filter(a=>!this.preloadQueue.has(a)).slice(0,this.options.maxPreloadCount).map(async a=>{this.preloadQueue.add(a);try{console.log(`[ 智能预加载 ] 开始预加载: ${a}`),await t(a,s),console.log(`[ 智能预加载 ] 完成: ${a}`)}catch(r){console.warn(`[ 智能预加载 ] 失败: ${a}`,r)}finally{this.preloadQueue.delete(a)}});await Promise.all(o),this.isPreloading=!1}addAssociation(e,s){this.associations.has(e)||this.associations.set(e,new Map);const t=this.associations.get(e);s.forEach(o=>{const a=t.get(o)||0;t.set(o,a+10)})}getStats(){const e=Array.from(this.loadHistory.entries()).sort((s,t)=>t[1].count-s[1].count).slice(0,10).map(([s,t])=>({path:s,loadCount:t.count,lastLoadTime:new Date(t.lastLoadTime).toLocaleString()}));return{totalModelsLoaded:this.loadHistory.size,totalAssociations:this.associations.size,topModels:e,preloadQueueSize:this.preloadQueue.size}}clearHistory(){this.loadHistory.clear(),this.loadSequence=[],this.associations.clear()}exportAssociations(){const e={};return this.associations.forEach((s,t)=>{e[t]=Array.from(s.entries())}),e}importAssociations(e){Object.entries(e).forEach(([s,t])=>{const o=new Map(t);this.associations.set(s,o)})}}const h=new c;exports.PredictiveLoader=c;exports.predictiveLoader=h;