@inweb/viewer-three 27.4.7 → 27.5.0

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

@@ -88,6 +88,8 @@ export class GltfStructure {
     this._nextObjectId = 1;
     this.loadingAborted = false;
     this.criticalError = null;
+    // Holds decoded base64 buffer when the .gltf has an embedded data URI
+    this.embeddedBinaryChunk = null;
   }
 
   async initialize(loader) {
@@ -99,21 +101,53 @@ export class GltfStructure {
 
     this.json = json;
     this.loader = loader;
-    this.uri = this.json.buffers[0].uri || "";
+
+    const bufferUri = this.json.buffers?.[0]?.uri || "";
+
+    // Detect embedded data URI (e.g. "data:application/octet-stream;base64,...")
+    // and decode it once into memory. The buffer URI is then cleared so that
+    // scheduleRequest serves data from memory instead of doing network requests.
+    if (bufferUri.startsWith("data:")) {
+      this.embeddedBinaryChunk = await this._decodeDataUri(bufferUri);
+      this.uri = "";
+    } else {
+      this.uri = bufferUri;
+    }
+  }
+
+  // Decode a data URI to ArrayBuffer using the browser's native fetch() —
+  // much faster than atob() + JS loop for large (10+ MB) base64 buffers.
+  async _decodeDataUri(dataUri) {
+    try {
+      const response = await fetch(dataUri);
+      return await response.arrayBuffer();
+    } catch (e) {
+      throw new Error(`DynamicLoader: Failed to decode embedded data URI: ${e.message}`);
+    }
   }
 
   clear() {
-    this.json = null;
-    this.loadController = null;
-    this.pendingRequests = [];
     if (this.batchTimeout) {
       clearTimeout(this.batchTimeout);
       this.batchTimeout = null;
     }
 
-    this.disposeMaterials();
-    this.textureCache.clear();
-    this.materials.clear();
+    this._rejectPendingRequests();
+
+    if (this.disposeMaterials) {
+      try {
+        this.disposeMaterials();
+      } catch (e) {
+        console.warn("DynamicLoader: error during disposeMaterials in clear():", e);
+      }
+    }
+    if (this.textureCache) this.textureCache.clear();
+    if (this.materials) this.materials.clear();
+
+    this.embeddedBinaryChunk = null;
+    this.json = null;
+    this.loadController = null;
+    this.uri = "";
 
     this.activeChunkLoads = 0;
     this.chunkQueue = [];
@@ -121,11 +155,38 @@ export class GltfStructure {
     this.criticalError = null;
   }
 
+  _rejectPendingRequests() {
+    const pending = this.pendingRequests;
+    this.pendingRequests = [];
+    if (!pending || pending.length === 0) return;
+
+    const cancelError = new Error("DynamicLoader: Structure cleared while requests pending");
+    for (let i = 0; i < pending.length; i++) {
+      const item = pending[i];
+      if (item && typeof item._reject === "function") {
+        try {
+          item._reject(cancelError);
+        } catch {
+          // Consumer may have already been disposed
+        }
+      }
+    }
+  }
+
   getJson() {
     return this.json;
   }
 
   scheduleRequest(request) {
+    // Fast path: buffer was an embedded data URI, decoded once into memory
+    if (this.embeddedBinaryChunk && !this.uri) {
+      return Promise.resolve({
+        buffer: this.embeddedBinaryChunk,
+        relOffset: request.offset,
+        length: request.length,
+      });
+    }
+
     return new Promise((resolve, reject) => {
       if (this.loadingAborted) {
         reject(
@@ -441,8 +502,13 @@ export class GltfStructure {
           return await this.textureLoader.loadAsync(fullUrl);
         } else if (image.bufferView !== undefined) {
           const bufferView = this.json.bufferViews[image.bufferView];
-          const array = await this.getBufferView(bufferView.byteOffset || 0, bufferView.byteLength, 5121);
-          const blob = new Blob([array], { type: image.mimeType });
+          const { buffer, relOffset } = await this.getBufferView(
+            bufferView.byteOffset || 0,
+            bufferView.byteLength,
+            5121
+          );
+          const imageBytes = new Uint8Array(buffer, relOffset, bufferView.byteLength);
+          const blob = new Blob([imageBytes], { type: image.mimeType });
           const url = URL.createObjectURL(blob);
           const texture = await this.textureLoader.loadAsync(url);
           URL.revokeObjectURL(url);
@@ -479,6 +545,7 @@ export class GltfStructure {
         })
       );
     }
+    await this.flushBufferRequests();
     await Promise.all(texturePromises);
   }
 

package/src/Viewer/loaders/GLTFCloudDynamicLoader.ts

@@ -58,9 +58,10 @@ export class GLTFCloudDynamicLoader extends Loader {
     const scene = new Group();
 
     this.gltfLoader = new DynamicGltfLoader(this.viewer.camera, scene, this.viewer.renderer);
-    this.gltfLoader.memoryLimit = this.viewer.options.memoryLimit;
+    this.gltfLoader.setMemoryLimit(this.viewer.options.memoryLimit);
     this.gltfLoader.setVisibleEdges(this.viewer.options.edgeModel);
-    // this.gltfLoader.setMaxConcurrentChunks(this.viewer.options.maxConcurrentChunks);
+    this.gltfLoader.setMaxConcurrentChunks(params.maxConcurrentChunks);
+    this.gltfLoader.setDracoLoader(params.dracoLoader);
 
     const modelImpl = new DynamicModelImpl(scene);
     modelImpl.id = model.file.id;

package/src/Viewer/loaders/GLTFFileDynamicLoader.ts

@@ -62,8 +62,10 @@ export class GLTFFileDynamicLoader extends Loader {
     const scene = new Group();
 
     this.gltfLoader = new DynamicGltfLoader(this.viewer.camera, scene, this.viewer.renderer);
-    this.gltfLoader.memoryLimit = this.viewer.options.memoryLimit;
-    this.gltfLoader.visibleEdges = this.viewer.options.edgeModel;
+    this.gltfLoader.setMemoryLimit(this.viewer.options.memoryLimit);
+    this.gltfLoader.setVisibleEdges(this.viewer.options.edgeModel);
+    this.gltfLoader.setMaxConcurrentChunks(params.maxConcurrentChunks);
+    this.gltfLoader.setDracoLoader(params.dracoLoader);
 
     const modelImpl = new DynamicModelImpl(scene);
     modelImpl.id = params.modelId || this.extractFileName(file);

package/src/Viewer/measurement/Snapper.ts

@@ -32,7 +32,6 @@ import {
   Raycaster,
   Vector2,
   Vector3,
-  WebGLRenderer,
 } from "three";
 
 const DESKTOP_SNAP_DISTANCE = 10;
@@ -47,16 +46,16 @@ const _projection = new Vector3();
 
 export class Snapper {
   public camera: Camera;
-  public renderer: WebGLRenderer;
+  public clippingPlanes: Plane[];
   public canvas: HTMLCanvasElement;
   public threshold: number;
   private raycaster: Raycaster;
   private detectRadiusInPixels: number;
   private edgesCache: WeakMap<any, EdgesGeometry>;
 
-  constructor(camera: Camera, renderer: WebGLRenderer, canvas: HTMLCanvasElement) {
+  constructor(camera: Camera, clippingPlanes: Plane[], canvas: HTMLCanvasElement) {
     this.camera = camera;
-    this.renderer = renderer;
+    this.clippingPlanes = clippingPlanes;
     this.canvas = canvas;
 
     this.threshold = 0.0001;
@@ -109,7 +108,7 @@ export class Snapper {
     let intersects = this.raycaster.intersectObjects(objects, recursive);
 
     if (clip) {
-      const clippingPlanes = this.renderer.clippingPlanes || [];
+      const clippingPlanes = this.clippingPlanes;
       clippingPlanes.forEach((plane: Plane) => {
         intersects = intersects.filter((intersect) => plane.distanceToPoint(intersect.point) >= 0);
       });

package/src/Viewer/models/ModelImpl.ts

@@ -36,6 +36,7 @@ export class ModelImpl implements IModelImpl {
   private originalObjects: Set<Object3D>;
 
   constructor(scene: Object3D) {
+    this.id = "";
     this.scene = scene;
 
     this.handleToObjects = new Map();
@@ -275,7 +276,30 @@ export class ModelImpl implements IModelImpl {
   }
 
   getExtents(target: Box3): Box3 {
-    this.scene.traverseVisible((object) => target.expandByObject(object));
+    const _box = new Box3();
+
+    function expandByObject(object: any, target: Box3) {
+      if (!object.geometry) return;
+
+      object.updateWorldMatrix(false, false);
+
+      // Use object bounds for the BatchedMesh, InstancedMesh and SkinnedMesh, use geometry
+      // bounds for others. See Box3.expandByObject() for more details.
+
+      if (object.boundingBox !== undefined) {
+        if (object.boundingBox === null) object.computeBoundingBox();
+        _box.copy(object.boundingBox);
+      } else {
+        if (object.geometry.boundingBox === null) object.geometry.computeBoundingBox();
+        _box.copy(object.geometry.boundingBox);
+      }
+
+      _box.applyMatrix4(object.matrixWorld);
+
+      target.union(_box);
+    }
+
+    this.scene.traverseVisible((object) => expandByObject(object, target));
     return target;
   }
 
@@ -285,8 +309,8 @@ export class ModelImpl implements IModelImpl {
 
   getVisibleObjects(): Object3D[] {
     const objects = [];
-    this.scene.traverseVisible((object) => objects.push(object));
-    return objects.filter((object) => object.userData.handle);
+    this.scene.traverseVisible((object) => object.userData.handle && objects.push(object));
+    return objects;
   }
 
   getObjectsByHandles(handles: string | string[]): Object3D[] {

package/lib/Viewer/scenes/Helpers.d.ts

@@ -1,7 +0,0 @@
-import { Scene, WebGLRenderer } from "three";
-export declare class Helpers extends Scene {
-    private oldAutoClear;
-    private oldClippingPlanes;
-    onBeforeRender(renderer: WebGLRenderer): void;
-    onAfterRender(renderer: WebGLRenderer): void;
-}

package/src/Viewer/postprocessing/SSAARenderPass.js

@@ -1,245 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2002-2026, Open Design Alliance (the "Alliance").
-// All rights reserved.
-//
-// This software and its documentation and related materials are owned by
-// the Alliance. The software may only be incorporated into application
-// programs owned by members of the Alliance, subject to a signed
-// Membership Agreement and Supplemental Software License Agreement with the
-// Alliance. The structure and organization of this software are the valuable
-// trade secrets of the Alliance and its suppliers. The software is also
-// protected by copyright law and international treaty provisions. Application
-// programs incorporating this software must include the following statement
-// with their copyright notices:
-//
-//   This application incorporates Open Design Alliance software pursuant to a
-//   license agreement with Open Design Alliance.
-//   Open Design Alliance Copyright (C) 2002-2026 by Open Design Alliance.
-//   All rights reserved.
-//
-// By use of this software, its documentation or related materials, you
-// acknowledge and accept the above terms.
-///////////////////////////////////////////////////////////////////////////////
-
-import { AdditiveBlending, Color, HalfFloatType, ShaderMaterial, UniformsUtils, WebGLRenderTarget } from "three";
-import { Pass, FullScreenQuad } from "three/examples/jsm/postprocessing/Pass.js";
-import { CopyShader } from "three/examples/jsm/shaders/CopyShader.js";
-
-export class SSAARenderPass extends Pass {
-  constructor(scenes, camera, clearColor = 0x000000, clearAlpha = 0) {
-    super();
-    this.scenes = Array.isArray(scenes) ? scenes : [scenes];
-    this.camera = camera;
-    this.sampleLevel = 2;
-    this.unbiased = true;
-    this.stencilBuffer = false;
-    this.clearColor = clearColor;
-    this.clearAlpha = clearAlpha;
-
-    this._sampleRenderTarget = null;
-    this._oldClearColor = new Color();
-    this._copyUniforms = UniformsUtils.clone(CopyShader.uniforms);
-
-    this._copyMaterial = new ShaderMaterial({
-      uniforms: this._copyUniforms,
-      vertexShader: CopyShader.vertexShader,
-      fragmentShader: CopyShader.fragmentShader,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-      premultipliedAlpha: true,
-      blending: AdditiveBlending,
-    });
-
-    this._fsQuad = new FullScreenQuad(this._copyMaterial);
-  }
-
-  dispose() {
-    if (this._sampleRenderTarget) {
-      this._sampleRenderTarget.dispose();
-      this._sampleRenderTarget = null;
-    }
-
-    this._copyMaterial.dispose();
-
-    this._fsQuad.dispose();
-  }
-
-  setSize(width, height) {
-    if (this._sampleRenderTarget) this._sampleRenderTarget.setSize(width, height);
-  }
-
-  render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
-    if (!this._sampleRenderTarget) {
-      this._sampleRenderTarget = new WebGLRenderTarget(readBuffer.width, readBuffer.height, {
-        type: HalfFloatType,
-        stencilBuffer: this.stencilBuffer,
-      });
-      this._sampleRenderTarget.texture.name = "SSAAMultiRenderPass.sample";
-    }
-
-    const jitterOffsets = _JitterVectors[Math.max(0, Math.min(this.sampleLevel, 5))];
-
-    const autoClear = renderer.autoClear;
-    renderer.autoClear = false;
-
-    renderer.getClearColor(this._oldClearColor);
-    const oldClearAlpha = renderer.getClearAlpha();
-
-    const baseSampleWeight = 1.0 / jitterOffsets.length;
-    const roundingRange = 1 / 32;
-    this._copyUniforms["tDiffuse"].value = this._sampleRenderTarget.texture;
-
-    const viewOffset = {
-      fullWidth: readBuffer.width,
-      fullHeight: readBuffer.height,
-      offsetX: 0,
-      offsetY: 0,
-      width: readBuffer.width,
-      height: readBuffer.height,
-    };
-
-    const originalViewOffset = Object.assign({}, this.camera.view);
-
-    if (originalViewOffset.enabled) Object.assign(viewOffset, originalViewOffset);
-
-    for (let i = 0; i < jitterOffsets.length; i++) {
-      const jitterOffset = jitterOffsets[i];
-
-      if (this.camera.setViewOffset) {
-        this.camera.setViewOffset(
-          viewOffset.fullWidth,
-          viewOffset.fullHeight,
-
-          viewOffset.offsetX + jitterOffset[0] * 0.0625,
-          viewOffset.offsetY + jitterOffset[1] * 0.0625, // 0.0625 = 1 / 16
-
-          viewOffset.width,
-          viewOffset.height
-        );
-      }
-
-      let sampleWeight = baseSampleWeight;
-
-      if (this.unbiased) {
-        const uniformCenteredDistribution = -0.5 + (i + 0.5) / jitterOffsets.length;
-        sampleWeight += roundingRange * uniformCenteredDistribution;
-      }
-
-      this._copyUniforms["opacity"].value = sampleWeight;
-      renderer.setClearColor(this.clearColor, this.clearAlpha);
-      renderer.setRenderTarget(this._sampleRenderTarget);
-      renderer.clear();
-
-      this.scenes.forEach((scene) => renderer.render(scene, this.camera));
-
-      renderer.setRenderTarget(this.renderToScreen ? null : writeBuffer);
-
-      if (i === 0) {
-        renderer.setClearColor(0x000000, 0.0);
-        renderer.clear();
-      }
-
-      this._fsQuad.render(renderer);
-    }
-
-    if (this.camera.setViewOffset && originalViewOffset.enabled) {
-      this.camera.setViewOffset(
-        originalViewOffset.fullWidth,
-        originalViewOffset.fullHeight,
-
-        originalViewOffset.offsetX,
-        originalViewOffset.offsetY,
-
-        originalViewOffset.width,
-        originalViewOffset.height
-      );
-    } else if (this.camera.clearViewOffset) {
-      this.camera.clearViewOffset();
-    }
-
-    renderer.autoClear = autoClear;
-    renderer.setClearColor(this._oldClearColor, oldClearAlpha);
-  }
-}
-
-// These jitter vectors are specified in integers because it is easier.
-// I am assuming a [-8,8) integer grid, but it needs to be mapped onto [-0.5,0.5)
-// before being used, thus these integers need to be scaled by 1/16.
-//
-// Sample patterns reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ff476218%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396
-const _JitterVectors = [
-  [[0, 0]],
-  [
-    [4, 4],
-    [-4, -4],
-  ],
-  [
-    [-2, -6],
-    [6, -2],
-    [-6, 2],
-    [2, 6],
-  ],
-  [
-    [1, -3],
-    [-1, 3],
-    [5, 1],
-    [-3, -5],
-    [-5, 5],
-    [-7, -1],
-    [3, 7],
-    [7, -7],
-  ],
-  [
-    [1, 1],
-    [-1, -3],
-    [-3, 2],
-    [4, -1],
-    [-5, -2],
-    [2, 5],
-    [5, 3],
-    [3, -5],
-    [-2, 6],
-    [0, -7],
-    [-4, -6],
-    [-6, 4],
-    [-8, 0],
-    [7, -4],
-    [6, 7],
-    [-7, -8],
-  ],
-  [
-    [-4, -7],
-    [-7, -5],
-    [-3, -5],
-    [-5, -4],
-    [-1, -4],
-    [-2, -2],
-    [-6, -1],
-    [-4, 0],
-    [-7, 1],
-    [-1, 2],
-    [-6, 3],
-    [-3, 3],
-    [-7, 6],
-    [-3, 6],
-    [-5, 7],
-    [-1, 7],
-    [5, -7],
-    [1, -6],
-    [6, -5],
-    [4, -4],
-    [2, -3],
-    [7, -2],
-    [1, -1],
-    [4, -1],
-    [2, 1],
-    [6, 2],
-    [0, 4],
-    [4, 4],
-    [2, 5],
-    [7, 5],
-    [5, 6],
-    [3, 7],
-  ],
-];