@inweb/viewer-three 26.9.0 → 26.9.2

package/dist/plugins/loaders/PotreeLoader.module.js

@@ -0,0 +1,68 @@
+import { ModelImpl, Loader, loaders } from "@inweb/viewer-three";
+
+import { Potree, PointColorType, PointSizeType, PointShape } from "potree-core";
+
+class PotreeModelImpl extends ModelImpl {
+    getExtents(target) {
+        return target.union(this.pco.pcoGeometry.boundingBox);
+    }
+}
+
+class PotreeFileLoader extends Loader {
+    constructor(viewer) {
+        super();
+        this.updatePointClouds = () => {
+            const result = this.potree.updatePointClouds(this.pointClouds, this.viewer.camera, this.viewer.renderer);
+            if (result.exceededMaxLoadsToGPU || result.nodeLoadPromises.length > 0) this.viewer.update();
+        };
+        this.viewer = viewer;
+        this.potree = new Potree;
+        this.pointClouds = [];
+        this.viewer.addEventListener("render", this.updatePointClouds);
+        this.viewer.addEventListener("changecamera", this.updatePointClouds);
+    }
+    dispose() {
+        this.pointClouds.forEach((pco => pco.dispose()));
+        this.viewer.removeEventListener("render", this.updatePointClouds);
+        this.viewer.removeEventListener("changecamera", this.updatePointClouds);
+    }
+    isSupport(file, format) {
+        return typeof file === "string" && /(cloud.js|metadata.json)$/i.test(file);
+    }
+    async load(file, format, params = {}) {
+        const path = (params.path || "") + file;
+        const index = path.lastIndexOf("/");
+        const baseUrl = path.slice(0, index + 1);
+        const url = path.slice(index + 1);
+        const pco = await this.potree.loadPointCloud(url, baseUrl);
+        pco.material.size = 1;
+        pco.material.shape = 2;
+        pco.material.inputColorEncoding = 1;
+        pco.material.outputColorEncoding = 1;
+        pco.material.pointColorType = PointColorType.RGB;
+        pco.material.pointSizeType = PointSizeType.ADAPTIVE;
+        pco.material.shape = PointShape.CIRCLE;
+        if (params.position) pco.position.copy(params.position);
+        if (params.rotation) pco.rotation.copy(params.rotation);
+        if (params.scale) pco.scale.copy(params.scale);
+        this.pointClouds.push(pco);
+        const modelImpl = new PotreeModelImpl(pco);
+        modelImpl.loader = this;
+        modelImpl.viewer = this.viewer;
+        modelImpl.pco = pco;
+        this.viewer.scene.add(pco);
+        this.viewer.models.push(modelImpl);
+        this.viewer.syncOptions();
+        this.viewer.syncOverlay();
+        this.viewer.update();
+        this.viewer.emitEvent({
+            type: "databasechunk",
+            data: pco,
+            file: file
+        });
+        return this;
+    }
+}
+
+loaders.registerLoader("potree-file", (viewer => new PotreeFileLoader(viewer)));
+//# sourceMappingURL=PotreeLoader.module.js.map

package/dist/plugins/loaders/PotreeLoader.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PotreeLoader.module.js","sources":["../../../plugins/loaders/Potree/PotreeModelImpl.ts","../../../plugins/loaders/Potree/PotreeFileLoader.ts","../../../plugins/loaders/Potree/index.ts"],"sourcesContent":["///////////////////////////////////////////////////////////////////////////////\n// Copyright (C) 2002-2025, Open Design Alliance (the \"Alliance\").\n// All rights reserved.\n//\n// This software and its documentation and related materials are owned by\n// the Alliance. The software may only be incorporated into application\n// programs owned by members of the Alliance, subject to a signed\n// Membership Agreement and Supplemental Software License Agreement with the\n// Alliance. The structure and organization of this software are the valuable\n// trade secrets of the Alliance and its suppliers. The software is also\n// protected by copyright law and international treaty provisions. Application\n// programs incorporating this software must include the following statement\n// with their copyright notices:\n//\n//   This application incorporates Open Design Alliance software pursuant to a\n//   license agreement with Open Design Alliance.\n//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.\n//   All rights reserved.\n//\n// By use of this software, its documentation or related materials, you\n// acknowledge and accept the above terms.\n///////////////////////////////////////////////////////////////////////////////\n\nimport { Box3 } from \"three\";\nimport { PointCloudOctree } from \"potree-core\";\nimport { ModelImpl } from \"@inweb/viewer-three\";\n\n// Potree model implementation.\n\nexport class PotreeModelImpl extends ModelImpl {\n  public pco: PointCloudOctree;\n\n  override getExtents(target: Box3): Box3 {\n    return target.union(this.pco.pcoGeometry.boundingBox);\n  }\n}\n","///////////////////////////////////////////////////////////////////////////////\n// Copyright (C) 2002-2025, Open Design Alliance (the \"Alliance\").\n// All rights reserved.\n//\n// This software and its documentation and related materials are owned by\n// the Alliance. The software may only be incorporated into application\n// programs owned by members of the Alliance, subject to a signed\n// Membership Agreement and Supplemental Software License Agreement with the\n// Alliance. The structure and organization of this software are the valuable\n// trade secrets of the Alliance and its suppliers. The software is also\n// protected by copyright law and international treaty provisions. Application\n// programs incorporating this software must include the following statement\n// with their copyright notices:\n//\n//   This application incorporates Open Design Alliance software pursuant to a\n//   license agreement with Open Design Alliance.\n//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.\n//   All rights reserved.\n//\n// By use of this software, its documentation or related materials, you\n// acknowledge and accept the above terms.\n///////////////////////////////////////////////////////////////////////////////\n\nimport { Euler, Vector3 } from \"three\";\nimport { PointColorType, PointCloudOctree, PointSizeType, PointShape, Potree } from \"potree-core\";\nimport { Loader, Viewer } from \"@inweb/viewer-three\";\n\nimport { PotreeModelImpl } from \"./PotreeModelImpl\";\n\nexport type PotreeLoadParams = {\n  path?: string;\n  position?: Vector3;\n  rotation?: Euler;\n  scale?: Vector3;\n};\n\nexport class PotreeFileLoader extends Loader {\n  public viewer: Viewer;\n  public potree: Potree;\n  public pointClouds: PointCloudOctree[];\n\n  constructor(viewer: Viewer) {\n    super();\n    this.viewer = viewer;\n\n    this.potree = new Potree();\n    this.pointClouds = [];\n\n    this.viewer.addEventListener(\"render\", this.updatePointClouds);\n    this.viewer.addEventListener(\"changecamera\", this.updatePointClouds);\n  }\n\n  override dispose() {\n    this.pointClouds.forEach((pco) => pco.dispose());\n\n    this.viewer.removeEventListener(\"render\", this.updatePointClouds);\n    this.viewer.removeEventListener(\"changecamera\", this.updatePointClouds);\n  }\n\n  override isSupport(file: any, format?: string): boolean {\n    return typeof file === \"string\" && /(cloud.js|metadata.json)$/i.test(file);\n  }\n\n  override async load(file: any, format?: string, params: PotreeLoadParams = {}): Promise<this> {\n    const path = (params.path || \"\") + file;\n    const index = path.lastIndexOf(\"/\");\n    const baseUrl = path.slice(0, index + 1);\n    const url = path.slice(index + 1);\n\n    const pco = await this.potree.loadPointCloud(url, baseUrl);\n    pco.material.size = 1.0;\n    pco.material.shape = 2;\n    pco.material.inputColorEncoding = 1;\n    pco.material.outputColorEncoding = 1;\n    pco.material.pointColorType = PointColorType.RGB; // RGB | DEPTH | HEIGHT | POINT_INDEX | LOD | CLASSIFICATION\n    pco.material.pointSizeType = PointSizeType.ADAPTIVE; // ADAPTIVE | FIXED\n    pco.material.shape = PointShape.CIRCLE; // CIRCLE | SQUARE\n\n    if (params.position) pco.position.copy(params.position);\n    if (params.rotation) pco.rotation.copy(params.rotation);\n    if (params.scale) pco.scale.copy(params.scale);\n\n    this.pointClouds.push(pco);\n\n    const modelImpl = new PotreeModelImpl(pco);\n    modelImpl.loader = this;\n    modelImpl.viewer = this.viewer;\n    modelImpl.pco = pco;\n\n    this.viewer.scene.add(pco);\n    this.viewer.models.push(modelImpl);\n\n    this.viewer.syncOptions();\n    this.viewer.syncOverlay();\n    this.viewer.update();\n\n    this.viewer.emitEvent({ type: \"databasechunk\", data: pco, file });\n\n    return this;\n  }\n\n  updatePointClouds = () => {\n    const result = this.potree.updatePointClouds(this.pointClouds, this.viewer.camera, this.viewer.renderer);\n    if (result.exceededMaxLoadsToGPU || result.nodeLoadPromises.length > 0) this.viewer.update();\n  };\n}\n","///////////////////////////////////////////////////////////////////////////////\n// Copyright (C) 2002-2025, Open Design Alliance (the \"Alliance\").\n// All rights reserved.\n//\n// This software and its documentation and related materials are owned by\n// the Alliance. The software may only be incorporated into application\n// programs owned by members of the Alliance, subject to a signed\n// Membership Agreement and Supplemental Software License Agreement with the\n// Alliance. The structure and organization of this software are the valuable\n// trade secrets of the Alliance and its suppliers. The software is also\n// protected by copyright law and international treaty provisions. Application\n// programs incorporating this software must include the following statement\n// with their copyright notices:\n//\n//   This application incorporates Open Design Alliance software pursuant to a\n//   license agreement with Open Design Alliance.\n//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.\n//   All rights reserved.\n//\n// By use of this software, its documentation or related materials, you\n// acknowledge and accept the above terms.\n///////////////////////////////////////////////////////////////////////////////\n\nimport { loaders } from \"@inweb/viewer-three\";\n\nimport { PotreeFileLoader } from \"./PotreeFileLoader\";\n\nloaders.registerLoader(\"potree-file\", (viewer: any) => new PotreeFileLoader(viewer));\n"],"names":["PotreeModelImpl","ModelImpl","getExtents","target","union","this","pco","pcoGeometry","boundingBox","PotreeFileLoader","Loader","constructor","viewer","super","updatePointClouds","result","potree","pointClouds","camera","renderer","exceededMaxLoadsToGPU","nodeLoadPromises","length","update","Potree","addEventListener","dispose","forEach","removeEventListener","isSupport","file","format","test","load","params","path","index","lastIndexOf","baseUrl","slice","url","loadPointCloud","material","size","shape","inputColorEncoding","outputColorEncoding","pointColorType","PointColorType","RGB","pointSizeType","PointSizeType","ADAPTIVE","PointShape","CIRCLE","position","copy","rotation","scale","push","modelImpl","loader","scene","add","models","syncOptions","syncOverlay","emitEvent","type","data","loaders","registerLoader"],"mappings":";;;;AA6BM,MAAOA,wBAAwBC;IAG1B,UAAAC,CAAWC;QAClB,OAAOA,OAAOC,MAAMC,KAAKC,IAAIC,YAAYC;;;;ACGvC,MAAOC,yBAAyBC;IAKpC,WAAAC,CAAYC;QACVC;QA2DFR,KAAiBS,oBAAG;YAClB,MAAMC,SAASV,KAAKW,OAAOF,kBAAkBT,KAAKY,aAAaZ,KAAKO,OAAOM,QAAQb,KAAKO,OAAOO;YAC/F,IAAIJ,OAAOK,yBAAyBL,OAAOM,iBAAiBC,SAAS,GAAGjB,KAAKO,OAAOW;AAAQ;QA5D5FlB,KAAKO,SAASA;QAEdP,KAAKW,SAAS,IAAIQ;QAClBnB,KAAKY,cAAc;QAEnBZ,KAAKO,OAAOa,iBAAiB,UAAUpB,KAAKS;QAC5CT,KAAKO,OAAOa,iBAAiB,gBAAgBpB,KAAKS;;IAG3C,OAAAY;QACPrB,KAAKY,YAAYU,SAASrB,OAAQA,IAAIoB;QAEtCrB,KAAKO,OAAOgB,oBAAoB,UAAUvB,KAAKS;QAC/CT,KAAKO,OAAOgB,oBAAoB,gBAAgBvB,KAAKS;;IAG9C,SAAAe,CAAUC,MAAWC;QAC5B,cAAcD,SAAS,YAAY,6BAA6BE,KAAKF;;IAG9D,UAAMG,CAAKH,MAAWC,QAAiBG,SAA2B,CAAA;QACzE,MAAMC,QAAQD,OAAOC,QAAQ,MAAML;QACnC,MAAMM,QAAQD,KAAKE,YAAY;QAC/B,MAAMC,UAAUH,KAAKI,MAAM,GAAGH,QAAQ;QACtC,MAAMI,MAAML,KAAKI,MAAMH,QAAQ;QAE/B,MAAM9B,YAAYD,KAAKW,OAAOyB,eAAeD,KAAKF;QAClDhC,IAAIoC,SAASC,OAAO;QACpBrC,IAAIoC,SAASE,QAAQ;QACrBtC,IAAIoC,SAASG,qBAAqB;QAClCvC,IAAIoC,SAASI,sBAAsB;QACnCxC,IAAIoC,SAASK,iBAAiBC,eAAeC;QAC7C3C,IAAIoC,SAASQ,gBAAgBC,cAAcC;QAC3C9C,IAAIoC,SAASE,QAAQS,WAAWC;QAEhC,IAAIpB,OAAOqB,UAAUjD,IAAIiD,SAASC,KAAKtB,OAAOqB;QAC9C,IAAIrB,OAAOuB,UAAUnD,IAAImD,SAASD,KAAKtB,OAAOuB;QAC9C,IAAIvB,OAAOwB,OAAOpD,IAAIoD,MAAMF,KAAKtB,OAAOwB;QAExCrD,KAAKY,YAAY0C,KAAKrD;QAEtB,MAAMsD,YAAY,IAAI5D,gBAAgBM;QACtCsD,UAAUC,SAASxD;QACnBuD,UAAUhD,SAASP,KAAKO;QACxBgD,UAAUtD,MAAMA;QAEhBD,KAAKO,OAAOkD,MAAMC,IAAIzD;QACtBD,KAAKO,OAAOoD,OAAOL,KAAKC;QAExBvD,KAAKO,OAAOqD;QACZ5D,KAAKO,OAAOsD;QACZ7D,KAAKO,OAAOW;QAEZlB,KAAKO,OAAOuD,UAAU;YAAEC,MAAM;YAAiBC,MAAM/D;YAAKwB;;QAE1D,OAAOzB;;;;ACvEXiE,QAAQC,eAAe,gBAAgB3D,UAAgB,IAAIH,iBAAiBG"}

package/dist/viewer-three.js

@@ -80902,6 +80902,12 @@ void main() {
                 this.viewer.target.copy(this.orbit.target);
                 this.viewer.update();
                 switch (this.orbit.state) {
+                    case STATE.ROTATE:
+                    case STATE.TOUCH_ROTATE:
+                        this.viewer.emitEvent({
+                            type: "orbit",
+                        });
+                        break;
                     case STATE.PAN:
                     case STATE.TOUCH_PAN:
                         this.viewer.emitEvent({
@@ -80921,6 +80927,7 @@ void main() {
                         });
                         break;
                 }
+                this.viewer.emitEvent({ type: "changecamera" });
                 this.changed = true;
             };
             this.stopContextMenu = (event) => {
@@ -81724,6 +81731,7 @@ void main() {
             };
             this.controlsChange = () => {
                 this.viewer.update();
+                this.viewer.emitEvent({ type: "changecamera" });
             };
             this.walkspeedChange = (event) => {
                 this.viewer.emitEvent(event);
@@ -82047,32 +82055,32 @@ void main() {
     function zoomTo(viewer, box) {
         if (box.isEmpty())
             return;
-        const center = box.getCenter(new Vector3());
-        const sphere = box.getBoundingSphere(new Sphere());
+        const boxCenter = box.getCenter(new Vector3());
+        const boxSize = box.getBoundingSphere(new Sphere()).radius;
         const rendererSize = viewer.renderer.getSize(new Vector2());
         const aspect = rendererSize.x / rendererSize.y;
         const camera = viewer.camera;
         if (camera.isPerspectiveCamera) {
-            const offset = new Vector3(0, 0, 1);
-            offset.applyQuaternion(camera.quaternion);
-            offset.multiplyScalar(sphere.radius / Math.tan(MathUtils.DEG2RAD * camera.fov * 0.5));
-            camera.position.copy(center).add(offset);
+            const offset = new Vector3(0, 0, 1)
+                .applyQuaternion(camera.quaternion)
+                .multiplyScalar(boxSize / Math.tan(MathUtils.DEG2RAD * camera.fov * 0.5));
+            camera.position.copy(offset).add(boxCenter);
             camera.updateMatrixWorld();
         }
         if (camera.isOrthographicCamera) {
-            camera.top = sphere.radius;
-            camera.bottom = -sphere.radius;
+            camera.top = boxSize;
+            camera.bottom = -boxSize;
             camera.left = camera.bottom * aspect;
             camera.right = camera.top * aspect;
             camera.zoom = 1;
             camera.updateProjectionMatrix();
-            const offset = new Vector3(0, 0, 1);
-            offset.applyQuaternion(camera.quaternion);
-            offset.multiplyScalar(viewer.extents.getBoundingSphere(new Sphere()).radius * 3);
-            camera.position.copy(center).add(offset);
+            const offset = new Vector3(0, 0, 1)
+                .applyQuaternion(camera.quaternion)
+                .multiplyScalar(viewer.extents.getBoundingSphere(new Sphere()).radius * 3);
+            camera.position.copy(offset).add(boxCenter);
             camera.updateMatrixWorld();
         }
-        viewer.target.copy(center);
+        viewer.target.copy(boxCenter);
         viewer.update();
         viewer.emitEvent({ type: "zoom" });
     }
@@ -82100,27 +82108,30 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     const defaultViewPositions = {
-        front: new Vector3(0, 0, 1),
-        back: new Vector3(0, 0, -1),
-        left: new Vector3(-1, 0, 0),
-        right: new Vector3(1, 0, 0),
+        front: new Vector3(0, 0, -1),
+        back: new Vector3(0, 0, 1),
+        left: new Vector3(1, 0, 0),
+        right: new Vector3(-1, 0, 0),
         bottom: new Vector3(0, -1, 0),
         top: new Vector3(0, 1, 0),
-        ns: new Vector3(-0.5, 1.0, -0.5).normalize(),
-        sw: new Vector3(0.5, 1.0, -0.5).normalize(),
-        nw: new Vector3(0.5, 1.0, 0.5).normalize(),
-        se: new Vector3(-0.5, 1.0, 0.5).normalize(),
+        se: new Vector3(-1, 1, -1).normalize(),
+        sw: new Vector3(1, 1, -1).normalize(),
+        ne: new Vector3(-1, 1, 1).normalize(),
+        nw: new Vector3(1, 1, 1).normalize(),
     };
     function setDefaultViewPosition(viewer, position) {
-        const direction = defaultViewPositions[position] || defaultViewPositions["sw"];
-        const center = viewer.extents.getCenter(new Vector3());
-        const sphere = viewer.extents.getBoundingSphere(new Sphere());
-        const offset = direction.clone().multiplyScalar(sphere.radius);
+        const extentsCenter = viewer.extents.getCenter(new Vector3());
+        const extentsSize = viewer.extents.getBoundingSphere(new Sphere()).radius * 2;
+        const upY = new Vector3(0, 1, 0);
+        const offsetY = defaultViewPositions[position] || defaultViewPositions["sw"];
+        const up = new Vector3().copy(viewer.camera.up);
+        const quaternion = new Quaternion().setFromUnitVectors(upY, up);
+        const offset = new Vector3().copy(offsetY).applyQuaternion(quaternion);
         const camera = viewer.camera;
-        camera.position.copy(center).add(offset);
-        camera.lookAt(center);
+        camera.position.copy(offset).multiplyScalar(extentsSize).add(extentsCenter);
+        camera.lookAt(extentsCenter);
         camera.updateMatrixWorld();
-        viewer.target.copy(center);
+        viewer.target.copy(extentsCenter);
         viewer.update();
         viewer.emit({ type: "viewposition", data: position });
         zoomTo(viewer, viewer.extents);
@@ -82802,7 +82813,7 @@ void main() {
                 const extents = new Box3();
                 this.viewer.models.forEach((model) => model.getExtents(extents));
                 this.viewer.extents.copy(extents);
-                extents.getCenter(this.viewer.target);
+                this.viewer.extents.getCenter(this.viewer.target);
             };
             this.viewer = viewer;
             this.viewer.addEventListener("databasechunk", this.syncExtents);
@@ -82857,12 +82868,13 @@ void main() {
                     return;
                 const extentsCenter = this.viewer.extents.getCenter(new Vector3());
                 const extentsSize = this.viewer.extents.getBoundingSphere(new Sphere()).radius;
-                const front = new Vector3()
-                    .copy(this.viewer.camera.up)
-                    .cross(new Vector3(1, 0, 0))
-                    .negate();
+                const upY = new Vector3(0, 1, 0);
+                const frontY = new Vector3(0, 0, -1);
+                const up = new Vector3().copy(this.viewer.camera.up);
+                const quaternion = new Quaternion().setFromUnitVectors(upY, up);
+                const front = new Vector3().copy(frontY).applyQuaternion(quaternion).negate();
                 this.directionalLight.position
-                    .copy(this.viewer.camera.up)
+                    .copy(up)
                     .applyAxisAngle(front, (-Math.PI * 30) / 180)
                     .multiplyScalar(extentsSize * 2)
                     .add(extentsCenter);
@@ -82968,21 +82980,7 @@ void main() {
                 const { width, height } = entries[0].contentRect;
                 if (!width || !height)
                     return; // <- invisible viewer, or viewer with parent removed
-                const camera = this.viewer.camera;
-                const aspect = width / height;
-                if (camera.isPerspectiveCamera) {
-                    camera.aspect = aspect;
-                    camera.updateProjectionMatrix();
-                }
-                if (camera.isOrthographicCamera) {
-                    camera.left = camera.bottom * aspect;
-                    camera.right = camera.top * aspect;
-                    camera.updateProjectionMatrix();
-                }
-                this.viewer.renderer.setSize(width, height, true);
-                this.viewer.composer.setSize(width, height);
-                this.viewer.update(true);
-                this.viewer.emitEvent({ type: "resize", width, height });
+                this.viewer.setSize(width, height);
             };
             this.viewer = viewer;
             this.resizeObserver = new ResizeObserver(this.resizeViewer);
@@ -84462,9 +84460,9 @@ void main() {
             this.size = 160;
             this.orthoCamera = new OrthographicCamera(-2, 2, 2, -2, 0, 4);
             this.orthoCamera.position.set(0, 0, 2);
-            const matRed = new MeshBasicMaterial({ toneMapped: false, color: "#aa0000" });
-            const matGreen = new MeshBasicMaterial({ toneMapped: false, color: "#00aa00" });
-            const matBlue = new MeshBasicMaterial({ toneMapped: false, color: "#0000aa" });
+            const matRed = new MeshBasicMaterial({ toneMapped: false, color: "#dd0000" });
+            const matGreen = new MeshBasicMaterial({ toneMapped: false, color: "#00dd00" });
+            const matBlue = new MeshBasicMaterial({ toneMapped: false, color: "#0000dd" });
             const spriteRed = this.getSpriteMaterial(matRed.color, "X");
             const spriteGreen = this.getSpriteMaterial(matGreen.color, "Y");
             const spriteBlue = this.getSpriteMaterial(matBlue.color, "Z");
@@ -90265,11 +90263,12 @@ void main() {
     const MAX_CHUNK = 30 * 1024 * 1024; // 100 MB
 
     class GltfStructure {
-      constructor(id) {
+      constructor(id, loadController) {
         this.id = `${id}`;
         this.json = null;
         this.baseUrl = "";
-        this.loadController = null;
+        this.loadController = loadController;
+        this.loader = null;
         this.batchDelay = 10;
         this.maxBatchSize = 5 * 1024 * 1024;
         this.maxRangesPerRequest = 512;
@@ -90281,10 +90280,10 @@ void main() {
         this.materialCache = new Map();
       }
 
-      async initialize(loadController) {
-        this.json = await loadController.loadJson();
-        this.baseUrl = await loadController.baseUrl();
-        this.loadController = loadController;
+      async initialize(loader) {
+        this.json = await this.loadController.loadJson();
+        this.baseUrl = await this.loadController.baseUrl();
+        this.loader = loader;
       }
 
       clear() {
@@ -90297,10 +90296,12 @@ void main() {
           this.batchTimeout = null;
         }
 
-        // Clear materials and textures
         this.disposeMaterials();
         this.textureCache.clear();
         this.materials.clear();
+
+        this.activeChunkLoads = 0;
+        this.chunkQueue = [];
       }
 
       getJson() {
@@ -90379,35 +90380,32 @@ void main() {
             finalRanges.push({ start, end, requests });
           }
         }
-        /*
-        for (const range of finalRanges) {
-          const length = range.end - range.start;
-          const buffer = await this.loadController.loadBinaryData([
-            { offset: range.start, length: length }
-          ]);
-          for (const req of range.requests) {
-            const relOffset = req.offset - range.start;
-            try {
-              req._resolve({ buffer, relOffset, length: req.length });
-            } catch (e) {
-              req._reject(e);
-            }
-          }
-        }
-        */
 
-        const promises = finalRanges.map(async (range) => {
-          const length = range.end - range.start;
-          const buffer = await this.loadController.loadBinaryData([{ offset: range.start, length }]);
-          for (const req of range.requests) {
-            const relOffset = req.offset - range.start;
-            try {
-              req._resolve({ buffer, relOffset, length: req.length });
-            } catch (e) {
-              req._reject(e);
+        const promises = finalRanges.map(async (range, index) => {
+          await this.loader.waitForChunkSlot();
+
+          try {
+            const length = range.end - range.start;
+            const buffer = await this.loadController.loadBinaryData([{ offset: range.start, length }]);
+
+            for (const req of range.requests) {
+              const relOffset = req.offset - range.start;
+              try {
+                req._resolve({ buffer, relOffset, length: req.length });
+              } catch (e) {
+                req._reject(e);
+              }
             }
+          } catch (error) {
+            for (const req of range.requests) {
+              req._reject(error);
+            }
+            console.warn(`Failed to load chunk ${index + 1}/${finalRanges.length} (${range.start}-${range.end}):`, error);
+          } finally {
+            this.loader.releaseChunkSlot();
           }
         });
+
         await Promise.all(promises);
 
         this.pendingRequests = [];
@@ -90825,6 +90823,10 @@ void main() {
         this.hiddenHandles = new Set();
         this.newOptimizedObjects = new Set();
         this.oldOptimizeObjects = new Set();
+
+        this.maxConcurrentChunks = 8;
+        this.activeChunkLoads = 0;
+        this.chunkQueue = [];
       }
 
       setVisibleEdges(visible) {
@@ -91234,6 +91236,7 @@ void main() {
         const structureArray = Array.isArray(structures) ? structures : [structures];
 
         for (const structure of structureArray) {
+          await structure.initialize(this);
           this.structures.push(structure);
         }
 
@@ -91625,13 +91628,6 @@ void main() {
         this.nodesToLoad = [];
       }
 
-      async addStructure(loadController) {
-        const structure = new GltfStructure();
-        await structure.initialize(loadController);
-        this.structures.push(structure);
-        return structure;
-      }
-
       removeOptimization() {
         this.originalObjects.forEach((obj) => (obj.visible = true));
 
@@ -91663,7 +91659,8 @@ void main() {
       }
 
       clear() {
-        // Clear all structures
+        this.chunkQueue = [];
+
         this.structures.forEach((structure) => {
           if (structure) {
             structure.clear();
@@ -91704,7 +91701,6 @@ void main() {
         });
         this.loadedMeshes.clear();
 
-        // Clear all structure roots and their children
         this.structureRoots.forEach((rootGroup) => {
           if (rootGroup) {
             rootGroup.traverse((child) => {
@@ -91724,7 +91720,6 @@ void main() {
         });
         this.structureRoots.clear();
 
-        // Clear all optimized objects
         this.mergedMesh.forEach((mesh) => {
           if (mesh.geometry) mesh.geometry.dispose();
           if (mesh.material) {
@@ -92477,7 +92472,6 @@ void main() {
         });
       }
 
-      // Возвращает bounding box для конкретной структуры
       getStructureGeometryExtent(structureId) {
         const extent = new Box3();
         for (const [nodeId, node] of this.nodes.entries()) {
@@ -92495,6 +92489,35 @@ void main() {
         }
         return extent;
       }
+
+      setMaxConcurrentChunks(maxChunks) {
+        if (maxChunks < 1) {
+          console.warn("Max concurrent chunks must be at least 1");
+          return;
+        }
+        this.maxConcurrentChunks = maxChunks;
+      }
+
+      waitForChunkSlot() {
+        if (this.activeChunkLoads < this.maxConcurrentChunks) {
+          this.activeChunkLoads++;
+          return Promise.resolve();
+        }
+
+        return new Promise((resolve) => {
+          this.chunkQueue.push(resolve);
+        });
+      }
+
+      releaseChunkSlot() {
+        this.activeChunkLoads--;
+
+        if (this.chunkQueue.length > 0) {
+          const nextResolve = this.chunkQueue.shift();
+          this.activeChunkLoads++;
+          nextResolve();
+        }
+      }
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -92540,6 +92563,7 @@ void main() {
             this.gltfLoader = new DynamicGltfLoader(this.viewer.camera, scene, this.viewer.renderer);
             this.gltfLoader.memoryLimit = this.viewer.options.memoryLimit;
             this.gltfLoader.setVisibleEdges(this.viewer.options.edgeModel);
+            // this.gltfLoader.setMaxConcurrentChunks(this.viewer.options.maxConcurrentChunks);
             this.gltfLoader.addEventListener("databasechunk", (data) => {
                 const modelImpl = new DynamicModelImpl(scene);
                 modelImpl.loader = this;
@@ -92583,8 +92607,7 @@ void main() {
                 },
                 baseUrl: () => Promise.resolve(`${model.httpClient.serverUrl}${model.path}/`),
             };
-            const structure = new GltfStructure(model.id);
-            await structure.initialize(loadController);
+            const structure = new GltfStructure(model.id, loadController);
             await this.gltfLoader.loadStructure(structure);
             await this.gltfLoader.loadNodes();
             return this;
@@ -109764,7 +109787,7 @@ void main() {
             this.target = new Vector3();
             this._activeDragger = null;
             this._components = [];
-            this.renderTime = 0;
+            this._renderTime = 0;
             this.render = this.render.bind(this);
             this.update = this.update.bind(this);
             this._markup = new KonvaMarkup();
@@ -109790,13 +109813,13 @@ void main() {
             this.addEventListener("optionschange", (event) => this.syncOptions(event.data));
             this.scene = new Scene();
             this.helpers = new Helpers();
-            this.target = new Vector3();
+            this.target = new Vector3(0, 0, 0);
             const pixelRatio = window.devicePixelRatio;
             const rect = canvas.parentElement.getBoundingClientRect();
             const width = rect.width || 1;
             const height = rect.height || 1;
             const aspect = width / height;
-            this.camera = new PerspectiveCamera(45, aspect, 0.01, 1000);
+            this.camera = new PerspectiveCamera(45, aspect, 0.001, 1000);
             this.camera.up.set(0, 1, 0);
             this.camera.position.set(0, 0, 1);
             this.camera.lookAt(this.target);
@@ -109828,6 +109851,7 @@ void main() {
             this.composer.addPass(this.fxaaPass);
             this.composer.addPass(this.ssaaRenderPass);
             this.composer.addPass(this.outputPass);
+            this.composer.setSize(width, height);
             this.canvas = canvas;
             this.canvasEvents.forEach((x) => canvas.addEventListener(x, this.canvaseventlistener));
             this._markup.initialize(this.canvas, this.canvasEvents, this, this);
@@ -109836,8 +109860,8 @@ void main() {
             }
             this.syncOptions();
             this.syncOverlay();
-            this.renderTime = performance.now();
-            this.render(this.renderTime);
+            this._renderTime = performance.now();
+            this.render(this._renderTime);
             if (typeof onProgress === "function")
                 onProgress(new ProgressEvent("progress", { lengthComputable: true, loaded: 1, total: 1 }));
             this.emitEvent({ type: "initializeprogress", data: 1, loaded: 1, total: 1 });
@@ -109889,8 +109913,27 @@ void main() {
         isInitialized() {
             return !!this.renderer;
         }
+        setSize(width, height, updateStyle = true) {
+            if (!this.renderer)
+                return;
+            const camera = this.camera;
+            const aspect = width / height;
+            if (camera.isPerspectiveCamera) {
+                camera.aspect = aspect;
+                camera.updateProjectionMatrix();
+            }
+            if (camera.isOrthographicCamera) {
+                camera.left = camera.bottom * aspect;
+                camera.right = camera.top * aspect;
+                camera.updateProjectionMatrix();
+            }
+            this.renderer.setSize(width, height, updateStyle);
+            this.composer.setSize(width, height);
+            this.update(true);
+            this.emitEvent({ type: "resize", width, height });
+        }
         update(force = false) {
-            this.renderNeeded = true;
+            this._renderNeeded = true;
             if (force)
                 this.render();
             this.emitEvent({ type: "update", data: force });
@@ -109899,13 +109942,13 @@ void main() {
             var _a, _b;
             if (!this.renderer)
                 return;
-            if (!(this.renderNeeded || force))
+            if (!this._renderNeeded && !force)
                 return;
             if (!time)
                 time = performance.now();
-            const deltaTime = (time - this.renderTime) / 1000;
-            this.renderTime = time;
-            this.renderNeeded = false;
+            const deltaTime = (time - this._renderTime) / 1000;
+            this._renderTime = time;
+            this._renderNeeded = false;
             if (this.options.antialiasing === true || this.options.antialiasing === "msaa") {
                 this.renderer.render(this.scene, this.camera);
                 this.renderer.render(this.helpers, this.camera);
@@ -110202,7 +110245,7 @@ void main() {
                     camera.left = camera.bottom * aspect;
                     camera.right = camera.top * aspect;
                     camera.near = 0;
-                    camera.far = extentsSize * 100;
+                    camera.far = extentsSize * 1000;
                     camera.zoom = orthogonal_camera.view_to_world_scale;
                     camera.updateProjectionMatrix();
                     camera.up.copy(getVector3FromPoint3d(orthogonal_camera.up_vector));
@@ -110223,8 +110266,8 @@ void main() {
                     const camera = new PerspectiveCamera();
                     camera.fov = perspective_camera.field_of_view;
                     camera.aspect = aspect;
-                    camera.near = extentsSize / 100;
-                    camera.far = extentsSize * 100;
+                    camera.near = extentsSize / 1000;
+                    camera.far = extentsSize * 1000;
                     camera.updateProjectionMatrix();
                     camera.up.copy(getVector3FromPoint3d(perspective_camera.up_vector));
                     camera.position.copy(getVector3FromPoint3d(perspective_camera.view_point));