gltf-parser-plugin 1.1.2 → 1.1.4

package/build/gltf-parser-plugin.module.js

@@ -1,4 +1,4 @@
-import { Mesh, Vector3, Triangle, BufferGeometry, EventDispatcher, DataTexture, RGBAFormat, UnsignedByteType, SRGBColorSpace, Texture, MeshStandardMaterial, DoubleSide, FrontSide, BufferAttribute, OrthographicCamera, Float32BufferAttribute, Vector2, WebGLRenderer, WebGLRenderTarget, ShaderMaterial, OneFactor, ZeroFactor, CustomBlending, Box2, Matrix4, Matrix3, Matrix2, Vector4, MeshBasicMaterial, Loader, Scene, Group, InstancedMesh, Quaternion, Box3 } from "three";
+import { Mesh, Vector3, Triangle, BufferGeometry, EventDispatcher, DataTexture, RGBAFormat, UnsignedByteType, SRGBColorSpace, Texture, MeshStandardMaterial, DoubleSide, FrontSide, BufferAttribute, Box3, Vector2, OrthographicCamera, Float32BufferAttribute, WebGLRenderer, WebGLRenderTarget, ShaderMaterial, OneFactor, ZeroFactor, CustomBlending, Box2, Matrix4, Matrix3, Matrix2, Vector4, MeshBasicMaterial, Loader, Scene, Group, InstancedMesh, Quaternion, Color } from "three";
 class FeatureIdUniforms {
   mesh;
   plugin;
@@ -554,6 +554,114 @@ function acquireWorker() {
   currentWorkerIndex = (currentWorkerIndex + 1) % workerPool.length;
   return worker;
 }
+function pointInPolygon(px, py, polygon) {
+  let inside = false;
+  const n = polygon.length;
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const xi = polygon[i].x, yi = polygon[i].y;
+    const xj = polygon[j].x, yj = polygon[j].y;
+    if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function segmentsIntersect(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {
+  const cross = (ox, oy, ax, ay, bx, by) => (ax - ox) * (by - oy) - (ay - oy) * (bx - ox);
+  const d1 = cross(bx1, by1, bx2, by2, ax1, ay1);
+  const d2 = cross(bx1, by1, bx2, by2, ax2, ay2);
+  const d3 = cross(ax1, ay1, ax2, ay2, bx1, by1);
+  const d4 = cross(ax1, ay1, ax2, ay2, bx2, by2);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    return true;
+  }
+  const onSeg = (px, py, qx, qy, rx, ry) => Math.min(px, qx) <= rx && rx <= Math.max(px, qx) && Math.min(py, qy) <= ry && ry <= Math.max(py, qy);
+  if (d1 === 0 && onSeg(bx1, by1, bx2, by2, ax1, ay1)) return true;
+  if (d2 === 0 && onSeg(bx1, by1, bx2, by2, ax2, ay2)) return true;
+  if (d3 === 0 && onSeg(ax1, ay1, ax2, ay2, bx1, by1)) return true;
+  if (d4 === 0 && onSeg(ax1, ay1, ax2, ay2, bx2, by2)) return true;
+  return false;
+}
+function polygonIntersectsRect(polygon, minX, minY, maxX, maxY) {
+  const n = polygon.length;
+  for (let i = 0; i < n; i++) {
+    const p = polygon[i];
+    if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
+      return true;
+    }
+  }
+  if (pointInPolygon(minX, minY, polygon) || pointInPolygon(maxX, minY, polygon) || pointInPolygon(maxX, maxY, polygon) || pointInPolygon(minX, maxY, polygon)) {
+    return true;
+  }
+  const rx = [minX, maxX, maxX, minX];
+  const ry = [minY, minY, maxY, maxY];
+  for (let i = 0; i < n; i++) {
+    const a = polygon[i];
+    const b = polygon[(i + 1) % n];
+    for (let j = 0; j < 4; j++) {
+      const k = (j + 1) % 4;
+      if (segmentsIntersect(a.x, a.y, b.x, b.y, rx[j], ry[j], rx[k], ry[k])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function selectByBoxFromOidMap(oidNodeMap, box) {
+  const result = [];
+  const nodeBox = new Box3();
+  for (const [oid, node] of oidNodeMap) {
+    if (!node.bbox || node.bbox.length < 6) continue;
+    nodeBox.min.set(node.bbox[0], node.bbox[1], node.bbox[2]);
+    nodeBox.max.set(node.bbox[3], node.bbox[4], node.bbox[5]);
+    if (box.intersectsBox(nodeBox)) {
+      result.push(oid);
+    }
+  }
+  return result;
+}
+function selectByPolygonFromOidMap(oidNodeMap, polygon, axis = "xz") {
+  const result = [];
+  const polygon2D = polygon.map((p) => {
+    switch (axis) {
+      case "xy":
+        return new Vector2(p.x, p.y);
+      case "yz":
+        return new Vector2(p.y, p.z);
+      case "xz":
+      default:
+        return new Vector2(p.x, p.z);
+    }
+  });
+  for (const [oid, node] of oidNodeMap) {
+    if (!node.bbox || node.bbox.length < 6) continue;
+    let minU, minV, maxU, maxV;
+    switch (axis) {
+      case "xy":
+        minU = node.bbox[0];
+        minV = node.bbox[1];
+        maxU = node.bbox[3];
+        maxV = node.bbox[4];
+        break;
+      case "xz":
+        minU = node.bbox[0];
+        minV = node.bbox[2];
+        maxU = node.bbox[3];
+        maxV = node.bbox[5];
+        break;
+      case "yz":
+        minU = node.bbox[1];
+        minV = node.bbox[2];
+        maxU = node.bbox[4];
+        maxV = node.bbox[5];
+        break;
+    }
+    if (polygonIntersectsRect(polygon2D, minU, minV, maxU, maxV)) {
+      result.push(oid);
+    }
+  }
+  return result;
+}
 const _camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
 class FullscreenTriangleGeometry extends BufferGeometry {
   constructor() {
@@ -1646,6 +1754,276 @@ class GLTFWorkerLoader extends Loader {
     });
   }
 }
+function ensureColor(color) {
+  if (color instanceof Color) {
+    return color;
+  }
+  return new Color(color);
+}
+function getMaterials(mesh) {
+  const mat = mesh.material;
+  if (!mat) return [];
+  return Array.isArray(mat) ? mat : [mat];
+}
+function isColorMaterial(material) {
+  return "color" in material && typeof material.color !== "undefined";
+}
+class ComponentColorModifier {
+  constructor(context) {
+    this.context = context;
+  }
+  _originalColors = /* @__PURE__ */ new Map();
+  _originalOpacities = /* @__PURE__ */ new Map();
+  /**
+   * 根据 oid 数组修改构件颜色
+   * @param oids 构件 OID 数组
+   * @param color 颜色值，支持 hex 数字、颜色字符串（如 "#ff0000"）、THREE.Color 对象
+   */
+  setColorByOids(oids, color) {
+    const threeColor = ensureColor(color);
+    for (const oid of oids) {
+      const meshes = this.context.getMeshesByOid(oid);
+      for (const mesh of meshes) {
+        for (const material of getMaterials(mesh)) {
+          if (isColorMaterial(material)) {
+            if (!this._originalColors.has(material)) {
+              this._originalColors.set(material, material.color.clone());
+            }
+            material.color.copy(threeColor);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 恢复指定构件的颜色为修改前的状态
+   * @param oids 构件 OID 数组
+   */
+  restoreColorByOids(oids) {
+    for (const oid of oids) {
+      const meshes = this.context.getMeshesByOid(oid);
+      for (const mesh of meshes) {
+        for (const material of getMaterials(mesh)) {
+          if (isColorMaterial(material)) {
+            const original = this._originalColors.get(material);
+            if (original) {
+              material.color.copy(original);
+              this._originalColors.delete(material);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 根据 oid 数组修改构件颜色透明度
+   * @param oids 构件 OID 数组
+   * @param opacity 透明度，0-1，0 完全透明，1 完全不透明
+   */
+  setOpacityByOids(oids, opacity) {
+    const clampedOpacity = Math.max(0, Math.min(1, opacity));
+    for (const oid of oids) {
+      const meshes = this.context.getMeshesByOid(oid);
+      for (const mesh of meshes) {
+        for (const material of getMaterials(mesh)) {
+          if (!this._originalOpacities.has(material)) {
+            this._originalOpacities.set(material, material.opacity);
+          }
+          material.opacity = clampedOpacity;
+          material.transparent = clampedOpacity < 1;
+        }
+      }
+    }
+  }
+  /**
+   * 恢复指定构件的透明度为修改前的状态
+   * @param oids 构件 OID 数组
+   */
+  restoreOpacityByOids(oids) {
+    for (const oid of oids) {
+      const meshes = this.context.getMeshesByOid(oid);
+      for (const mesh of meshes) {
+        for (const material of getMaterials(mesh)) {
+          const original = this._originalOpacities.get(material);
+          if (original !== void 0) {
+            material.opacity = original;
+            material.transparent = original < 1;
+            this._originalOpacities.delete(material);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 清除缓存的原始值，释放引用
+   */
+  dispose() {
+    this._originalColors.clear();
+    this._originalOpacities.clear();
+  }
+}
+class InteractionFilter {
+  constructor(context) {
+    this.context = context;
+  }
+  frozenOids = /* @__PURE__ */ new Set();
+  isolatedOids = /* @__PURE__ */ new Set();
+  trackedMeshes = /* @__PURE__ */ new Map();
+  meshListeners = /* @__PURE__ */ new Map();
+  isPluginRemoving = false;
+  isOidBlocked(oid) {
+    if (this.frozenOids.has(oid)) return true;
+    if (this.isolatedOids.size > 0 && !this.isolatedOids.has(oid)) return true;
+    return false;
+  }
+  trackMesh(mesh, oid) {
+    if (this.meshListeners.has(mesh)) return;
+    const onAdded = () => {
+      if (this.isPluginRemoving) return;
+      mesh.userData._detachedParent = null;
+      if (this.isOidBlocked(oid) && mesh.parent) {
+        const parent = mesh.parent;
+        this.isPluginRemoving = true;
+        mesh.userData._detachedParent = parent;
+        parent.remove(mesh);
+        this.isPluginRemoving = false;
+      }
+    };
+    const onRemoved = () => {
+      if (this.isPluginRemoving) return;
+      mesh.userData._detachedParent = null;
+    };
+    mesh.addEventListener("added", onAdded);
+    mesh.addEventListener("removed", onRemoved);
+    this.meshListeners.set(mesh, { onAdded, onRemoved });
+  }
+  untrackMesh(mesh) {
+    const listeners = this.meshListeners.get(mesh);
+    if (listeners) {
+      mesh.removeEventListener("added", listeners.onAdded);
+      mesh.removeEventListener("removed", listeners.onRemoved);
+      this.meshListeners.delete(mesh);
+    }
+    mesh.userData._detachedParent = null;
+  }
+  onCollectorMeshChange(oid, newMeshes) {
+    const tracked = this.trackedMeshes.get(oid);
+    const newSet = new Set(newMeshes);
+    if (tracked) {
+      for (const mesh of tracked) {
+        if (!newSet.has(mesh)) {
+          this.untrackMesh(mesh);
+          tracked.delete(mesh);
+        }
+      }
+    }
+    const trackSet = tracked || /* @__PURE__ */ new Set();
+    for (const mesh of newMeshes) {
+      if (!trackSet.has(mesh)) {
+        this.trackMesh(mesh, oid);
+        trackSet.add(mesh);
+      }
+    }
+    this.trackedMeshes.set(oid, trackSet);
+  }
+  syncCollectorMeshes() {
+    this.isPluginRemoving = true;
+    for (const [oid, collector] of this.context.getCollectorCache()) {
+      const blocked = this.isOidBlocked(oid);
+      for (const mesh of collector.meshes) {
+        if (!this.meshListeners.has(mesh)) continue;
+        if (blocked) {
+          if (mesh.parent && !mesh.userData._detachedParent) {
+            const parent = mesh.parent;
+            mesh.userData._detachedParent = parent;
+            parent.remove(mesh);
+          }
+        } else {
+          const storedParent = mesh.userData._detachedParent;
+          if (storedParent && !mesh.parent) {
+            storedParent.add(mesh);
+            mesh.userData._detachedParent = null;
+          }
+        }
+      }
+    }
+    this.isPluginRemoving = false;
+  }
+  onUnregisterCollector(oid) {
+    const tracked = this.trackedMeshes.get(oid);
+    if (tracked) {
+      for (const mesh of tracked) {
+        this.untrackMesh(mesh);
+      }
+      this.trackedMeshes.delete(oid);
+    }
+  }
+  freezeByOids(oids) {
+    for (const oid of oids) {
+      this.frozenOids.add(oid);
+    }
+    this.syncCollectorMeshes();
+  }
+  freezeByOid(oid) {
+    this.frozenOids.add(oid);
+    this.syncCollectorMeshes();
+  }
+  unfreezeByOids(oids) {
+    for (const oid of oids) {
+      this.frozenOids.delete(oid);
+    }
+    this.syncCollectorMeshes();
+  }
+  unfreezeByOid(oid) {
+    this.frozenOids.delete(oid);
+    this.syncCollectorMeshes();
+  }
+  unfreeze() {
+    this.frozenOids.clear();
+    this.syncCollectorMeshes();
+  }
+  getFrozenOids() {
+    return Array.from(this.frozenOids);
+  }
+  isolateByOids(oids) {
+    for (const oid of oids) {
+      this.isolatedOids.add(oid);
+    }
+    this.syncCollectorMeshes();
+  }
+  isolateByOid(oid) {
+    this.isolatedOids.add(oid);
+    this.syncCollectorMeshes();
+  }
+  unisolateByOids(oids) {
+    for (const oid of oids) {
+      this.isolatedOids.delete(oid);
+    }
+    this.syncCollectorMeshes();
+  }
+  unisolateByOid(oid) {
+    this.isolatedOids.delete(oid);
+    this.syncCollectorMeshes();
+  }
+  unisolate() {
+    this.isolatedOids.clear();
+    this.syncCollectorMeshes();
+  }
+  getIsolatedOids() {
+    return Array.from(this.isolatedOids);
+  }
+  dispose() {
+    for (const [, meshSet] of this.trackedMeshes) {
+      for (const mesh of meshSet) {
+        this.untrackMesh(mesh);
+      }
+    }
+    this.trackedMeshes.clear();
+    this.meshListeners.clear();
+    this.frozenOids.clear();
+    this.isolatedOids.clear();
+  }
+}
 const DB_NAME = "GLTFParserPluginTilesCache";
 const DB_VERSION = 1;
 const STORE_NAME = "tiles";
@@ -1749,12 +2127,8 @@ class GLTFParserPlugin {
   // --- Model info properties ---
   _modelInfo = null;
   _modelInfoPromise = null;
-  // --- Interaction filter properties ---
-  _frozenOids = /* @__PURE__ */ new Set();
-  _isolatedOids = /* @__PURE__ */ new Set();
-  _trackedMeshes = /* @__PURE__ */ new Map();
-  _meshListeners = /* @__PURE__ */ new Map();
-  _isPluginRemoving = false;
+  _interactionFilter;
+  _componentColorModifier;
   // --- Mesh helper properties ---
   oids = [];
   renderer = null;
@@ -1777,6 +2151,12 @@ class GLTFParserPlugin {
     if (options?.renderer) {
       this.renderer = options.renderer;
     }
+    this._interactionFilter = new InteractionFilter({
+      getCollectorCache: () => this.collectorCache
+    });
+    this._componentColorModifier = new ComponentColorModifier({
+      getMeshesByOid: (oid) => this._getMeshesByOidInternal(oid)
+    });
     setMaxWorkers(this._options.maxWorkers);
   }
   /**
@@ -1935,71 +2315,6 @@ class GLTFParserPlugin {
   async getStructureData() {
     return this._ensureStructureLoaded();
   }
-  // =============================================
-  // Spatial Query Methods
-  // =============================================
-  _pointInPolygon(px, py, polygon) {
-    let inside = false;
-    const n = polygon.length;
-    for (let i = 0, j = n - 1; i < n; j = i++) {
-      const xi = polygon[i].x, yi = polygon[i].y;
-      const xj = polygon[j].x, yj = polygon[j].y;
-      if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi) {
-        inside = !inside;
-      }
-    }
-    return inside;
-  }
-  _segmentsIntersect(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {
-    const cross = (ox, oy, ax, ay, bx, by) => (ax - ox) * (by - oy) - (ay - oy) * (bx - ox);
-    const d1 = cross(bx1, by1, bx2, by2, ax1, ay1);
-    const d2 = cross(bx1, by1, bx2, by2, ax2, ay2);
-    const d3 = cross(ax1, ay1, ax2, ay2, bx1, by1);
-    const d4 = cross(ax1, ay1, ax2, ay2, bx2, by2);
-    if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
-      return true;
-    }
-    const onSeg = (px, py, qx, qy, rx, ry) => Math.min(px, qx) <= rx && rx <= Math.max(px, qx) && Math.min(py, qy) <= ry && ry <= Math.max(py, qy);
-    if (d1 === 0 && onSeg(bx1, by1, bx2, by2, ax1, ay1)) return true;
-    if (d2 === 0 && onSeg(bx1, by1, bx2, by2, ax2, ay2)) return true;
-    if (d3 === 0 && onSeg(ax1, ay1, ax2, ay2, bx1, by1)) return true;
-    if (d4 === 0 && onSeg(ax1, ay1, ax2, ay2, bx2, by2)) return true;
-    return false;
-  }
-  _polygonIntersectsRect(polygon, minX, minY, maxX, maxY) {
-    const n = polygon.length;
-    for (let i = 0; i < n; i++) {
-      const p = polygon[i];
-      if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
-        return true;
-      }
-    }
-    if (this._pointInPolygon(minX, minY, polygon) || this._pointInPolygon(maxX, minY, polygon) || this._pointInPolygon(maxX, maxY, polygon) || this._pointInPolygon(minX, maxY, polygon)) {
-      return true;
-    }
-    const rx = [minX, maxX, maxX, minX];
-    const ry = [minY, minY, maxY, maxY];
-    for (let i = 0; i < n; i++) {
-      const a = polygon[i];
-      const b = polygon[(i + 1) % n];
-      for (let j = 0; j < 4; j++) {
-        const k = (j + 1) % 4;
-        if (this._segmentsIntersect(
-          a.x,
-          a.y,
-          b.x,
-          b.y,
-          rx[j],
-          ry[j],
-          rx[k],
-          ry[k]
-        )) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
   /**
    * 选择包围盒范围内的构件（包含相交和包含两种情况）
    * @param box 查询用的 Box3 范围，坐标系与 structure.json 中 bbox 一致
@@ -2007,21 +2322,11 @@ class GLTFParserPlugin {
    */
   async selectByBox(box) {
     await this._ensureStructureLoaded();
-    const result = [];
-    const nodeBox = new Box3();
-    for (const [oid, node] of this._oidNodeMap) {
-      if (!node.bbox || node.bbox.length < 6) continue;
-      nodeBox.min.set(node.bbox[0], node.bbox[1], node.bbox[2]);
-      nodeBox.max.set(node.bbox[3], node.bbox[4], node.bbox[5]);
-      if (box.intersectsBox(nodeBox)) {
-        result.push(oid);
-      }
-    }
-    return result;
+    return selectByBoxFromOidMap(this._oidNodeMap, box);
   }
   /**
    * 选择多边形（平面投影）范围内的构件（包含相交和包含两种情况）
-   * @param polygon 多边形顶点数组（Vector2），按顺序连接构成闭合多边形
+   * @param polygon 多边形顶点数组（Vector3），按顺序连接构成闭合多边形
    * @param axis 投影平面，决定使用 bbox 的哪两个轴做 2D 判定
    *   - 'xz'（默认）：俯视图，取 bbox 的 x/z 坐标
    *   - 'xy'：正视图，取 bbox 的 x/y 坐标
@@ -2030,35 +2335,7 @@ class GLTFParserPlugin {
    */
   async selectByPolygon(polygon, axis = "xz") {
     await this._ensureStructureLoaded();
-    const result = [];
-    for (const [oid, node] of this._oidNodeMap) {
-      if (!node.bbox || node.bbox.length < 6) continue;
-      let minU, minV, maxU, maxV;
-      switch (axis) {
-        case "xy":
-          minU = node.bbox[0];
-          minV = node.bbox[1];
-          maxU = node.bbox[3];
-          maxV = node.bbox[4];
-          break;
-        case "xz":
-          minU = node.bbox[0];
-          minV = node.bbox[2];
-          maxU = node.bbox[3];
-          maxV = node.bbox[5];
-          break;
-        case "yz":
-          minU = node.bbox[1];
-          minV = node.bbox[2];
-          maxU = node.bbox[4];
-          maxV = node.bbox[5];
-          break;
-      }
-      if (this._polygonIntersectsRect(polygon, minU, minV, maxU, maxV)) {
-        result.push(oid);
-      }
-    }
-    return result;
+    return selectByPolygonFromOidMap(this._oidNodeMap, polygon, axis);
   }
   // =============================================
   // Model Info Methods
@@ -2143,13 +2420,7 @@ class GLTFParserPlugin {
     const oid = collector.getOid();
     this.collectors.delete(collector);
     this.collectorCache.delete(oid);
-    const tracked = this._trackedMeshes.get(oid);
-    if (tracked) {
-      for (const mesh of tracked) {
-        this._untrackMesh(mesh);
-      }
-      this._trackedMeshes.delete(oid);
-    }
+    this._interactionFilter.onUnregisterCollector(oid);
   }
   _updateWebGLLimits() {
     const gl = this.renderer.getContext();
@@ -2248,186 +2519,86 @@ class GLTFParserPlugin {
   queryFeatureFromIntersection(hit) {
     const result = queryFeatureFromIntersection(hit);
     if (result.isValid && result.oid !== void 0) {
-      if (this._frozenOids.has(result.oid)) {
-        return { isValid: false, error: "Component is frozen" };
-      }
-      if (this._isolatedOids.size > 0 && !this._isolatedOids.has(result.oid)) {
-        return { isValid: false, error: "Component is not in isolated set" };
+      if (this._interactionFilter.isOidBlocked(result.oid)) {
+        return {
+          isValid: false,
+          error: this._interactionFilter.getFrozenOids().includes(result.oid) ? "Component is frozen" : "Component is not in isolated set"
+        };
       }
     }
     return result;
   }
   // =============================================
-  // Interaction Filter Methods
+  // Interaction Filter Methods (delegated)
   // =============================================
-  _isOidBlocked(oid) {
-    if (this._frozenOids.has(oid)) return true;
-    if (this._isolatedOids.size > 0 && !this._isolatedOids.has(oid))
-      return true;
-    return false;
-  }
-  _trackMesh(mesh, oid) {
-    if (this._meshListeners.has(mesh)) return;
-    const onAdded = () => {
-      if (this._isPluginRemoving) return;
-      mesh.userData._detachedParent = null;
-      if (this._isOidBlocked(oid) && mesh.parent) {
-        const parent = mesh.parent;
-        this._isPluginRemoving = true;
-        mesh.userData._detachedParent = parent;
-        parent.remove(mesh);
-        this._isPluginRemoving = false;
-      }
-    };
-    const onRemoved = () => {
-      if (this._isPluginRemoving) return;
-      mesh.userData._detachedParent = null;
-    };
-    mesh.addEventListener("added", onAdded);
-    mesh.addEventListener("removed", onRemoved);
-    this._meshListeners.set(mesh, { onAdded, onRemoved });
-  }
-  _untrackMesh(mesh) {
-    const listeners = this._meshListeners.get(mesh);
-    if (listeners) {
-      mesh.removeEventListener("added", listeners.onAdded);
-      mesh.removeEventListener("removed", listeners.onRemoved);
-      this._meshListeners.delete(mesh);
-    }
-    mesh.userData._detachedParent = null;
-  }
-  _onCollectorMeshChange(oid, newMeshes) {
-    const tracked = this._trackedMeshes.get(oid);
-    const newSet = new Set(newMeshes);
-    if (tracked) {
-      for (const mesh of tracked) {
-        if (!newSet.has(mesh)) {
-          this._untrackMesh(mesh);
-          tracked.delete(mesh);
-        }
-      }
-    }
-    const trackSet = tracked || /* @__PURE__ */ new Set();
-    for (const mesh of newMeshes) {
-      if (!trackSet.has(mesh)) {
-        this._trackMesh(mesh, oid);
-        trackSet.add(mesh);
-      }
-    }
-    this._trackedMeshes.set(oid, trackSet);
-  }
-  _syncCollectorMeshes() {
-    this._isPluginRemoving = true;
-    for (const [oid, collector] of this.collectorCache) {
-      const blocked = this._isOidBlocked(oid);
-      for (const mesh of collector.meshes) {
-        if (!this._meshListeners.has(mesh)) continue;
-        if (blocked) {
-          if (mesh.parent && !mesh.userData._detachedParent) {
-            const parent = mesh.parent;
-            mesh.userData._detachedParent = parent;
-            this.unhideByOids([oid]);
-          }
-        } else {
-          const storedParent = mesh.userData._detachedParent;
-          if (storedParent && !mesh.parent) {
-            storedParent.add(mesh);
-            mesh.userData._detachedParent = null;
-          }
-        }
-      }
-    }
-    this._isPluginRemoving = false;
-  }
-  /**
-   * 冻结指定构件，被冻结的构件不再响应任何交互和事件
-   */
   freezeByOids(oids) {
-    for (const oid of oids) {
-      this._frozenOids.add(oid);
-    }
-    this._syncCollectorMeshes();
+    this._interactionFilter.freezeByOids(oids);
   }
-  /**
-   * 冻结单个构件
-   */
   freezeByOid(oid) {
-    this._frozenOids.add(oid);
-    this._syncCollectorMeshes();
+    this._interactionFilter.freezeByOid(oid);
   }
-  /**
-   * 解冻指定构件
-   */
   unfreezeByOids(oids) {
-    for (const oid of oids) {
-      this._frozenOids.delete(oid);
-    }
-    this._syncCollectorMeshes();
+    this._interactionFilter.unfreezeByOids(oids);
   }
-  /**
-   * 解冻单个构件
-   */
   unfreezeByOid(oid) {
-    this._frozenOids.delete(oid);
-    this._syncCollectorMeshes();
+    this._interactionFilter.unfreezeByOid(oid);
   }
-  /**
-   * 解冻全部构件
-   */
   unfreeze() {
-    this._frozenOids.clear();
-    this._syncCollectorMeshes();
+    this._interactionFilter.unfreeze();
   }
-  /**
-   * 获取当前被冻结的 OID 数组
-   */
   getFrozenOids() {
-    return Array.from(this._frozenOids);
+    return this._interactionFilter.getFrozenOids();
   }
-  /**
-   * 隔离指定构件，隔离模式下只有被隔离的构件才能响应交互和事件
-   */
   isolateByOids(oids) {
-    for (const oid of oids) {
-      this._isolatedOids.add(oid);
-    }
-    this._syncCollectorMeshes();
+    this._interactionFilter.isolateByOids(oids);
   }
-  /**
-   * 往隔离集合中添加单个构件
-   */
   isolateByOid(oid) {
-    this._isolatedOids.add(oid);
-    this._syncCollectorMeshes();
+    this._interactionFilter.isolateByOid(oid);
+  }
+  unisolateByOids(oids) {
+    this._interactionFilter.unisolateByOids(oids);
   }
+  unisolateByOid(oid) {
+    this._interactionFilter.unisolateByOid(oid);
+  }
+  unisolate() {
+    this._interactionFilter.unisolate();
+  }
+  getIsolatedOids() {
+    return this._interactionFilter.getIsolatedOids();
+  }
+  // =============================================
+  // Component Color Modifier Methods (delegated)
+  // =============================================
   /**
-   * 取消隔离指定构件
+   * 根据 oid 数组修改构件颜色
+   * @param oids 构件 OID 数组
+   * @param color 颜色值，支持 hex 数字（如 0xff0000）、颜色字符串（如 "#ff0000"）、THREE.Color 对象
    */
-  unisolateByOids(oids) {
-    for (const oid of oids) {
-      this._isolatedOids.delete(oid);
-    }
-    this._syncCollectorMeshes();
+  setColorByOids(oids, color) {
+    this._componentColorModifier.setColorByOids(oids, color);
   }
   /**
-   * 从隔离集合中移除单个构件
+   * 根据 oid 数组修改构件颜色透明度
+   * @param oids 构件 OID 数组
+   * @param opacity 透明度，0-1，0 完全透明，1 完全不透明
    */
-  unisolateByOid(oid) {
-    this._isolatedOids.delete(oid);
-    this._syncCollectorMeshes();
+  setOpacityByOids(oids, opacity) {
+    this._componentColorModifier.setOpacityByOids(oids, opacity);
   }
   /**
-   * 取消全部隔离，恢复所有构件的交互能力
+   * 恢复指定构件的颜色为修改前的状态
+   * @param oids 构件 OID 数组
    */
-  unisolate() {
-    this._isolatedOids.clear();
-    this._syncCollectorMeshes();
+  restoreColorByOids(oids) {
+    this._componentColorModifier.restoreColorByOids(oids);
   }
   /**
-   * 获取当前被隔离的 OID 数组
+   * 恢复指定构件的透明度为修改前的状态
+   * @param oids 构件 OID 数组
    */
-  getIsolatedOids() {
-    return Array.from(this._isolatedOids);
+  restoreOpacityByOids(oids) {
+    this._componentColorModifier.restoreOpacityByOids(oids);
   }
   /**
    * 内部方法：根据 oid 获取 mesh 数组
@@ -2458,9 +2629,9 @@ class GLTFParserPlugin {
     }
     const collector = new MeshCollector(oid, this);
     this.collectorCache.set(oid, collector);
-    this._onCollectorMeshChange(oid, collector.meshes);
+    this._interactionFilter.onCollectorMeshChange(oid, collector.meshes);
     collector.addEventListener("mesh-change", (event) => {
-      this._onCollectorMeshChange(oid, event.meshes);
+      this._interactionFilter.onCollectorMeshChange(oid, event.meshes);
     });
     return collector;
   }
@@ -2516,15 +2687,8 @@ class GLTFParserPlugin {
     this._structurePromise = null;
     this._modelInfo = null;
     this._modelInfoPromise = null;
-    for (const [, meshSet] of this._trackedMeshes) {
-      for (const mesh of meshSet) {
-        this._untrackMesh(mesh);
-      }
-    }
-    this._trackedMeshes.clear();
-    this._meshListeners.clear();
-    this._frozenOids.clear();
-    this._isolatedOids.clear();
+    this._interactionFilter.dispose();
+    this._componentColorModifier.dispose();
     this._loader = null;
     this.tiles = null;
   }