gltf-parser-plugin 1.1.4 → 1.1.5

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

@@ -1755,9 +1755,7 @@ class GLTFWorkerLoader extends Loader {
   }
 }
 function ensureColor(color) {
-  if (color instanceof Color) {
-    return color;
-  }
+  if (color instanceof Color) return color;
   return new Color(color);
 }
 function getMaterials(mesh) {
@@ -1765,101 +1763,196 @@ function getMaterials(mesh) {
   if (!mat) return [];
   return Array.isArray(mat) ? mat : [mat];
 }
-function isColorMaterial(material) {
-  return "color" in material && typeof material.color !== "undefined";
+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);
 }
-class ComponentColorModifier {
+const materialCache = /* @__PURE__ */ new Map();
+class ComponentColorHelper {
   constructor(context) {
     this.context = context;
   }
-  _originalColors = /* @__PURE__ */ new Map();
-  _originalOpacities = /* @__PURE__ */ new Map();
+  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 数组修改构件颜色
-   * @param oids 构件 OID 数组
-   * @param color 颜色值，支持 hex 数字、颜色字符串（如 "#ff0000"）、THREE.Color 对象
+   * 根据 oid 数组设置构件颜色
+   * 隐藏原 mesh，将 split mesh 替换材质后加入场景
    */
-  setColorByOids(oids, color) {
+  setComponentColorByOids(oids, color) {
+    const scene = this.context.getScene();
+    if (!scene) return;
     const threeColor = ensureColor(color);
+    const material = getMaterialForColor(threeColor);
     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);
-          }
+      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());
   }
   /**
-   * 恢复指定构件的颜色为修改前的状态
-   * @param oids 构件 OID 数组
+   * 恢复指定构件的颜色
+   * 若该 oid 已无颜色且无透明度修改，则从场景移除 split mesh 并 unhide 原 mesh
    */
-  restoreColorByOids(oids) {
+  restoreComponentColorByOids(oids) {
+    const scene = this.context.getScene();
+    if (!scene) return;
     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);
+      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 数组修改构件颜色透明度
+   * 根据 oid 数组设置构件透明度
+   * 隐藏原 mesh，将 split mesh 修改材质透明度后加入场景
    * @param oids 构件 OID 数组
    * @param opacity 透明度，0-1，0 完全透明，1 完全不透明
    */
-  setOpacityByOids(oids, opacity) {
+  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) {
-      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;
+      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());
   }
   /**
-   * 恢复指定构件的透明度为修改前的状态
-   * @param oids 构件 OID 数组
+   * 恢复指定构件的透明度
+   * 若该 oid 已无颜色且无透明度修改，则从场景移除 split mesh 并 unhide 原 mesh
    */
-  restoreOpacityByOids(oids) {
+  restoreComponentOpacityByOids(oids) {
+    const scene = this.context.getScene();
+    if (!scene) return;
     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);
+      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) {
-            material.opacity = original;
-            material.transparent = original < 1;
-            this._originalOpacities.delete(material);
+            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);
+        }
       }
     }
-  }
-  /**
-   * 清除缓存的原始值，释放引用
-   */
-  dispose() {
-    this._originalColors.clear();
-    this._originalOpacities.clear();
+    this.context.unhideByOids(oids);
   }
 }
 class InteractionFilter {
@@ -2128,7 +2221,7 @@ class GLTFParserPlugin {
   _modelInfo = null;
   _modelInfoPromise = null;
   _interactionFilter;
-  _componentColorModifier;
+  _componentColorHelper = null;
   // --- Mesh helper properties ---
   oids = [];
   renderer = null;
@@ -2154,9 +2247,6 @@ class GLTFParserPlugin {
     this._interactionFilter = new InteractionFilter({
       getCollectorCache: () => this.collectorCache
     });
-    this._componentColorModifier = new ComponentColorModifier({
-      getMeshesByOid: (oid) => this._getMeshesByOidInternal(oid)
-    });
     setMaxWorkers(this._options.maxWorkers);
   }
   /**
@@ -2164,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
@@ -2567,39 +2663,6 @@ class GLTFParserPlugin {
   getIsolatedOids() {
     return this._interactionFilter.getIsolatedOids();
   }
-  // =============================================
-  // Component Color Modifier Methods (delegated)
-  // =============================================
-  /**
-   * 根据 oid 数组修改构件颜色
-   * @param oids 构件 OID 数组
-   * @param color 颜色值，支持 hex 数字（如 0xff0000）、颜色字符串（如 "#ff0000"）、THREE.Color 对象
-   */
-  setColorByOids(oids, color) {
-    this._componentColorModifier.setColorByOids(oids, color);
-  }
-  /**
-   * 根据 oid 数组修改构件颜色透明度
-   * @param oids 构件 OID 数组
-   * @param opacity 透明度，0-1，0 完全透明，1 完全不透明
-   */
-  setOpacityByOids(oids, opacity) {
-    this._componentColorModifier.setOpacityByOids(oids, opacity);
-  }
-  /**
-   * 恢复指定构件的颜色为修改前的状态
-   * @param oids 构件 OID 数组
-   */
-  restoreColorByOids(oids) {
-    this._componentColorModifier.restoreColorByOids(oids);
-  }
-  /**
-   * 恢复指定构件的透明度为修改前的状态
-   * @param oids 构件 OID 数组
-   */
-  restoreOpacityByOids(oids) {
-    this._componentColorModifier.restoreOpacityByOids(oids);
-  }
   /**
    * 内部方法：根据 oid 获取 mesh 数组
    */
@@ -2651,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
    */
@@ -2688,7 +2783,7 @@ class GLTFParserPlugin {
     this._modelInfo = null;
     this._modelInfoPromise = null;
     this._interactionFilter.dispose();
-    this._componentColorModifier.dispose();
+    this._componentColorHelper = null;
     this._loader = null;
     this.tiles = null;
   }