gltf-parser-plugin 1.1.3 → 1.1.5

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,369 @@ 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 getMaterialForColor(color) {
+  const key = color.getHex();
+  if (!materialCache.has(key)) {
+    materialCache.set(key, new MeshStandardMaterial({
+      color: color.clone(),
+      roughness: 0.5,
+      metalness: 0.1
+    }));
+  }
+  return materialCache.get(key);
+}
+const materialCache = /* @__PURE__ */ new Map();
+class ComponentColorHelper {
+  constructor(context) {
+    this.context = context;
+  }
+  coloredOids = /* @__PURE__ */ new Set();
+  materialByOid = /* @__PURE__ */ new Map();
+  originalMaterialByMesh = /* @__PURE__ */ new Map();
+  opacityModifiedOids = /* @__PURE__ */ new Set();
+  opacityByOid = /* @__PURE__ */ new Map();
+  originalOpacityByMaterial = /* @__PURE__ */ new Map();
+  meshChangeHandlers = /* @__PURE__ */ new Map();
+  getAllModifiedOids() {
+    return Array.from(/* @__PURE__ */ new Set([...this.coloredOids, ...this.opacityModifiedOids]));
+  }
+  applyToMeshes(oid) {
+    const scene = this.context.getScene();
+    if (!scene) return;
+    const collector = this.context.getMeshCollectorByOid(oid);
+    const colorMaterial = this.materialByOid.get(oid);
+    const opacity = this.opacityByOid.get(oid);
+    collector.meshes.forEach((mesh) => {
+      if (!mesh.parent) scene.add(mesh);
+      if (colorMaterial) {
+        mesh.material = colorMaterial;
+      }
+      if (opacity !== void 0) {
+        for (const mat of getMaterials(mesh)) {
+          if (!this.originalOpacityByMaterial.has(mat)) {
+            this.originalOpacityByMaterial.set(mat, mat.opacity);
+          }
+          mat.opacity = opacity;
+          mat.transparent = opacity < 1;
+        }
+      }
+    });
+  }
+  /**
+   * 根据 oid 数组设置构件颜色
+   * 隐藏原 mesh，将 split mesh 替换材质后加入场景
+   */
+  setComponentColorByOids(oids, color) {
+    const scene = this.context.getScene();
+    if (!scene) return;
+    const threeColor = ensureColor(color);
+    const material = getMaterialForColor(threeColor);
+    for (const oid of oids) {
+      this.coloredOids.add(oid);
+      this.materialByOid.set(oid, material);
+      const collector = this.context.getMeshCollectorByOid(oid);
+      collector.meshes.forEach((mesh) => {
+        if (!this.originalMaterialByMesh.has(mesh.uuid)) {
+          this.originalMaterialByMesh.set(mesh.uuid, mesh.material);
+        }
+        mesh.material = material;
+        scene.add(mesh);
+      });
+      if (!this.meshChangeHandlers.has(oid)) {
+        const handler = () => this.applyToMeshes(oid);
+        this.meshChangeHandlers.set(oid, handler);
+        collector.addEventListener("mesh-change", handler);
+      }
+    }
+    this.context.hideByOids(this.getAllModifiedOids());
+  }
+  /**
+   * 恢复指定构件的颜色
+   * 若该 oid 已无颜色且无透明度修改，则从场景移除 split mesh 并 unhide 原 mesh
+   */
+  restoreComponentColorByOids(oids) {
+    const scene = this.context.getScene();
+    if (!scene) return;
+    for (const oid of oids) {
+      this.coloredOids.delete(oid);
+      this.materialByOid.delete(oid);
+      const collector = this.context.getMeshCollectorByOid(oid);
+      const opacity = this.opacityByOid.get(oid);
+      collector.meshes.forEach((mesh) => {
+        const originalMat = this.originalMaterialByMesh.get(mesh.uuid);
+        if (originalMat) {
+          mesh.material = originalMat;
+          this.originalMaterialByMesh.delete(mesh.uuid);
+          if (opacity !== void 0) {
+            for (const mat of getMaterials(mesh)) {
+              if (!this.originalOpacityByMaterial.has(mat)) {
+                this.originalOpacityByMaterial.set(mat, mat.opacity);
+              }
+              mat.opacity = opacity;
+              mat.transparent = opacity < 1;
+            }
+          }
+        }
+        if (!this.coloredOids.has(oid) && !this.opacityModifiedOids.has(oid) && mesh.parent === scene) {
+          scene.remove(mesh);
+        }
+      });
+      if (!this.coloredOids.has(oid) && !this.opacityModifiedOids.has(oid)) {
+        const handler = this.meshChangeHandlers.get(oid);
+        if (handler) {
+          this.meshChangeHandlers.delete(oid);
+          collector.removeEventListener("mesh-change", handler);
+        }
+      }
+    }
+    this.context.unhideByOids(oids);
+  }
+  /**
+   * 根据 oid 数组设置构件透明度
+   * 隐藏原 mesh，将 split mesh 修改材质透明度后加入场景
+   * @param oids 构件 OID 数组
+   * @param opacity 透明度，0-1，0 完全透明，1 完全不透明
+   */
+  setComponentOpacityByOids(oids, opacity) {
+    const scene = this.context.getScene();
+    if (!scene) return;
+    const clampedOpacity = Math.max(0, Math.min(1, opacity));
+    for (const oid of oids) {
+      this.opacityModifiedOids.add(oid);
+      this.opacityByOid.set(oid, clampedOpacity);
+      const colorMat = this.materialByOid.get(oid);
+      if (colorMat && colorMat.opacity !== clampedOpacity) {
+        const clone = colorMat.clone();
+        clone.opacity = clampedOpacity;
+        clone.transparent = clampedOpacity < 1;
+        this.materialByOid.set(oid, clone);
+        this.originalOpacityByMaterial.set(clone, 1);
+      }
+      const collector = this.context.getMeshCollectorByOid(oid);
+      collector.meshes.forEach((mesh) => {
+        scene.add(mesh);
+        const mat = colorMat ? this.materialByOid.get(oid) : mesh.material;
+        if (!this.originalOpacityByMaterial.has(mat)) {
+          this.originalOpacityByMaterial.set(mat, mat.opacity);
+        }
+        mat.opacity = clampedOpacity;
+        mat.transparent = clampedOpacity < 1;
+        if (colorMat) mesh.material = mat;
+      });
+      if (!this.meshChangeHandlers.has(oid)) {
+        const handler = () => this.applyToMeshes(oid);
+        this.meshChangeHandlers.set(oid, handler);
+        collector.addEventListener("mesh-change", handler);
+      }
+    }
+    this.context.hideByOids(this.getAllModifiedOids());
+  }
+  /**
+   * 恢复指定构件的透明度
+   * 若该 oid 已无颜色且无透明度修改，则从场景移除 split mesh 并 unhide 原 mesh
+   */
+  restoreComponentOpacityByOids(oids) {
+    const scene = this.context.getScene();
+    if (!scene) return;
+    for (const oid of oids) {
+      this.opacityModifiedOids.delete(oid);
+      this.opacityByOid.delete(oid);
+      const collector = this.context.getMeshCollectorByOid(oid);
+      collector.meshes.forEach((mesh) => {
+        for (const mat of getMaterials(mesh)) {
+          const original = this.originalOpacityByMaterial.get(mat);
+          if (original !== void 0) {
+            mat.opacity = original;
+            mat.transparent = original < 1;
+            this.originalOpacityByMaterial.delete(mat);
+          }
+        }
+        if (!this.coloredOids.has(oid) && !this.opacityModifiedOids.has(oid) && mesh.parent === scene) {
+          scene.remove(mesh);
+        }
+      });
+      if (!this.coloredOids.has(oid) && !this.opacityModifiedOids.has(oid)) {
+        const handler = this.meshChangeHandlers.get(oid);
+        if (handler) {
+          this.meshChangeHandlers.delete(oid);
+          collector.removeEventListener("mesh-change", handler);
+        }
+      }
+    }
+    this.context.unhideByOids(oids);
+  }
+}
+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 +2220,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;
+  _componentColorHelper = null;
   // --- Mesh helper properties ---
   oids = [];
   renderer = null;
@@ -1777,6 +2244,9 @@ class GLTFParserPlugin {
     if (options?.renderer) {
       this.renderer = options.renderer;
     }
+    this._interactionFilter = new InteractionFilter({
+      getCollectorCache: () => this.collectorCache
+    });
     setMaxWorkers(this._options.maxWorkers);
   }
   /**
@@ -1784,6 +2254,12 @@ class GLTFParserPlugin {
    */
   init(tiles) {
     this.tiles = tiles;
+    this._componentColorHelper = new ComponentColorHelper({
+      hideByOids: (oids) => this.hideByOids(oids),
+      unhideByOids: (oids) => this.unhideByOids(oids),
+      getMeshCollectorByOid: (oid) => this.getMeshCollectorByOid(oid),
+      getScene: () => this.tiles?.group ?? null
+    });
     this._loader = new GLTFWorkerLoader(tiles.manager, {
       metadata: this._options.metadata,
       materialBuilder: this._options.materialBuilder
@@ -1935,71 +2411,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,17 +2418,7 @@ 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);
   }
   /**
    * 选择多边形（平面投影）范围内的构件（包含相交和包含两种情况）
@@ -2030,46 +2431,7 @@ class GLTFParserPlugin {
    */
   async selectByPolygon(polygon, axis = "xz") {
     await this._ensureStructureLoaded();
-    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 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(polygon2D, minU, minV, maxU, maxV)) {
-        result.push(oid);
-      }
-    }
-    return result;
+    return selectByPolygonFromOidMap(this._oidNodeMap, polygon, axis);
   }
   // =============================================
   // Model Info Methods
@@ -2154,13 +2516,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();
@@ -2259,186 +2615,53 @@ 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) {
-    for (const oid of oids) {
-      this._isolatedOids.delete(oid);
-    }
-    this._syncCollectorMeshes();
+    this._interactionFilter.unisolateByOids(oids);
   }
-  /**
-   * 从隔离集合中移除单个构件
-   */
   unisolateByOid(oid) {
-    this._isolatedOids.delete(oid);
-    this._syncCollectorMeshes();
+    this._interactionFilter.unisolateByOid(oid);
   }
-  /**
-   * 取消全部隔离，恢复所有构件的交互能力
-   */
   unisolate() {
-    this._isolatedOids.clear();
-    this._syncCollectorMeshes();
+    this._interactionFilter.unisolate();
   }
-  /**
-   * 获取当前被隔离的 OID 数组
-   */
   getIsolatedOids() {
-    return Array.from(this._isolatedOids);
+    return this._interactionFilter.getIsolatedOids();
   }
   /**
    * 内部方法：根据 oid 获取 mesh 数组
@@ -2469,9 +2692,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;
   }
@@ -2491,6 +2714,38 @@ class GLTFParserPlugin {
     this.oids = newOids;
     this.featureIdCount = this._calculateFeatureIdCount();
   }
+  /**
+   * 根据 oid 数组设置构件颜色
+   * 隐藏原 mesh，将 split mesh 替换材质后加入场景（使用 tiles.group）
+   * @param oids 构件 OID 数组
+   * @param color 颜色值，支持 hex 数字、颜色字符串（如 "#ff0000"）、THREE.Color 对象
+   */
+  setComponentColorByOids(oids, color) {
+    this._componentColorHelper?.setComponentColorByOids(oids, color);
+  }
+  /**
+   * 恢复指定构件的颜色
+   * 从场景移除 split mesh，unhide 原 mesh
+   * @param oids 构件 OID 数组
+   */
+  restoreComponentColorByOids(oids) {
+    this._componentColorHelper?.restoreComponentColorByOids(oids);
+  }
+  /**
+   * 根据 oid 数组设置构件透明度
+   * @param oids 构件 OID 数组
+   * @param opacity 透明度，0-1，0 完全透明，1 完全不透明
+   */
+  setComponentOpacityByOids(oids, opacity) {
+    this._componentColorHelper?.setComponentOpacityByOids(oids, opacity);
+  }
+  /**
+   * 恢复指定构件的透明度
+   * @param oids 构件 OID 数组
+   */
+  restoreComponentOpacityByOids(oids) {
+    this._componentColorHelper?.restoreComponentOpacityByOids(oids);
+  }
   /**
    * Restore the original materials of the mesh
    */
@@ -2527,15 +2782,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._componentColorHelper = null;
     this._loader = null;
     this.tiles = null;
   }