@inweb/viewer-three 26.7.6 → 26.8.0

package/lib/Viewer/components/HighlighterComponent.d.ts

@@ -1,11 +1,11 @@
-import { LineBasicMaterial, MeshBasicMaterial, Object3D, WebGLRenderTarget } from "three";
+import { LineBasicMaterial, MeshPhongMaterial, Object3D, WebGLRenderTarget } from "three";
 import { LineMaterial } from "three/examples/jsm/lines/LineMaterial.js";
 import { IComponent, ResizeEvent } from "@inweb/viewer-core";
 import { Viewer } from "../Viewer";
 export declare class HighlighterComponent implements IComponent {
     protected viewer: Viewer;
     renderTarget: WebGLRenderTarget;
-    highlightMaterial: MeshBasicMaterial;
+    highlightMaterial: MeshPhongMaterial;
     outlineMaterial: LineMaterial;
     highlightLineMaterial: LineBasicMaterial;
     highlightLineGlowMaterial: LineMaterial;

package/lib/Viewer/loaders/GLTFCloudDynamicLoader.d.ts

@@ -1,10 +1,8 @@
-import { Group } from "three";
 import { ILoader, LoadParams } from "@inweb/viewer-core";
 import { Viewer } from "../Viewer";
 import { DynamicGltfLoader } from "./DynamicGltfLoader/DynamicGltfLoader.js";
 export declare class GLTFCloudDynamicLoader implements ILoader {
     viewer: Viewer;
-    scene: Group;
     gltfLoader: DynamicGltfLoader;
     requestId: number;
     constructor(viewer: Viewer);

package/lib/Viewer/loaders/index.d.ts

@@ -11,7 +11,7 @@ import { ILoadersRegistry } from "@inweb/viewer-core";
  *
  *    The loader should do:
  *
- *    - Load scene from file. The scene must be a Three.js object of type `Object3D` or a descendant of it.
+ *    - Load raw data from file and convert it to the `Three.js` scene.
  *    - Add scene to the viewer `scene`.
  *    - Create `ModelImpl` for the scene and to the viewer `models` list.
  *    - Synchronize viewer options and overlay.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inweb/viewer-three",
-  "version": "26.7.6",
+  "version": "26.8.0",
   "description": "JavaScript library for rendering CAD and BIM files in a browser using Three.js",
   "homepage": "https://cloud.opendesign.com/docs/index.html",
   "license": "SEE LICENSE IN LICENSE",
@@ -35,10 +35,10 @@
     "docs": "typedoc"
   },
   "dependencies": {
-    "@inweb/client": "~26.7.6",
-    "@inweb/eventemitter2": "~26.7.6",
-    "@inweb/markup": "~26.7.6",
-    "@inweb/viewer-core": "~26.7.6"
+    "@inweb/client": "~26.8.0",
+    "@inweb/eventemitter2": "~26.8.0",
+    "@inweb/markup": "~26.8.0",
+    "@inweb/viewer-core": "~26.8.0"
   },
   "devDependencies": {
     "@types/three": "^0.173.0",

package/src/Viewer/commands/SetSelected.ts

@@ -30,6 +30,7 @@ export function setSelected(viewer: Viewer, handles: string[] = []): void {
 
   viewer.models.forEach((model) => {
     const objects = model.getObjectsByHandles(handles);
+    model.showObjects(objects);
     selection.select(objects, model);
   });
 

package/src/Viewer/commands/index.ts

@@ -80,9 +80,9 @@ commands.registerCommand("applyModelTransform", applyModelTransform);
 commands.registerCommand("clearMarkup", clearMarkup);
 commands.registerCommand("clearSelected", clearSelected);
 commands.registerCommand("clearSlices", clearSlices);
+commands.registerCommand("collect", collect);
 commands.registerCommand("createPreview", createPreview);
 commands.registerCommand("explode", explode);
-commands.registerCommand("collect", collect);
 commands.registerCommand("getDefaultViewPositions", getDefaultViewPositions);
 commands.registerCommand("getModels", getModels);
 commands.registerCommand("getSelected", getSelected);

package/src/Viewer/components/HighlighterComponent.ts

@@ -25,7 +25,7 @@ import {
   Color,
   EdgesGeometry,
   LineBasicMaterial,
-  MeshBasicMaterial,
+  MeshPhongMaterial,
   Object3D,
   RGBAFormat,
   UnsignedByteType,
@@ -43,7 +43,7 @@ import { HighlighterUtils } from "./HighlighterUtils";
 export class HighlighterComponent implements IComponent {
   protected viewer: Viewer;
   public renderTarget: WebGLRenderTarget;
-  public highlightMaterial: MeshBasicMaterial;
+  public highlightMaterial: MeshPhongMaterial;
   public outlineMaterial: LineMaterial;
   public highlightLineMaterial: LineBasicMaterial;
   public highlightLineGlowMaterial: LineMaterial;
@@ -76,6 +76,8 @@ export class HighlighterComponent implements IComponent {
   }
 
   highlight(objects: Object3D | Object3D[]) {
+    const { edgesVisibility } = this.viewer.options;
+
     if (!Array.isArray(objects)) objects = [objects];
     if (!objects.length) return;
 
@@ -93,25 +95,27 @@ export class HighlighterComponent implements IComponent {
         wireframe.position.copy(object.position);
         wireframe.rotation.copy(object.rotation);
         wireframe.scale.copy(object.scale);
+        wireframe.visible = edgesVisibility;
 
         object.parent.add(wireframe);
+        object.userData.highlightWireframe = wireframe;
 
-        object.userData.highlightwireframe = wireframe;
         object.userData.originalMaterial = object.material;
         object.material = this.highlightLineMaterial;
         object.isHighlighted = true;
       } else if (object.isMesh) {
-        const edgesGeometry = new EdgesGeometry(object.geometry, 30);
+        const edgesGeometry = new EdgesGeometry(object.geometry, 60);
         const lineGeometry = new LineSegmentsGeometry().fromEdgesGeometry(edgesGeometry);
 
         const wireframe = new Wireframe(lineGeometry, this.outlineMaterial);
         wireframe.position.copy(object.position);
         wireframe.rotation.copy(object.rotation);
         wireframe.scale.copy(object.scale);
+        wireframe.visible = edgesVisibility;
 
         object.parent.add(wireframe);
+        object.userData.highlightWireframe = wireframe;
 
-        object.userData.highlightwireframe = wireframe;
         object.userData.originalMaterial = object.material;
         object.material = this.highlightMaterial;
         object.isHighlighted = true;
@@ -128,29 +132,35 @@ export class HighlighterComponent implements IComponent {
 
       object.isHighlighted = false;
       object.material = object.userData.originalMaterial;
-      object.userData.highlightwireframe.removeFromParent();
+      object.userData.highlightWireframe.removeFromParent();
 
       delete object.userData.originalMaterial;
-      delete object.userData.highlightwireframe;
+      delete object.userData.highlightWireframe;
     });
   }
 
   geometryEnd = () => {
-    const { facesColor, facesTransparancy, edgesColor } = this.viewer.options;
+    const { facesColor, facesTransparancy, edgesColor, edgesOverlap, facesOverlap } = this.viewer.options;
 
-    this.highlightMaterial = new MeshBasicMaterial({
+    this.highlightMaterial = new MeshPhongMaterial({
       color: new Color(facesColor.r / 255, facesColor.g / 255, facesColor.b / 255),
       transparent: true,
       opacity: (255 - facesTransparancy) / 255,
-      depthTest: false,
-      depthWrite: false,
+      depthTest: !facesOverlap,
+      depthWrite: !facesOverlap,
+      specular: 0x222222,
+      shininess: 10,
+      reflectivity: 0.05,
+      polygonOffset: true,
+      polygonOffsetFactor: 1,
+      polygonOffsetUnits: 1,
     });
 
     this.outlineMaterial = new LineMaterial({
       color: new Color(edgesColor.r / 255, edgesColor.g / 255, edgesColor.b / 255),
       linewidth: 1.5,
-      depthTest: false,
-      depthWrite: false,
+      depthTest: !edgesOverlap,
+      depthWrite: !edgesOverlap,
       resolution: new Vector2(window.innerWidth, window.innerHeight),
     });
 
@@ -165,21 +175,33 @@ export class HighlighterComponent implements IComponent {
       linewidth: 5,
       transparent: true,
       opacity: 0.8,
-      depthTest: true,
-      depthWrite: true,
+      depthTest: !edgesOverlap,
+      depthWrite: !edgesOverlap,
       resolution: new Vector2(window.innerWidth, window.innerHeight),
     });
   };
 
   optionsChange = () => {
-    const { facesColor, facesTransparancy, edgesColor } = this.viewer.options;
+    const { facesColor, facesTransparancy, edgesColor, edgesVisibility, edgesOverlap, facesOverlap } =
+      this.viewer.options;
 
     this.highlightMaterial.color.setRGB(facesColor.r / 255, facesColor.g / 255, facesColor.b / 255);
     this.highlightMaterial.opacity = (255 - facesTransparancy) / 255;
+    this.highlightMaterial.depthTest = !facesOverlap;
+    this.highlightMaterial.depthWrite = !facesOverlap;
+
     this.outlineMaterial.color.setRGB(edgesColor.r / 255, edgesColor.g / 255, edgesColor.b / 255);
+    this.outlineMaterial.depthTest = !edgesOverlap;
+    this.outlineMaterial.depthWrite = !edgesOverlap;
+
     this.highlightLineMaterial.color.setRGB(facesColor.r / 255, facesColor.g / 255, facesColor.b / 255);
     this.highlightLineGlowMaterial.color.setRGB(facesColor.r / 255, facesColor.g / 255, facesColor.b / 255);
 
+    this.viewer.selected.forEach((selected) => {
+      const wireframe = selected.userData.highlightWireframe;
+      if (wireframe) wireframe.visible = edgesVisibility;
+    });
+
     this.viewer.update();
   };
 

package/src/Viewer/components/LightComponent.ts

@@ -36,20 +36,10 @@ export class LightComponent implements IComponent {
   constructor(viewer: Viewer) {
     this.viewer = viewer;
 
-    this.ambientLight = new AmbientLight(0xffffff, 1);
-    this.viewer.scene.add(this.ambientLight);
-
-    this.directionalLight = new DirectionalLight(0xffffff, 1);
-    this.directionalLight.position.set(0.5, 0, 0.866); // ~60º
-    this.viewer.scene.add(this.directionalLight);
-
+    this.ambientLight = new AmbientLight(0xffffff, 1.0);
+    this.directionalLight = new DirectionalLight(0xffffff, 1.0);
     this.frontLight = new DirectionalLight(0xffffff, 1.25);
-    this.frontLight.position.set(0, 1, 0);
-    this.viewer.scene.add(this.frontLight);
-
     this.hemisphereLight = new HemisphereLight(0xffffff, 0x444444, 1.25);
-    this.hemisphereLight.position.set(0, 0, 1);
-    this.viewer.scene.add(this.hemisphereLight);
 
     this.viewer.addEventListener("databasechunk", this.geometryEnd);
     this.viewer.addEventListener("clear", this.geometryEnd);
@@ -84,15 +74,21 @@ export class LightComponent implements IComponent {
     const extentsSize = this.viewer.extents.getBoundingSphere(new Sphere()).radius;
 
     this.directionalLight.position
-      .set(0.5, 0, 0.866)
+      .set(0.5, 0.866, 0) // ~60º
       .multiplyScalar(extentsSize * 2)
       .add(extentsCenter);
     this.directionalLight.target.position.copy(extentsCenter);
 
-    this.frontLight.position.set(0, extentsSize * 2, 0).add(extentsCenter);
+    this.frontLight.position
+      .set(0, 0, 1)
+      .multiplyScalar(extentsSize * 2)
+      .add(extentsCenter);
     this.frontLight.target.position.copy(extentsCenter);
 
-    this.hemisphereLight.position.set(0, extentsSize * 3, 0).add(extentsCenter);
+    this.hemisphereLight.position
+      .set(0, 0, 1)
+      .multiplyScalar(extentsSize * 3)
+      .add(extentsCenter);
 
     this.viewer.scene.add(this.ambientLight);
     this.viewer.scene.add(this.directionalLight);

package/src/Viewer/components/SelectionComponent.ts

@@ -68,7 +68,7 @@ export class SelectionComponent implements IComponent {
     this.viewer.models.forEach((model) => {
       const objects = model.getVisibleObjects();
       const intersects = this.getPointerIntersects(upPosition, objects);
-      intersections.push(...intersects.map((x) => ({ ...x, model })));
+      if (intersects.length > 0) intersections.push({ ...intersects[0], model });
     });
     intersections = intersections.sort((a, b) => a.distance - b.distance);
 
@@ -126,7 +126,6 @@ export class SelectionComponent implements IComponent {
     if (!Array.isArray(objects)) objects = [objects];
     if (!objects.length) return;
 
-    model.showObjects(objects);
     model.showOriginalObjects(objects);
     this.highlighter.highlight(objects);
 

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

@@ -86,7 +86,9 @@ export class DynamicGltfLoader {
     this.mergedPoints = new Set();
 
     this.isolatedObjects = [];
-    this.useVAO = !!window.WebGL2RenderingContext && this.renderer.getContext() instanceof WebGL2RenderingContext;
+    //!!window.WebGL2RenderingContext && this.renderer.getContext() instanceof WebGL2RenderingContext
+    this.useVAO = false;
+    this.visibleEdges = true;
 
     this.handleToOptimizedObjects = new Map();
 
@@ -95,6 +97,10 @@ export class DynamicGltfLoader {
     this.oldOptimizeObjects = new Set();
   }
 
+  setVisibleEdges(visible) {
+    this.visibleEdges = visible;
+  }
+
   getAvailableMemory() {
     let memoryLimit = 6 * 1024 * 1024 * 1024;
     try {
@@ -115,7 +121,7 @@ export class DynamicGltfLoader {
       console.warn("Error detecting available memory:", error);
     }
 
-    return memoryLimit;
+    return memoryLimit / 3;
   }
 
   getAbortController() {
@@ -220,7 +226,7 @@ export class DynamicGltfLoader {
     console.log(`Final memory usage: ${Math.round(currentMemoryUsage / (1024 * 1024))}MB`);
   }
 
-  async loadNode(nodeId) {
+  async loadNode(nodeId, onLoadFinishCb) {
     const node = this.nodes.get(nodeId);
     if (!node || node.loaded || node.loading) return;
 
@@ -228,38 +234,138 @@ export class DynamicGltfLoader {
     const meshDef = node.structure.getJson().meshes[node.meshIndex];
 
     try {
-      for (const primitive of meshDef.primitives) {
-        const positionAccessor = primitive.attributes.POSITION;
-        const geometry = new BufferGeometry();
-        const attributes = new Map();
-
-        attributes.set("position", node.structure.createBufferAttribute(positionAccessor));
+      const bufferRequests = [];
+      const primitiveReqMap = new Map();
+      for (let primIdx = 0; primIdx < meshDef.primitives.length; primIdx++) {
+        const primitive = meshDef.primitives[primIdx];
+        const reqs = [];
+
+        if (primitive.attributes.POSITION !== undefined) {
+          const accessorIndex = primitive.attributes.POSITION;
+          const accessor = node.structure.json.accessors[accessorIndex];
+          const bufferView = node.structure.json.bufferViews[accessor.bufferView];
+          const byteOffset = (bufferView.byteOffset || 0) + (accessor.byteOffset || 0);
+          const components = node.structure.getNumComponents(accessor.type);
+          const count = accessor.count;
+          const byteLength = count * components * node.structure.getComponentSize(accessor.componentType);
+          reqs.push({
+            offset: byteOffset,
+            length: byteLength,
+            componentType: accessor.componentType,
+            accessorIndex,
+            type: "position",
+            primIdx,
+          });
+        }
 
         if (primitive.attributes.NORMAL !== undefined) {
-          attributes.set("normal", node.structure.createBufferAttribute(primitive.attributes.NORMAL));
+          const accessorIndex = primitive.attributes.NORMAL;
+          const accessor = node.structure.json.accessors[accessorIndex];
+          const bufferView = node.structure.json.bufferViews[accessor.bufferView];
+          const byteOffset = (bufferView.byteOffset || 0) + (accessor.byteOffset || 0);
+          const components = node.structure.getNumComponents(accessor.type);
+          const count = accessor.count;
+          const byteLength = count * components * node.structure.getComponentSize(accessor.componentType);
+          reqs.push({
+            offset: byteOffset,
+            length: byteLength,
+            componentType: accessor.componentType,
+            accessorIndex,
+            type: "normal",
+            primIdx,
+          });
         }
 
         if (primitive.attributes.TEXCOORD_0 !== undefined) {
-          attributes.set("uv", node.structure.createBufferAttribute(primitive.attributes.TEXCOORD_0));
+          const accessorIndex = primitive.attributes.TEXCOORD_0;
+          const accessor = node.structure.json.accessors[accessorIndex];
+          const bufferView = node.structure.json.bufferViews[accessor.bufferView];
+          const byteOffset = (bufferView.byteOffset || 0) + (accessor.byteOffset || 0);
+          const components = node.structure.getNumComponents(accessor.type);
+          const count = accessor.count;
+          const byteLength = count * components * node.structure.getComponentSize(accessor.componentType);
+          reqs.push({
+            offset: byteOffset,
+            length: byteLength,
+            componentType: accessor.componentType,
+            accessorIndex,
+            type: "uv",
+            primIdx,
+          });
         }
 
-        const loadedAttributes = await Promise.all(
-          [...attributes.entries()].map(async ([name, promise]) => {
-            const attribute = await promise;
-            return [name, attribute];
-          })
-        );
+        if (primitive.indices !== undefined) {
+          const accessorIndex = primitive.indices;
+          const accessor = node.structure.json.accessors[accessorIndex];
+          const bufferView = node.structure.json.bufferViews[accessor.bufferView];
+          const byteOffset = (bufferView.byteOffset || 0) + (accessor.byteOffset || 0);
+          const components = node.structure.getNumComponents(accessor.type);
+          const count = accessor.count;
+          const byteLength = count * components * node.structure.getComponentSize(accessor.componentType);
+          reqs.push({
+            offset: byteOffset,
+            length: byteLength,
+            componentType: accessor.componentType,
+            accessorIndex,
+            type: "index",
+            primIdx,
+          });
+        }
+        primitiveReqMap.set(primIdx, reqs);
+        bufferRequests.push(...reqs);
+      }
 
-        loadedAttributes.forEach(([name, attribute]) => {
-          geometry.setAttribute(name, attribute);
-        });
+      if (bufferRequests.length === 0) {
+        node.loaded = true;
+        node.loading = false;
+        return;
+      }
+      bufferRequests.sort((a, b) => a.offset - b.offset);
+      const minOffset = bufferRequests[0].offset;
+      const maxOffset = Math.max(...bufferRequests.map((r) => r.offset + r.length));
+      const totalLength = maxOffset - minOffset;
+
+      const { buffer, relOffset: baseRelOffset } = await node.structure.scheduleRequest({
+        offset: minOffset,
+        length: totalLength,
+        componentType: null,
+      });
 
-        if (primitive.indices !== undefined) {
-          const indexAttribute = await node.structure.createBufferAttribute(primitive.indices);
-          geometry.setIndex(indexAttribute);
+      for (const req of bufferRequests) {
+        const relOffset = req.offset - minOffset;
+        req.data = node.structure.createTypedArray(buffer, baseRelOffset + relOffset, req.length, req.componentType);
+      }
+
+      for (let primIdx = 0; primIdx < meshDef.primitives.length; primIdx++) {
+        const primitive = meshDef.primitives[primIdx];
+        const geometry = new BufferGeometry();
+        const reqs = primitiveReqMap.get(primIdx);
+
+        if (primitive.attributes.POSITION !== undefined) {
+          const req = reqs.find((r) => r.type === "position" && r.accessorIndex === primitive.attributes.POSITION);
+          const accessor = node.structure.json.accessors[primitive.attributes.POSITION];
+          const components = node.structure.getNumComponents(accessor.type);
+          geometry.setAttribute("position", new BufferAttribute(req.data, components));
         }
 
-        this.currentPrimitiveMode = primitive.mode;
+        if (primitive.attributes.NORMAL !== undefined) {
+          const req = reqs.find((r) => r.type === "normal" && r.accessorIndex === primitive.attributes.NORMAL);
+          const accessor = node.structure.json.accessors[primitive.attributes.NORMAL];
+          const components = node.structure.getNumComponents(accessor.type);
+          geometry.setAttribute("normal", new BufferAttribute(req.data, components));
+        }
+
+        if (primitive.attributes.TEXCOORD_0 !== undefined) {
+          const req = reqs.find((r) => r.type === "uv" && r.accessorIndex === primitive.attributes.TEXCOORD_0);
+          const accessor = node.structure.json.accessors[primitive.attributes.TEXCOORD_0];
+          const components = node.structure.getNumComponents(accessor.type);
+          geometry.setAttribute("uv", new BufferAttribute(req.data, components));
+        }
+
+        if (primitive.indices !== undefined) {
+          const req = reqs.find((r) => r.type === "index" && r.accessorIndex === primitive.indices);
+          geometry.setIndex(new BufferAttribute(req.data, 1));
+        }
 
         let material;
         if (primitive.material !== undefined) {
@@ -274,8 +380,7 @@ export class DynamicGltfLoader {
           Material.prototype.copy.call(pointsMaterial, material);
           pointsMaterial.color.copy(material.color);
           pointsMaterial.map = material.map;
-          pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px
-
+          pointsMaterial.sizeAttenuation = false;
           mesh = new Points(geometry, pointsMaterial);
         } else if (
           primitive.mode === GL_CONSTANTS.TRIANGLES ||
@@ -284,7 +389,6 @@ export class DynamicGltfLoader {
           primitive.mode === undefined
         ) {
           mesh = new Mesh(geometry, material);
-
           if (primitive.mode === GL_CONSTANTS.TRIANGLE_STRIP) {
             mesh.drawMode = TriangleStripDrawMode;
           } else if (primitive.mode === GL_CONSTANTS.TRIANGLE_FAN) {
@@ -297,39 +401,30 @@ export class DynamicGltfLoader {
         } else if (primitive.mode === GL_CONSTANTS.LINE_LOOP) {
           mesh = new LineLoop(geometry, material);
         }
-
         if (node.extras) {
           mesh.userData = { ...mesh.userData, ...node.extras };
         }
-
         if (meshDef.extras) {
           mesh.userData = { ...mesh.userData, ...meshDef.extras };
         }
-
         if (primitive.extras) {
           mesh.userData = { ...mesh.userData, ...primitive.extras };
         }
-
         if (node.handle) {
           mesh.userData.handle = node.handle;
         } else {
           mesh.userData.handle = `${node.structure.id}_${mesh.userData.handle}`;
         }
-
         if (mesh.material.name === "edges") {
           mesh.userData.isEdge = true;
         } else {
           mesh.userData.isEdge = false;
         }
-
         this.registerObjectWithHandle(mesh, mesh.userData.handle);
-
         mesh.position.copy(node.position);
-
         if (!geometry.attributes.normal) {
           geometry.computeVertexNormals();
         }
-
         if (material.aoMap && geometry.attributes.uv) {
           geometry.setAttribute("uv2", geometry.attributes.uv);
         }
@@ -339,17 +434,17 @@ export class DynamicGltfLoader {
           this.scene.add(mesh);
         }
         node.object = mesh;
-
         this.totalLoadedObjects++;
         mesh.visible = this.totalLoadedObjects < this.graphicsObjectLimit;
       }
-
       node.loaded = true;
       node.loading = false;
-
       const geometrySize = this.estimateGeometrySize(node.object);
       this.geometryCache.set(node.object.uuid, geometrySize);
       this.currentMemoryUsage += geometrySize;
+      if (onLoadFinishCb) {
+        onLoadFinishCb();
+      }
     } catch (error) {
       if (error.name !== "AbortError") {
         console.error(`Error loading node ${nodeId}:`, error);
@@ -474,7 +569,7 @@ export class DynamicGltfLoader {
       return volumeB - volumeA;
     });
 
-    if (!ignoreEdges) {
+    if (!ignoreEdges && this.visibleEdges) {
       this.nodesToLoad.push(...this.edgeNodes);
     }
 
@@ -601,33 +696,13 @@ export class DynamicGltfLoader {
   async processNodes() {
     const nodesToLoad = this.nodesToLoad;
     let loadedCount = 0;
+    let lastLoadedCount = 0;
     const totalNodes = nodesToLoad.length;
 
-    try {
-      while (loadedCount < totalNodes) {
-        const batch = nodesToLoad.slice(loadedCount, loadedCount + this.batchSize);
-        const batchPromises = [];
-
-        for (const nodeId of batch) {
-          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;
-          }
-
-          batchPromises.push(this.loadNode(nodeId));
-        }
-
-        await Promise.all(batchPromises);
-        loadedCount += batch.length;
-
+    const loadProgress = async () => {
+      loadedCount++;
+      if (loadedCount - lastLoadedCount > 1000) {
+        lastLoadedCount = loadedCount;
         this.updateMemoryIndicator();
         this.dispatchEvent("geometryprogress", {
           percentage: Math.round((loadedCount / totalNodes) * 100),
@@ -645,6 +720,34 @@ export class DynamicGltfLoader {
           setTimeout(resolve, 0);
         });
       }
+    };
+
+    try {
+      const loadOperations = [];
+      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;
+        }
+
+        loadOperations.push(this.loadNode(nodeId, loadProgress));
+      }
+
+      for (const structure of this.structures) {
+        loadOperations.push(structure.flushBufferRequests());
+      }
+
+      await Promise.all(loadOperations);
 
       this.dispatchEvent("geometryend", {
         totalLoaded: loadedCount,
@@ -1625,4 +1728,23 @@ export class DynamicGltfLoader {
       }
     });
   }
+
+  // Возвращает bounding box для конкретной структуры
+  getStructureGeometryExtent(structureId) {
+    const extent = new Box3();
+    for (const [nodeId, node] of this.nodes.entries()) {
+      if (!node.geometryExtents) continue;
+      if (!nodeId.startsWith(structureId + "_")) continue;
+      if (node.object && this.hiddenHandles && this.hiddenHandles.has(node.object.userData.handle)) continue;
+      const transformedBox = node.geometryExtents.clone();
+      if (node.group && node.group.matrix) {
+        transformedBox.applyMatrix4(node.group.matrix);
+        if (node.group.parent && node.group.parent.matrix) {
+          transformedBox.applyMatrix4(node.group.parent.matrix);
+        }
+      }
+      extent.union(transformedBox);
+    }
+    return extent;
+  }
 }