@inweb/viewer-three 27.4.2 → 27.4.3

package/dist/viewer-three.js

@@ -38259,6 +38259,19 @@ void main() {
         }
     }
 
+    const GL_TO_THREE_WRAP = {
+      33071: ClampToEdgeWrapping,
+      33648: MirroredRepeatWrapping,
+      10497: RepeatWrapping,
+    };
+    const GL_TO_THREE_FILTER = {
+      9728: NearestFilter,
+      9729: LinearFilter,
+      9984: NearestMipmapNearestFilter,
+      9985: LinearMipmapNearestFilter,
+      9986: NearestMipmapLinearFilter,
+      9987: LinearMipmapLinearFilter,
+    };
     const GL_COMPONENT_TYPES = {
       5120: Int8Array,
       5121: Uint8Array,
@@ -38301,6 +38314,7 @@ void main() {
         this.pendingRequests = [];
         this.batchTimeout = null;
         this.textureLoader = new TextureLoader();
+        this.textureLoader.crossOrigin = "anonymous";
         this.materials = new Map();
         this.textureCache = new Map();
         this.materialCache = new Map();
@@ -38312,7 +38326,7 @@ void main() {
       async initialize(loader) {
         const json = await this.loadController.loadJson();
         if (json.asset === undefined || json.asset.version[0] < 2) {
-          throw new Error("GltfStructure: Unsupported asset. glTF versions >=2.0 are supported.");
+          throw new Error("DynamicLoader: Unsupported asset. glTF versions >=2.0 are supported.");
         }
         this.json = json;
         this.loader = loader;
@@ -38340,7 +38354,9 @@ void main() {
       scheduleRequest(request) {
         return new Promise((resolve, reject) => {
           if (this.loadingAborted) {
-            reject(this.criticalError || new Error("Structure loading has been aborted due to critical error"));
+            reject(
+              this.criticalError || new Error("DynamicLoader: Structure loading has been aborted due to critical error")
+            );
             return;
           }
           this.pendingRequests.push({
@@ -38379,7 +38395,7 @@ void main() {
           }
         }
         console.error(
-          `❌ Critical error for structure "${this.id}". All further loading aborted.`,
+          `DynamicLoader: Critical error for structure "${this.id}". All further loading aborted.`,
           `\n   Error: ${error.message || error}`,
           `\n   Rejected ${requests.length} pending chunk requests.`
         );
@@ -38449,7 +38465,7 @@ void main() {
         const promises = finalRanges.map(async (range, index) => {
           if (this.loadingAborted) {
             for (const req of range.requests) {
-              req._reject(this.criticalError || new Error("Structure loading aborted"));
+              req._reject(this.criticalError || new Error("DynamicLoader: Structure loading aborted"));
             }
             return;
           }
@@ -38472,7 +38488,10 @@ void main() {
             if (this.isCriticalHttpError(error)) {
               this.abortLoading(error);
             } else {
-              console.warn(`Failed to load chunk ${index + 1}/${finalRanges.length} (${range.start}-${range.end}):`, error);
+              console.warn(
+                `DynamicLoader: Failed to load chunk ${index + 1}/${finalRanges.length} (${range.start}-${range.end}):`,
+                error
+              );
             }
           } finally {
             this.loader.releaseChunkSlot();
@@ -38491,7 +38510,7 @@ void main() {
       createTypedArray(buffer, offset, length, componentType) {
         try {
           if (!buffer || !(buffer instanceof ArrayBuffer)) {
-            throw new Error("Invalid buffer");
+            throw new Error("DynamicLoader: Invalid buffer");
           }
           let elementSize;
           switch (componentType) {
@@ -38508,20 +38527,22 @@ void main() {
               elementSize = 4;
               break;
             default:
-              throw new Error(`Unsupported component type: ${componentType}`);
+              throw new Error(`DynamicLoader: Unsupported component type: ${componentType}`);
           }
           const numElements = length / elementSize;
           if (!Number.isInteger(numElements)) {
-            throw new Error(`Invalid length ${length} for component type ${componentType}`);
+            throw new Error(`DynamicLoader: Invalid length ${length} for component type ${componentType}`);
           }
           if (length > buffer.byteLength) {
-            throw new Error(`Buffer too small: need ${length} bytes, but buffer is ${buffer.byteLength} bytes`);
+            throw new Error(
+              `DynamicLoader: Buffer too small: need ${length} bytes, but buffer is ${buffer.byteLength} bytes`
+            );
           }
           const ArrayType = GL_COMPONENT_TYPES[componentType];
           return new ArrayType(buffer, offset, numElements);
         } catch (error) {
           if (error.name !== "AbortError") {
-            console.error("Error creating typed array:", {
+            console.warn("DynamicLoader: Error creating typed array:", {
               bufferSize: buffer?.byteLength,
               offset,
               length,
@@ -38534,7 +38555,7 @@ void main() {
       }
       async createBufferAttribute(accessorIndex) {
         if (!this.json) {
-          throw new Error("No GLTF structure loaded");
+          throw new Error("DynamicLoader: No GLTF structure loaded");
         }
         const gltf = this.json;
         const accessor = gltf.accessors[accessorIndex];
@@ -38551,7 +38572,7 @@ void main() {
           return attribute;
         } catch (error) {
           if (error.name !== "AbortError") {
-            console.error("Error creating buffer attribute:", {
+            console.warn("DynamicLoader: Error creating buffer attribute:", {
               error,
               accessor,
               bufferView,
@@ -38572,7 +38593,7 @@ void main() {
           case 5126:
             return 4;
           default:
-            throw new Error(`Unknown component type: ${componentType}`);
+            throw new Error(`DynamicLoader: Unknown component type: ${componentType}`);
         }
       }
       getNumComponents(type) {
@@ -38592,31 +38613,50 @@ void main() {
           case "MAT4":
             return 16;
           default:
-            throw new Error(`Unknown type: ${type}`);
+            throw new Error(`DynamicLoader: Unknown type: ${type}`);
         }
       }
       async loadTextures() {
         if (!this.json.textures) return;
         const loadTexture = async (imageIndex) => {
-          const image = this.json.images[imageIndex];
-          if (image.uri) {
-            const fullUrl = await this.loadController.resolveURL(image.uri);
-            return this.textureLoader.loadAsync(fullUrl);
-          } else if (image.bufferView !== undefined) {
-            const bufferView = this.json.bufferViews[image.bufferView];
-            const array = await this.getBufferView(bufferView.byteOffset || 0, bufferView.byteLength, 5121);
-            const blob = new Blob([array], { type: image.mimeType });
-            const url = URL.createObjectURL(blob);
-            const texture = await this.textureLoader.loadAsync(url);
-            URL.revokeObjectURL(url);
-            texture.flipY = false;
-            return texture;
+          let textureName = `index_${imageIndex}`;
+          try {
+            const image = this.json.images[imageIndex];
+            textureName = image.uri || image.name || textureName;
+            if (image.uri) {
+              const fullUrl = await this.loadController.resolveURL(image.uri);
+              return await this.textureLoader.loadAsync(fullUrl);
+            } else if (image.bufferView !== undefined) {
+              const bufferView = this.json.bufferViews[image.bufferView];
+              const array = await this.getBufferView(bufferView.byteOffset || 0, bufferView.byteLength, 5121);
+              const blob = new Blob([array], { type: image.mimeType });
+              const url = URL.createObjectURL(blob);
+              const texture = await this.textureLoader.loadAsync(url);
+              URL.revokeObjectURL(url);
+              return texture;
+            }
+          } catch {
+            console.warn(`DynamicLoader: Error loading texture ${textureName}`);
           }
         };
         const texturePromises = [];
         for (let i = 0; i < this.json.textures.length; i++) {
           texturePromises.push(
-            loadTexture(this.json.textures[i].source).then((texture) => this.textureCache.set(i, texture))
+            loadTexture(this.json.textures[i].source).then((texture) => {
+              if (texture) {
+                const samplerDef =
+                  this.json.textures[i].sampler !== undefined && this.json.samplers
+                    ? this.json.samplers[this.json.textures[i].sampler]
+                    : {};
+                texture.magFilter = GL_TO_THREE_FILTER[samplerDef.magFilter] || LinearFilter;
+                texture.minFilter = GL_TO_THREE_FILTER[samplerDef.minFilter] || LinearMipmapLinearFilter;
+                texture.wrapS = GL_TO_THREE_WRAP[samplerDef.wrapS] || RepeatWrapping;
+                texture.wrapT = GL_TO_THREE_WRAP[samplerDef.wrapT] || RepeatWrapping;
+                texture.flipY = false;
+                texture.needsUpdate = true;
+              }
+              this.textureCache.set(i, texture);
+            })
           );
         }
         await Promise.all(texturePromises);
@@ -38647,8 +38687,14 @@ void main() {
             params.opacity = pbr.baseColorFactor[3];
             if (params.opacity < 1.0) params.transparent = true;
           }
-          if (pbr.baseColorTexture) {
-            params.map = this.textureCache.get(pbr.baseColorTexture.index);
+          if (pbr.baseColorTexture !== undefined) {
+            const texture = this.textureCache.get(pbr.baseColorTexture.index);
+            if (texture) {
+              params.map = texture;
+              if (!pbr.baseColorFactor) {
+                params.color = new Color(0xffffff);
+              }
+            }
           }
         }
         if (materialDef.emissiveFactor) {
@@ -38678,10 +38724,58 @@ void main() {
           params.polygonOffset = true;
           params.polygonOffsetFactor = 1;
           params.polygonOffsetUnits = 1;
-          if (materialDef.normalTexture) {
-            params.normalMap = this.textureCache.get(materialDef.normalTexture.index);
+          if (params.map && !materialDef.pbrMetallicRoughness?.baseColorFactor) {
+            params.color = new Color(0xffffff);
+          }
+          if (materialDef.normalTexture !== undefined) {
+            const normalMap = this.textureCache.get(materialDef.normalTexture.index);
+            if (normalMap) {
+              params.normalMap = normalMap;
+            }
+          }
+          if (materialDef.emissiveTexture !== undefined) {
+            const emissiveMap = this.textureCache.get(materialDef.emissiveTexture.index);
+            if (emissiveMap) {
+              params.emissiveMap = emissiveMap;
+            }
+          }
+          const usePBR = materialDef.pbrMetallicRoughness?.metallicRoughnessTexture !== undefined;
+          if (usePBR) {
+            params.metalness =
+              materialDef.pbrMetallicRoughness?.metallicFactor !== undefined
+                ? materialDef.pbrMetallicRoughness.metallicFactor
+                : 1.0;
+            params.roughness =
+              materialDef.pbrMetallicRoughness?.roughnessFactor !== undefined
+                ? materialDef.pbrMetallicRoughness.roughnessFactor
+                : 1.0;
+            if (materialDef.pbrMetallicRoughness?.metallicRoughnessTexture !== undefined) {
+              const map = this.textureCache.get(materialDef.pbrMetallicRoughness.metallicRoughnessTexture.index);
+              if (map) {
+                params.metalnessMap = map;
+                params.roughnessMap = map;
+              }
+            }
+            material = new MeshStandardMaterial(params);
+          } else {
+            material = new MeshPhongMaterial(params);
+          }
+          if (material.map) material.map.colorSpace = SRGBColorSpace;
+          if (material.emissiveMap) material.emissiveMap.colorSpace = SRGBColorSpace;
+          if (material.normalMap) {
+            if (materialDef.normalTexture?.scale !== undefined) {
+              material.normalScale.set(materialDef.normalTexture.scale, materialDef.normalTexture.scale);
+            }
+          }
+          if (materialDef.occlusionTexture !== undefined) {
+            const aoMap = this.textureCache.get(materialDef.occlusionTexture.index);
+            if (aoMap) {
+              material.aoMap = aoMap;
+              if (materialDef.occlusionTexture.strength !== undefined) {
+                material.aoMapIntensity = materialDef.occlusionTexture.strength;
+              }
+            }
           }
-          material = new MeshPhongMaterial(params);
         }
         return material;
       }
@@ -39085,7 +39179,7 @@ void main() {
           memoryLimit = Math.max(memoryLimit, 2 * 1024 * 1024 * 1024);
           console.log(`Available memory set to ${Math.round(memoryLimit / (1024 * 1024 * 1024))}GB`);
         } catch (error) {
-          console.warn("Error detecting available memory:", error);
+          console.warn("DynamicLoader: Error detecting available memory:", error);
         }
         return memoryLimit;
       }
@@ -39250,7 +39344,7 @@ void main() {
                 if (entry?.lines?.uuid) uniqueMaterialIds.add(entry.lines.uuid);
               }
             } catch (exp) {
-              console.error("Error adding material to uniqueMaterialIds", exp);
+              console.warn("DynamicLoader: Error collecting material stats", exp);
             }
           }
         }
@@ -39271,7 +39365,7 @@ void main() {
               this._webglInfoCache = { renderer: null, vendor: null };
             }
           } catch (e) {
-            console.error("Error getting webgl info", e);
+            console.warn("DynamicLoader: Error getting webgl info", e);
             this._webglInfoCache = { renderer: null, vendor: null };
           }
         }
@@ -39528,7 +39622,7 @@ void main() {
           if (node.structure && node.structure.loadingAborted) {
             return;
           }
-          console.error(`Error loading node ${nodeId}:`, error);
+          console.warn(`DynamicLoader: Error loading node ${nodeId}:`, error);
         }
       }
       unloadNode(nodeId) {
@@ -39581,7 +39675,7 @@ void main() {
             await structure.loadTextures();
             await structure.loadMaterials();
           } catch (error) {
-            console.error("Error loading materials:", error);
+            console.error("DynamicLoader: Error loading materials:", error);
             throw error;
           }
         }
@@ -39589,14 +39683,14 @@ void main() {
       }
       async processSceneHierarchy() {
         if (this.structures.length === 0) {
-          throw new Error("No GLTF structures loaded");
+          throw new Error("DynamicLoader: No GLTF structures loaded");
         }
         this.nodesToLoad = [];
         let estimatedSize = 0;
         for (const structure of this.structures) {
           const gltf = structure.getJson();
           if (!gltf.scenes || !gltf.scenes.length) {
-            console.warn("No scenes found in GLTF structure");
+            console.warn("DynamicLoader: No scenes found in GLTF structure");
             continue;
           }
           estimatedSize += gltf.buffers[0].byteLength;
@@ -40309,7 +40403,6 @@ void main() {
           }
         });
         if (totalObjectsToMerge > 0) {
-          console.log(`Pre-allocating transform texture for ${totalObjectsToMerge} objects`);
           this.maxObjectId = totalObjectsToMerge;
           this.initTransformTexture();
           this.initializeObjectVisibility();
@@ -40372,7 +40465,7 @@ void main() {
         let processedGroups = 0;
         for (const group of materialGroups) {
           if (!group.material) {
-            console.warn("Skipping mesh group with null material");
+            console.warn("DynamicLoader: Skipping mesh group with null material");
             continue;
           }
           try {
@@ -40457,7 +40550,7 @@ void main() {
               await this.yieldToUI();
             }
           } catch (error) {
-            console.error("Failed to merge meshes for material:", error);
+            console.warn("DynamicLoader: Failed to merge meshes for material:", error);
             group.objects.forEach((mesh) => {
               mesh.visible = true;
             });
@@ -40469,7 +40562,7 @@ void main() {
         for (const group of materialGroups) {
           if (group.objects.length === 0) continue;
           if (!group.material) {
-            console.warn("Skipping line group with null material");
+            console.warn("DynamicLoader: Skipping line group with null material");
             continue;
           }
           const handles = new Set();
@@ -40579,7 +40672,7 @@ void main() {
         let processedGroups = 0;
         for (const group of materialGroups) {
           if (!group.material) {
-            console.warn("Skipping line segment group with null material");
+            console.warn("DynamicLoader: Skipping line segment group with null material");
             continue;
           }
           try {
@@ -40667,7 +40760,7 @@ void main() {
               await this.yieldToUI();
             }
           } catch (error) {
-            console.warn("Failed to merge line segments for material:", error);
+            console.warn("DynamicLoader: Failed to merge line segments for material:", error);
             group.objects.forEach((line) => {
               line.visible = true;
             });
@@ -40678,7 +40771,7 @@ void main() {
         let processedGroups = 0;
         for (const group of materialGroups) {
           if (!group.material) {
-            console.warn("Skipping points group with null material");
+            console.warn("DynamicLoader: Skipping points group with null material");
             continue;
           }
           try {
@@ -40750,7 +40843,7 @@ void main() {
               await this.yieldToUI();
             }
           } catch (error) {
-            console.warn("Failed to merge points for material:", error);
+            console.warn("DynamicLoader: Failed to merge points for material:", error);
             group.objects.forEach((points) => {
               points.visible = true;
             });
@@ -40830,7 +40923,7 @@ void main() {
             obj.geometry.dispose();
           });
         } catch (error) {
-          console.error("Failed to merge geometries:", error);
+          console.warn("DynamicLoader: Failed to merge geometries:", error);
           lineSegmentsArray.forEach((obj) => {
             obj.visible = true;
             rootGroup.add(obj);
@@ -40934,11 +41027,11 @@ void main() {
       }
       applyObjectTransforms(objectTransformMap) {
         if (this.mergedObjectMap.size === 0) {
-          console.warn("No merged objects to transform");
+          console.warn("DynamicLoader: No merged objects to transform");
           return;
         }
         if (!this.transformData) {
-          console.warn("Transform texture not initialized");
+          console.warn("DynamicLoader: Transform texture not initialized");
           return;
         }
         this.objectTransforms = objectTransformMap;
@@ -41121,7 +41214,7 @@ void main() {
       }
       syncHiddenObjects() {
         if (this.mergedObjectMap.size === 0) {
-          console.log("No merged objects to sync");
+          console.warn("DynamicLoader: No merged objects to sync");
           return;
         }
         if (this.objectVisibility.length > 0) {