@inweb/viewer-three 26.9.7 → 26.9.8

package/src/Viewer/loaders/DynamicGltfLoader/DynamicGltfLoader.js

@@ -26,6 +26,9 @@ import {
 import { GL_CONSTANTS } from "./GltfStructure.js";
 import { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
 
+//#AI-GENERATED using Gemini 2.5 Pro, Claude-4-sonnet
+//#Reviewed and adapted by dborysov@opendesign.com
+
 export class DynamicGltfLoader {
   constructor(camera, scene, renderer) {
     this.camera = camera;
@@ -98,6 +101,18 @@ export class DynamicGltfLoader {
     this.maxConcurrentChunks = 8;
     this.activeChunkLoads = 0;
     this.chunkQueue = [];
+
+    // GPU-accelerated visibility system
+    this.objectIdToIndex = new Map(); // objectId -> index
+    this.maxObjectId = 0; // Maximum object ID
+    this.objectVisibility = new Float32Array(); // Array of visibility flags for each object
+
+    // Chunk loading configuration
+    this.maxConcurrentChunks = 6; // Default limit
+
+    // Merged geometry tracking
+    this.mergedObjectMap = new Map(); // objectId -> {mergedObject, startIndex, endIndex, vertexCount}
+    this.mergedGeometryVisibility = new Map(); // mergedObject -> visibility array
   }
 
   setVisibleEdges(visible) {
@@ -929,6 +944,59 @@ export class DynamicGltfLoader {
     this.originalObjectsToSelection.clear();
   }
 
+  initializeObjectVisibility() {
+    if (this.maxObjectId > 0) {
+      this.objectVisibility = new Float32Array(this.maxObjectId);
+      for (let i = 0; i < this.maxObjectId; i++) {
+        this.objectVisibility[i] = 1.0;
+      }
+      console.log(`Initialized object visibility array: ${this.maxObjectId} objects`);
+    }
+  }
+
+  createVisibilityMaterial(material) {
+    // Применяем шейдер напрямую к оригинальному материалу
+    material.onBeforeCompile = (shader) => {
+      shader.vertexShader = shader.vertexShader.replace(
+        "#include <common>",
+        `
+        #include <common>
+        attribute float visibility;
+        varying float vVisibility;
+        `
+      );
+
+      shader.fragmentShader = shader.fragmentShader.replace(
+        "#include <common>",
+        `
+        #include <common>
+        varying float vVisibility;
+        `
+      );
+
+      shader.vertexShader = shader.vertexShader.replace(
+        "void main() {",
+        `
+        void main() {
+          vVisibility = visibility;
+        `
+      );
+
+      shader.fragmentShader = shader.fragmentShader.replace(
+        "void main() {",
+        `
+        void main() {
+          if (vVisibility < 0.5) discard;
+        `
+      );
+    };
+
+    // Принудительная перекомпиляция материала
+    material.needsUpdate = true;
+
+    return material;
+  }
+
   clear() {
     this.chunkQueue = [];
 
@@ -939,7 +1007,6 @@ export class DynamicGltfLoader {
     });
     this.structures = [];
 
-    // Clear all nodes and unload their objects
     this.nodes.forEach((node) => {
       if (node.object) {
         if (node.object.parent) {
@@ -1025,13 +1092,11 @@ export class DynamicGltfLoader {
     });
     this.mergedPoints.clear();
 
-    // Clear all caches
     this.geometryCache.clear();
     this.materialCache.clear();
     this.textureCache.clear();
     this.loadedMaterials.clear();
 
-    // Clear all maps and sets
     this.nodesToLoad = [];
     this.handleToObjects.clear();
     this.originalObjects.clear();
@@ -1043,7 +1108,6 @@ export class DynamicGltfLoader {
     this.oldOptimizeObjects.clear();
     this.isolatedObjects = [];
 
-    // Reset counters and state
     this.totalLoadedObjects = 0;
     this.lastUpdateTime = 0;
     this.currentMemoryUsage = 0;
@@ -1051,6 +1115,10 @@ export class DynamicGltfLoader {
 
     this.abortController = new AbortController();
     this.updateMemoryIndicator();
+
+    this.objectIdToIndex.clear();
+    this.maxObjectId = 0;
+    this.objectVisibility = new Float32Array();
   }
 
   setStructureTransform(structureId, matrix) {
@@ -1224,21 +1292,52 @@ export class DynamicGltfLoader {
         this.originalObjectsToSelection.add(obj);
       }
     });
+    this.initializeObjectVisibility();
+
+    console.log(`Optimization complete. Total objects: ${this.maxObjectId}`);
 
     this.dispatchEvent("update");
   }
 
   mergeMeshGroups(materialGroups, rootGroup) {
     for (const group of materialGroups) {
+      if (!group.material) {
+        console.warn("Skipping mesh group with null material");
+        continue;
+      }
+
       try {
         const geometries = [];
         const handles = new Set();
         const optimizedObjects = [];
+        const objectMapping = new Map();
+        let currentVertexOffset = 0;
 
         for (const mesh of group.objects) {
           const geometry = mesh.geometry.clone();
           mesh.updateWorldMatrix(true, false);
           geometry.applyMatrix4(mesh.matrixWorld);
+
+          const handle = mesh.userData.handle;
+          if (!this.objectIdToIndex.has(handle)) {
+            this.objectIdToIndex.set(handle, this.maxObjectId++);
+          }
+          const objectId = this.objectIdToIndex.get(handle);
+
+          const vertexCount = geometry.attributes.position.count;
+          const objectIds = new Float32Array(vertexCount);
+          for (let i = 0; i < vertexCount; i++) {
+            objectIds[i] = objectId;
+          }
+          geometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
+
+          objectMapping.set(mesh, {
+            geometry,
+            startVertexIndex: currentVertexOffset,
+            vertexCount: geometry.attributes.position.count,
+          });
+
+          currentVertexOffset += geometry.attributes.position.count;
           geometries.push(geometry);
 
           optimizedObjects.push(mesh);
@@ -1249,16 +1348,41 @@ export class DynamicGltfLoader {
 
         if (geometries.length > 0) {
           const mergedGeometry = mergeGeometries(geometries);
+
+          // Create visibility attribute
+          const totalVertices = mergedGeometry.attributes.position.count;
+          const visibilityArray = new Float32Array(totalVertices);
+
+          // Initialize all vertices as visible (1.0)
+          for (let i = 0; i < totalVertices; i++) {
+            visibilityArray[i] = 1.0;
+          }
+
+          // Add visibility attribute to geometry
+          mergedGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
+
           if (this.useVAO) {
             this.createVAO(mergedGeometry);
           }
 
-          const mergedMesh = new Mesh(mergedGeometry, group.material);
+          // Create visibility material
+          const visibilityMaterial = this.createVisibilityMaterial(group.material);
+
+          const mergedMesh = new Mesh(mergedGeometry, visibilityMaterial);
           rootGroup.add(mergedMesh);
 
           this.mergedMesh.add(mergedMesh);
           this.optimizedOriginalMap.set(mergedMesh, optimizedObjects);
 
+          // Store object mappings with visibility tracking
+          this.mergedObjectMap.set(mergedMesh.uuid, {
+            objectMapping,
+            visibilityArray,
+            totalVertices,
+          });
+
+          this.mergedGeometryVisibility.set(mergedMesh, visibilityArray);
+
           mergedObjects.push(mergedMesh);
 
           geometries.forEach((geometry) => {
@@ -1288,8 +1412,16 @@ export class DynamicGltfLoader {
     for (const group of materialGroups) {
       if (group.objects.length === 0) continue;
 
+      if (!group.material) {
+        console.warn("Skipping line group with null material");
+        continue;
+      }
+
       const handles = new Set();
       let totalVertices = 0;
+      const objectMapping = new Map();
+      let currentVertexOffset = 0;
+
       group.objects.map((line) => {
         handles.add(line.userData.handle);
         totalVertices += line.geometry.attributes.position.count;
@@ -1306,6 +1438,18 @@ export class DynamicGltfLoader {
         const positionAttr = geometry.attributes.position;
         const vertexCount = positionAttr.count;
 
+        const handle = line.userData.handle;
+        if (!this.objectIdToIndex.has(handle)) {
+          this.objectIdToIndex.set(handle, this.maxObjectId++);
+        }
+        // const objectId = this.objectIdToIndex.get(handle);
+
+        objectMapping.set(line, {
+          startVertexIndex: currentVertexOffset,
+          vertexCount,
+        });
+        currentVertexOffset += vertexCount;
+
         line.updateWorldMatrix(true, false);
         const matrix = line.matrixWorld;
         const vector = new Vector3();
@@ -1331,7 +1475,28 @@ export class DynamicGltfLoader {
       geometry.computeBoundingSphere();
       geometry.computeBoundingBox();
 
-      const mergedLine = new LineSegments(geometry, group.material);
+      const objectIds = new Float32Array(totalVertices);
+      let vertexIndex = 0;
+      group.objects.forEach((line) => {
+        const vertexCount = line.geometry.attributes.position.count;
+        const handle = line.userData.handle;
+        const objectId = this.objectIdToIndex.get(handle);
+
+        for (let i = 0; i < vertexCount; i++) {
+          objectIds[vertexIndex++] = objectId;
+        }
+      });
+      geometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
+
+      const visibilityArray = new Float32Array(totalVertices);
+      for (let i = 0; i < totalVertices; i++) {
+        visibilityArray[i] = 1.0;
+      }
+      geometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
+
+      const visibilityMaterial = this.createVisibilityMaterial(group.material);
+
+      const mergedLine = new LineSegments(geometry, visibilityMaterial);
       const mergedObjects = [mergedLine];
       if (this.useVAO) {
         this.createVAO(mergedLine);
@@ -1340,6 +1505,14 @@ export class DynamicGltfLoader {
       this.mergedLines.add(mergedLine);
       this.optimizedOriginalMap.set(mergedLine, group.objects);
 
+      this.mergedObjectMap.set(mergedLine.uuid, {
+        objectMapping,
+        visibilityArray,
+        totalVertices,
+      });
+
+      this.mergedGeometryVisibility.set(mergedLine, visibilityArray);
+
       handles.forEach((handle) => {
         if (this.handleToOptimizedObjects.has(handle)) {
           const existingObjects = this.handleToOptimizedObjects.get(handle);
@@ -1354,15 +1527,42 @@ export class DynamicGltfLoader {
 
   mergeLineSegmentGroups(materialGroups, rootGroup) {
     for (const group of materialGroups) {
+      if (!group.material) {
+        console.warn("Skipping line segment group with null material");
+        continue;
+      }
+
       try {
         const geometries = [];
         const optimizedObjects = [];
         const handles = new Set();
+        const objectMapping = new Map();
+        let currentVertexOffset = 0;
 
         for (const line of group.objects) {
           const geometry = line.geometry.clone();
           line.updateWorldMatrix(true, false);
           geometry.applyMatrix4(line.matrixWorld);
+
+          const handle = line.userData.handle;
+          if (!this.objectIdToIndex.has(handle)) {
+            this.objectIdToIndex.set(handle, this.maxObjectId++);
+          }
+          const objectId = this.objectIdToIndex.get(handle);
+          const vertexCount = geometry.attributes.position.count;
+          const objectIds = new Float32Array(vertexCount);
+          for (let i = 0; i < vertexCount; i++) {
+            objectIds[i] = objectId;
+          }
+          geometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
+
+          objectMapping.set(line, {
+            geometry,
+            startVertexIndex: currentVertexOffset,
+            vertexCount: geometry.attributes.position.count,
+          });
+
+          currentVertexOffset += geometry.attributes.position.count;
           geometries.push(geometry);
           optimizedObjects.push(line);
           handles.add(line.userData.handle);
@@ -1372,7 +1572,19 @@ export class DynamicGltfLoader {
 
         if (geometries.length > 0) {
           const mergedGeometry = mergeGeometries(geometries, false);
-          const mergedLine = new LineSegments(mergedGeometry, group.material);
+
+          const totalVertices = mergedGeometry.attributes.position.count;
+          const visibilityArray = new Float32Array(totalVertices);
+
+          for (let i = 0; i < totalVertices; i++) {
+            visibilityArray[i] = 1.0;
+          }
+
+          mergedGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
+
+          const visibilityMaterial = this.createVisibilityMaterial(group.material);
+
+          const mergedLine = new LineSegments(mergedGeometry, visibilityMaterial);
 
           if (this.useVAO) {
             this.createVAO(mergedLine);
@@ -1381,6 +1593,15 @@ export class DynamicGltfLoader {
           rootGroup.add(mergedLine);
           this.mergedLineSegments.add(mergedLine);
           this.optimizedOriginalMap.set(mergedLine, optimizedObjects);
+
+          this.mergedObjectMap.set(mergedLine.uuid, {
+            objectMapping,
+            visibilityArray,
+            totalVertices,
+          });
+
+          this.mergedGeometryVisibility.set(mergedLine, visibilityArray);
+
           mergedObjects.push(mergedLine);
 
           geometries.forEach((geometry) => {
@@ -1408,6 +1629,11 @@ export class DynamicGltfLoader {
 
   mergePointsGroups(materialGroups, rootGroup) {
     for (const group of materialGroups) {
+      if (!group.material) {
+        console.warn("Skipping points group with null material");
+        continue;
+      }
+
       try {
         const geometries = [];
         const optimizedObjects = [];
@@ -1631,116 +1857,57 @@ export class DynamicGltfLoader {
     this.syncHiddenObjects();
   }
 
-  syncHiddenObjects() {
-    if (this.oldOptimizeObjects.size !== 0) {
-      for (const obj of this.oldOptimizeObjects) {
-        obj.visible = true;
-      }
-      this.oldOptimizeObjects.clear();
-    }
+  _updateVisibilityAttribute(mergedObject) {
+    if (
+      mergedObject.geometry &&
+      mergedObject.geometry.attributes.visibility &&
+      mergedObject.geometry.attributes.objectId
+    ) {
+      const visibilityArray = mergedObject.geometry.attributes.visibility.array;
+      const objectIdArray = mergedObject.geometry.attributes.objectId.array;
 
-    if (this.newOptimizedObjects.size !== 0) {
-      for (const obj of this.newOptimizedObjects) {
-        obj.visible = false;
-        obj.geometry.dispose();
-        obj.parent.remove(obj);
+      for (let i = 0; i < visibilityArray.length; i++) {
+        const objectId = objectIdArray[i];
+        if (objectId < this.objectVisibility.length) {
+          visibilityArray[i] = this.objectVisibility[objectId];
+        }
       }
-      this.newOptimizedObjects.clear();
+
+      mergedObject.geometry.attributes.visibility.needsUpdate = true;
     }
+  }
 
-    if (this.hiddenHandles.size === 0) {
+  syncHiddenObjects() {
+    if (this.mergedObjectMap.size === 0) {
+      console.log("No merged objects to sync");
       return;
     }
 
-    this.hiddenHandles.forEach((handle) => {
-      const objects = this.handleToOptimizedObjects.get(handle);
-      if (objects) {
-        objects.forEach((x) => this.oldOptimizeObjects.add(x));
+    if (this.objectVisibility.length > 0) {
+      for (let i = 0; i < this.objectVisibility.length; i++) {
+        this.objectVisibility[i] = 1.0;
       }
-    });
 
-    this.oldOptimizeObjects.forEach((optimizedObject) => {
-      optimizedObject.visible = false;
-
-      const originObjects = this.optimizedOriginalMap.get(optimizedObject);
-      const updateListToOptimize = [];
-      originObjects.forEach((obj) => {
-        if (!this.hiddenHandles.has(obj.userData.handle)) {
-          updateListToOptimize.push(obj);
+      this.hiddenHandles.forEach((handle) => {
+        const index = this.objectIdToIndex.get(handle);
+        if (index !== undefined && index < this.objectVisibility.length) {
+          this.objectVisibility[index] = 0.0;
         }
       });
+    }
 
-      const firstObject = updateListToOptimize[0];
-
-      if (firstObject instanceof Mesh || firstObject instanceof LineSegments) {
-        const geometries = updateListToOptimize.map((obj) => {
-          const geometry = obj.geometry.clone();
-          obj.updateWorldMatrix(true, false);
-          geometry.applyMatrix4(obj.matrixWorld);
-          return geometry;
-        });
-
-        const newMergedGeometry = mergeGeometries(geometries);
-        const mergedObject =
-          firstObject instanceof Mesh
-            ? new Mesh(newMergedGeometry, optimizedObject.material)
-            : new LineSegments(newMergedGeometry, optimizedObject.material);
-
-        mergedObject.visible = true;
-        optimizedObject.parent.add(mergedObject);
-        this.newOptimizedObjects.add(mergedObject);
-
-        geometries.forEach((geometry) => {
-          geometry.dispose();
-        });
-      } else if (firstObject instanceof Line) {
-        let totalVertices = 0;
-        updateListToOptimize.map((line) => {
-          totalVertices += line.geometry.attributes.position.count;
-        });
-
-        const positions = new Float32Array(totalVertices * 3);
-        let posOffset = 0;
-
-        const indices = [];
-        let vertexOffset = 0;
-
-        updateListToOptimize.forEach((line) => {
-          const geometry = line.geometry;
-          const positionAttr = geometry.attributes.position;
-          const vertexCount = positionAttr.count;
-
-          line.updateWorldMatrix(true, false);
-          const matrix = line.matrixWorld;
-          const vector = new Vector3();
-
-          for (let i = 0; i < vertexCount; i++) {
-            vector.fromBufferAttribute(positionAttr, i);
-            vector.applyMatrix4(matrix);
-            positions[posOffset++] = vector.x;
-            positions[posOffset++] = vector.y;
-            positions[posOffset++] = vector.z;
-          }
-
-          for (let i = 0; i < vertexCount - 1; i++) {
-            indices.push(vertexOffset + i, vertexOffset + i + 1);
-          }
-
-          vertexOffset += vertexCount;
-        });
-
-        const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new BufferAttribute(positions, 3));
-        geometry.setIndex(indices);
-        geometry.computeBoundingSphere();
-        geometry.computeBoundingBox();
-
-        const mergedLine = new LineSegments(geometry, optimizedObject.material);
-        mergedLine.visible = true;
-        optimizedObject.parent.add(mergedLine);
-        this.newOptimizedObjects.add(mergedLine);
-      }
-    });
+    for (const mesh of this.mergedMesh) {
+      this._updateVisibilityAttribute(mesh);
+    }
+    for (const line of this.mergedLines) {
+      this._updateVisibilityAttribute(line);
+    }
+    for (const lineSegment of this.mergedLineSegments) {
+      this._updateVisibilityAttribute(lineSegment);
+    }
+    for (const point of this.mergedPoints) {
+      this._updateVisibilityAttribute(point);
+    }
   }
 
   getStructureGeometryExtent(structureId) {