@inweb/viewer-three 27.1.9 → 27.2.1

package/dist/viewer-three.js

@@ -572,6 +572,7 @@
             this.memory = {
                 geometries: 0,
                 geometryBytes: 0,
+                optimizedGeometryBytes: 0,
                 textures: 0,
                 textureBytes: 0,
                 materials: 0,
@@ -35108,14 +35109,19 @@ void main() {
             super(camera, canvas);
             this.EYE_HEIGHT = 1.7;
             this.FAILING_DISTANCE = 2;
-            this.GROUND_FOLLOWING_SPEED = 0.05;
+            this.GROUND_FOLLOWING_SKIP_FRAMES = 3;
+            this.GROUND_FOLLOWING_SPEED = 0.4;
             this.LOOK_SPEED = 0.1;
             this.WALK_SPEED_DELIMITER = 4;
             this.WHEEL_SPEED_DELIMITER = 15000;
             this.movementSpeed = 0.1;
             this.multiplier = 3;
+            this.groundFollowingSkippedFrames = 0;
             this.moveWheel = 0;
             this.mouseDragOn = false;
+            this._up = new Vector3();
+            this._forward = new Vector3();
+            this._sideways = new Vector3();
             this.onPointerDown = (event) => {
                 if (event.button !== 0)
                     return;
@@ -35185,6 +35191,14 @@ void main() {
             this.raycaster = new Raycaster();
             this.raycaster.near = 0;
             this.raycaster.far = this.EYE_HEIGHT + this.FAILING_DISTANCE;
+            this.raycaster.params = {
+                Mesh: {},
+                Line: { threshold: 0 },
+                Line2: { threshold: 0 },
+                LOD: { threshold: 0 },
+                Points: { threshold: 0 },
+                Sprite: { threshold: 0 },
+            };
             this.moveKeys = new Set();
             this.moveClock = new Clock();
             this.quaternion = camera.quaternion.clone();
@@ -35209,16 +35223,8 @@ void main() {
             super.dispose();
         }
         updateGroundFollowing() {
-            const up = new Vector3().copy(this.camera.up);
-            this.raycaster.set(this.object.position, up.negate());
-            this.raycaster.params = this.raycaster.params = {
-                Mesh: {},
-                Line: { threshold: 0 },
-                Line2: { threshold: 0 },
-                LOD: { threshold: 0 },
-                Points: { threshold: 0 },
-                Sprite: { threshold: 0 },
-            };
+            this._up.copy(this.camera.up).negate();
+            this.raycaster.set(this.object.position, this._up);
             const intersects = this.raycaster.intersectObjects(this.groundObjects, false);
             if (intersects.length > 0) {
                 const groundY = intersects[0].point.y;
@@ -35229,8 +35235,8 @@ void main() {
         update() {
             let moved = false;
             let upgradeGroundFollowing = false;
-            const forward = new Vector3();
-            const sideways = new Vector3();
+            const forward = this._forward;
+            const sideways = this._sideways;
             if (this.moveKeys.size > 0) {
                 upgradeGroundFollowing = true;
                 const timeDelta = this.moveClock.getDelta();
@@ -35282,8 +35288,11 @@ void main() {
                 this.moveWheel += -1 * Math.sign(this.moveWheel);
                 moved = true;
             }
-            if (upgradeGroundFollowing)
+            this.groundFollowingSkippedFrames++;
+            if (upgradeGroundFollowing && this.groundFollowingSkippedFrames >= this.GROUND_FOLLOWING_SKIP_FRAMES) {
+                this.groundFollowingSkippedFrames = 0;
                 this.updateGroundFollowing();
+            }
             if (moved) {
                 this.dispatchEvent({ type: "change" });
             }
@@ -36093,7 +36102,7 @@ void main() {
                             camera = object;
                 });
                 if (camera) {
-                    camera.isDefaultCamera = true;
+                    camera.userData.isDefaultCamera = true;
                     camera.scale.set(1, 1, 1);
                     this.switchCamera(camera);
                     const mode = this.getCameraMode(camera);
@@ -36297,6 +36306,7 @@ void main() {
                 this.viewer.info.optimizedScene.edges = 0;
                 this.viewer.info.memory.geometries = 0;
                 this.viewer.info.memory.geometryBytes = 0;
+                this.viewer.info.memory.optimizedGeometryBytes = 0;
                 this.viewer.info.memory.textures = 0;
                 this.viewer.info.memory.textureBytes = 0;
                 this.viewer.info.memory.materials = 0;
@@ -36333,6 +36343,7 @@ void main() {
                 this.viewer.info.optimizedScene.edges += info.optimizedScene.edges;
                 this.viewer.info.memory.geometries += info.memory.geometries;
                 this.viewer.info.memory.geometryBytes += info.memory.geometryBytes;
+                this.viewer.info.memory.optimizedGeometryBytes += info.memory.optimizedGeometryBytes;
                 this.viewer.info.memory.textures += info.memory.textures;
                 this.viewer.info.memory.textureBytes += info.memory.textureBytes;
                 this.viewer.info.memory.materials += info.memory.materials;
@@ -36343,7 +36354,9 @@ void main() {
                 this.viewer.info.performance.loadTime += performance.now() - this.startTime;
                 console.log("Number of objects:", info.scene.objects);
                 console.log("Number of objects after optimization:", info.optimizedScene.objects);
-                console.log("Total geometry size:", info.memory.totalEstimatedGpuBytes / (1024 * 1024), "MB");
+                console.log("Geometry size:", info.memory.geometryBytes / (1024 * 1024), "MB");
+                console.log("Optimized geometry size:", info.memory.optimizedGeometryBytes / (1024 * 1024), "MB");
+                console.log("Estimated GPU used:", info.memory.totalEstimatedGpuBytes / (1024 * 1024), "MB");
                 console.log("File load time:", this.viewer.info.performance.loadTime, "ms");
             };
             this.resize = () => {
@@ -37725,6 +37738,7 @@ void main() {
             info.scene.edges = Math.floor(totalEdges);
             info.memory.geometries = geometries.size;
             info.memory.geometryBytes = geometryBytes;
+            info.memory.optimizedGeometryBytes = 0;
             info.memory.textures = textures.size;
             info.memory.textureBytes = Math.floor(textureBytes);
             info.memory.materials = materials.size;
@@ -37897,6 +37911,7 @@ void main() {
             info.optimizedScene.edges = stats.scene.afterOptimization.edges;
             info.memory.geometries = stats.memory.geometries.count;
             info.memory.geometryBytes = stats.memory.geometries.bytes;
+            info.memory.optimizedGeometryBytes = stats.memory.geometries.optimizedBytes;
             info.memory.textures = stats.memory.textures.count;
             info.memory.materials = stats.memory.materials.count;
             info.memory.totalEstimatedGpuBytes = stats.memory.totalEstimatedGpuBytes;
@@ -38717,11 +38732,14 @@ void main() {
         this.structures = [];
         this.structureRoots = new Map();
         this.memoryLimit = this.getAvailableMemory();
+        this.optimizationMemoryMultiplier = 5;
+        this.memoryEstimationFactor = 1.7;
         this.loadedGeometrySize = 0;
         this.geometryCache = new Map();
         this.materialCache = new Map();
         this.textureCache = new Map();
         this.currentMemoryUsage = 0;
+        this.pendingMemoryUsage = 0;
         this.updateMemoryIndicator();
         this.loadedMaterials = new Map();
         this.abortController = new AbortController();
@@ -38777,7 +38795,7 @@ void main() {
         } catch (error) {
           console.warn("Error detecting available memory:", error);
         }
-        return memoryLimit / 3;
+        return memoryLimit;
       }
       getAbortController() {
         return this.abortController;
@@ -38785,9 +38803,26 @@ void main() {
       abortLoading() {
         this.abortController.abort();
       }
+      getOptimizedGeometrySize() {
+        let total = 0;
+        const addSize = (obj) => {
+          if (obj && obj.geometry) total += this.estimateGeometrySize(obj);
+        };
+        this.mergedMesh?.forEach(addSize);
+        this.mergedLines?.forEach(addSize);
+        this.mergedLineSegments?.forEach(addSize);
+        this.mergedPoints?.forEach(addSize);
+        return total;
+      }
       updateMemoryIndicator() {
+        const optimizedUsage = this.getOptimizedGeometrySize();
+        const totalUsage = this.currentMemoryUsage + optimizedUsage;
+        const totalUsageEstimate = Math.round(totalUsage * this.memoryEstimationFactor);
         this.dispatchEvent("geometrymemory", {
           currentUsage: this.currentMemoryUsage,
+          optimizedUsage,
+          totalUsage,
+          totalUsageEstimate,
           limit: this.memoryLimit,
         });
       }
@@ -38839,10 +38874,13 @@ void main() {
         for (const geo of geometries) {
           currentMemoryUsage += geo.size;
         }
-        if (currentMemoryUsage > this.memoryLimit) {
-          console.log(`Memory usage (${Math.round(currentMemoryUsage / (1024 * 1024))}MB) exceeds limit`);
+        const effectiveLimitForEviction = this.memoryLimit / this.memoryEstimationFactor;
+        if (currentMemoryUsage > effectiveLimitForEviction) {
+          console.log(
+            `Memory usage (${Math.round((currentMemoryUsage * this.memoryEstimationFactor) / (1024 * 1024))}MB est.) exceeds limit`
+          );
           for (const geo of geometries) {
-            if (currentMemoryUsage <= this.memoryLimit) break;
+            if (currentMemoryUsage <= effectiveLimitForEviction) break;
             if (this.abortController.signal.aborted) {
               throw new DOMException("Loading aborted", "AbortError");
             }
@@ -38926,7 +38964,9 @@ void main() {
         }
         const materialCount = uniqueMaterialIds.size;
         const textureCount = uniqueTextureIds.size;
-        const estimatedGpuMemoryBytes = geometryMemoryBytes;
+        const optimizedUsageBytes = this.getOptimizedGeometrySize();
+        const totalUsageBytes = geometryMemoryBytes + optimizedUsageBytes;
+        const estimatedGpuMemoryBytes = Math.round(totalUsageBytes * this.memoryEstimationFactor);
         if (!this._webglInfoCache) {
           try {
             const gl = this.renderer.getContext();
@@ -38963,7 +39003,12 @@ void main() {
             },
           },
           memory: {
-            geometries: { count: geometryCount, bytes: geometryMemoryBytes },
+            geometries: {
+              count: geometryCount,
+              bytes: geometryMemoryBytes,
+              optimizedBytes: optimizedUsageBytes,
+              totalRawBytes: totalUsageBytes,
+            },
             textures: { count: textureCount },
             materials: { count: materialCount },
             totalEstimatedGpuBytes: estimatedGpuMemoryBytes,
@@ -38975,9 +39020,12 @@ void main() {
           },
         };
       }
-      async loadNode(nodeId, onLoadFinishCb) {
+      async loadNode(nodeId, onLoadFinishCb, reservedEstimatedSize = 0) {
         const node = this.nodes.get(nodeId);
-        if (!node || node.loaded || node.loading) return;
+        if (!node || node.loaded || node.loading) {
+          this.pendingMemoryUsage = Math.max(0, this.pendingMemoryUsage - reservedEstimatedSize);
+          return;
+        }
         node.loading = true;
         const meshDef = node.structure.getJson().meshes[node.meshIndex];
         try {
@@ -39060,6 +39108,7 @@ void main() {
           if (bufferRequests.length === 0) {
             node.loaded = true;
             node.loading = false;
+            this.pendingMemoryUsage = Math.max(0, this.pendingMemoryUsage - reservedEstimatedSize);
             return;
           }
           bufferRequests.sort((a, b) => a.offset - b.offset);
@@ -39171,6 +39220,7 @@ void main() {
           }
           node.loaded = true;
           node.loading = false;
+          this.pendingMemoryUsage = Math.max(0, this.pendingMemoryUsage - reservedEstimatedSize);
           const geometrySize = this.estimateGeometrySize(node.object);
           this.geometryCache.set(node.object.uuid, geometrySize);
           this.currentMemoryUsage += geometrySize;
@@ -39179,6 +39229,7 @@ void main() {
           }
         } catch (error) {
           node.loading = false;
+          this.pendingMemoryUsage = Math.max(0, this.pendingMemoryUsage - reservedEstimatedSize);
           if (error.name === "AbortError") {
             return;
           }
@@ -39394,15 +39445,18 @@ void main() {
         let loadedCount = 0;
         let lastLoadedCount = 0;
         const totalNodes = nodesToLoad.length;
+        const progressTotal = { value: totalNodes };
         const loadProgress = async () => {
           loadedCount++;
+          const total = progressTotal.value;
+          const percentage = total > 0 ? Math.min(100, Math.round((loadedCount / total) * 100)) : 0;
           if (loadedCount - lastLoadedCount > 1000) {
             lastLoadedCount = loadedCount;
             this.updateMemoryIndicator();
             this.dispatchEvent("geometryprogress", {
-              percentage: Math.round((loadedCount / totalNodes) * 100),
+              percentage,
               loaded: loadedCount,
-              total: totalNodes,
+              total,
             });
             this.dispatchEvent("update");
             await new Promise((resolve) => {
@@ -39412,20 +39466,22 @@ void main() {
         };
         try {
           const loadOperations = [];
+          let memoryLimitReached = false;
           for (const nodeId of nodesToLoad) {
             if (this.abortController.signal.aborted) {
               throw new DOMException("Loading aborted", "AbortError");
             }
             const estimatedSize = await this.estimateNodeSize(nodeId);
-            if (this.currentMemoryUsage + estimatedSize > this.memoryLimit) {
-              console.log(`Memory limit reached after loading ${loadedCount} nodes`);
-              this.dispatchEvent("geometryerror", {
-                message: "Memory limit reached",
-              });
-              this.dispatchEvent("update");
-              return loadedCount;
+            const estimated = Number(estimatedSize) || 0;
+            const effectiveLimit = this.memoryLimit / this.optimizationMemoryMultiplier / this.memoryEstimationFactor;
+            if (this.currentMemoryUsage + this.pendingMemoryUsage + estimated > effectiveLimit) {
+              memoryLimitReached = true;
+              progressTotal.value = loadOperations.length;
+              console.log(`Memory limit reached after scheduling ${loadOperations.length} nodes`);
+              break;
             }
-            loadOperations.push(this.loadNode(nodeId, loadProgress));
+            this.pendingMemoryUsage += estimated;
+            loadOperations.push(this.loadNode(nodeId, loadProgress, estimated));
           }
           for (const structure of this.structures) {
             loadOperations.push(structure.flushBufferRequests());
@@ -39433,7 +39489,8 @@ void main() {
           await Promise.all(loadOperations);
           this.dispatchEvent("geometryend", {
             totalLoaded: loadedCount,
-            totalNodes,
+            totalNodes: progressTotal.value,
+            memoryLimitReached,
           });
           return loadedCount;
         } catch (error) {
@@ -39743,6 +39800,7 @@ void main() {
         this.transformedGeometries.clear();
         this.totalLoadedObjects = 0;
         this.currentMemoryUsage = 0;
+        this.pendingMemoryUsage = 0;
         this.loadedGeometrySize = 0;
         this.abortController = new AbortController();
         this.updateMemoryIndicator();
@@ -39949,6 +40007,7 @@ void main() {
           progress: 100,
           message: `Optimization complete! ${this.maxObjectId} objects processed.`,
         });
+        this.updateMemoryIndicator();
         this.dispatchEvent("update");
       }
       async mergeMeshGroups(materialGroups, rootGroup) {