@inweb/viewer-three 26.8.1 → 26.8.3

package/src/Viewer/models/IModelImpl.ts

@@ -0,0 +1,67 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, 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-2025 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 { Box3, Object3D } from "three";
+import { ILoader, IViewer } from "@inweb/viewer-core";
+
+/**
+ * Model interface.
+ */
+export interface IModelImpl {
+  handle: string;
+  scene: Object3D;
+  loader: ILoader;
+  viewer: IViewer;
+
+  dispose(): void;
+
+  getExtents(target: Box3): Box3;
+
+  getObjects(): Object3D[];
+
+  getVisibleObjects(): Object3D[];
+
+  hasObject(objects: Object3D): boolean;
+
+  getOwnObjects(objects: Object3D | Object3D[]): Object3D[];
+
+  getObjectsByHandles(handles: string | string[]): Object3D[];
+
+  getHandlesByObjects(objects: Object3D | Object3D[]): string[];
+
+  hideObjects(objects: Object3D | Object3D[]): this;
+
+  hideAllObjects(): this;
+
+  isolateObjects(objects: Object3D | Object3D[]): this;
+
+  showObjects(objects: Object3D | Object3D[]): this;
+
+  showAllObjects(): this;
+
+  showOriginalObjects(objects: Object3D | Object3D[]): this;
+
+  hideOriginalObjects(objects: Object3D | Object3D[]): this;
+
+  explode(scale: number, coeff?: number): this;
+}

package/src/Viewer/models/ModelImpl.ts

@@ -0,0 +1,214 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, 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-2025 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 { Box3, Object3D, Vector3 } from "three";
+import { ILoader } from "@inweb/viewer-core";
+
+import { IModelImpl } from "./IModelImpl";
+import { Viewer } from "../Viewer";
+
+// Basic model implementation.
+
+export class ModelImpl implements IModelImpl {
+  public handle: string;
+  public scene: Object3D;
+  public loader: ILoader;
+  public viewer: Viewer;
+
+  constructor(scene: Object3D) {
+    this.handle = "1";
+    this.scene = scene;
+  }
+
+  dispose() {
+    function disposeMaterial(material: any) {
+      // if (material.alphaMap) material.alphaMap.dispose();
+      // if (material.anisotropyMap) material.anisotropyMap.dispose();
+      // if (material.aoMap) material.aoMap.dispose();
+      // if (material.bumpMap) material.bumpMap.dispose();
+      // if (material.clearcoatMap) material.clearcoatMap.dispose();
+      // if (material.clearcoatNormalMap) material.clearcoatNormalMap.dispose();
+      // if (material.clearcoatRoughnessMap) material.clearcoatRoughnessMap.dispose();
+      // if (material.displacementMap) material.displacementMap.dispose();
+      // if (material.emissiveMap) material.emissiveMap.dispose();
+      // if (material.gradientMap) material.gradientMap.dispose();
+      // if (material.envMap) material.envMap.dispose();
+      // if (material.iridescenceMap) material.iridescenceMap.dispose();
+      // if (material.lightMap) material.lightMap.dispose();
+      // if (material.map) material.map.dispose();
+      // if (material.metalnessMap) material.metalnessMap.dispose();
+      // if (material.normalMap) material.normalMap.dispose();
+      // if (material.roughnessMap) material.roughnessMap.dispose();
+      // if (material.sheenColorMap) material.sheenColorMap.dispose();
+      // if (material.sheenRoughnessMap) material.sheenRoughnessMap.dispose();
+      // if (material.specularMap) material.specularMap.dispose();
+      // if (material.thicknessMap) material.thicknessMap.dispose();
+      // if (material.transmissionMap) material.transmissionMap.dispose();
+      material.dispose();
+    }
+
+    function disposeMaterials(material: any) {
+      const materials = Array.isArray(material) ? material : [material];
+      materials.forEach((material: any) => disposeMaterial(material));
+    }
+
+    function disposeObject(object: any) {
+      if (object.geometry) object.geometry.dispose();
+      if (object.material) disposeMaterials(object.material);
+    }
+
+    this.scene.traverse(disposeObject);
+    this.scene.clear();
+  }
+
+  getExtents(target: Box3): Box3 {
+    this.scene.traverseVisible((object) => !object.children.length && target.expandByObject(object));
+    return target;
+  }
+
+  getObjects(): Object3D[] {
+    const objects = [];
+    this.scene.traverse((object) => objects.push(object));
+    return objects;
+  }
+
+  getVisibleObjects(): Object3D[] {
+    const objects = [];
+    this.scene.traverseVisible((object) => objects.push(object));
+    return objects;
+  }
+
+  hasObject(object: Object3D): boolean {
+    while (object) {
+      if (object === this.scene) return true;
+      object = object.parent;
+    }
+    return false;
+  }
+
+  getOwnObjects(objects: Object3D | Object3D[]): Object3D[] {
+    if (!Array.isArray(objects)) objects = [objects];
+    return objects.filter((object) => this.hasObject(object));
+  }
+
+  getObjectsByHandles(handles: string | string[]): Object3D[] {
+    const handleSet = new Set(handles);
+    const objects = [];
+    this.scene.traverse((object) => handleSet.has(object.userData.handle) && objects.push(object));
+    return objects;
+  }
+
+  getHandlesByObjects(objects: Object3D | Object3D[]): string[] {
+    if (!Array.isArray(objects)) objects = [objects];
+    const handlesSet = new Set<string>();
+    this.getOwnObjects(objects).forEach((object) => handlesSet.add(object.userData.handle));
+    return Array.from(handlesSet);
+  }
+
+  hideObjects(objects: Object3D | Object3D[]): this {
+    if (!Array.isArray(objects)) objects = [objects];
+    this.getOwnObjects(objects).forEach((object) => (object.visible = false));
+    return this;
+  }
+
+  hideAllObjects(): this {
+    return this.isolateObjects([]);
+  }
+
+  isolateObjects(objects: Object3D | Object3D[]): this {
+    if (!Array.isArray(objects)) objects = [objects];
+    const visibleSet = new Set(objects);
+    this.getOwnObjects(objects).forEach((object) => object.traverseAncestors((parent) => visibleSet.add(parent)));
+    this.scene.traverse((object) => (object.visible = visibleSet.has(object)));
+    return this;
+  }
+
+  showObjects(objects: Object3D | Object3D[]): this {
+    if (!Array.isArray(objects)) objects = [objects];
+    this.getOwnObjects(objects).forEach((object) => {
+      object.visible = true;
+      object.traverseAncestors((parent) => (parent.visible = true));
+    });
+    return this;
+  }
+
+  showAllObjects(): this {
+    this.scene.traverse((object) => (object.visible = true));
+    return this;
+  }
+
+  showOriginalObjects(objects: Object3D | Object3D[]): this {
+    return this;
+  }
+
+  hideOriginalObjects(objects: Object3D | Object3D[]): this {
+    return this;
+  }
+
+  explode(scale = 0, coeff = 4): this {
+    function calcExplodeDepth(object: Object3D, depth: number): number {
+      let res = depth;
+      object.children.forEach((x: Object3D) => {
+        const objectDepth = calcExplodeDepth(x, depth + 1);
+        if (res < objectDepth) res = objectDepth;
+      });
+
+      object.userData.originalPosition = object.position.clone();
+      object.userData.originalCenter = new Box3().setFromObject(object).getCenter(new Vector3());
+      object.userData.isExplodeLocked = depth > 2 && object.children.length === 0;
+
+      return res;
+    }
+
+    scale /= 100;
+
+    if (!this.scene.userData.explodeDepth) this.scene.userData.explodeDepth = calcExplodeDepth(this.scene, 1);
+    const maxDepth = this.scene.userData.explodeDepth;
+
+    const scaledExplodeDepth = scale * maxDepth + 1;
+    const explodeDepth = 0 | scaledExplodeDepth;
+    const currentSegmentFraction = scaledExplodeDepth - explodeDepth;
+
+    function explodeObject(object: Object3D, depth: number) {
+      object.position.copy(object.userData.originalPosition);
+
+      if (depth > 0 && depth <= explodeDepth && !object.userData.isExplodeLocked) {
+        let objectScale = scale * coeff;
+        if (depth === explodeDepth) objectScale *= currentSegmentFraction;
+
+        const parentCenter = object.parent.userData.originalCenter;
+        const objectCenter = object.userData.originalCenter;
+        const objectOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
+
+        object.position.add(objectOffset);
+      }
+
+      object.children.forEach((x) => explodeObject(x, depth + 1));
+    }
+
+    explodeObject(this.scene, 0);
+    this.scene.updateMatrixWorld();
+
+    return this;
+  }
+}

package/src/Viewer/postprocessing/SSAARenderPass.js

@@ -0,0 +1,245 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, 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-2025 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],
+  ],
+];

package/src/Viewer/scenes/Helpers.ts

@@ -0,0 +1,42 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, 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-2025 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 { Scene, WebGLRenderer } from "three";
+
+export class Helpers extends Scene {
+  private oldAutoClear = false;
+  private oldClippingPlanes = [];
+
+  override onBeforeRender(renderer: WebGLRenderer): void {
+    this.oldAutoClear = renderer.autoClear;
+    this.oldClippingPlanes = renderer.clippingPlanes;
+
+    renderer.autoClear = false;
+    renderer.clippingPlanes = [];
+  }
+
+  override onAfterRender(renderer: WebGLRenderer): void {
+    renderer.clippingPlanes = this.oldClippingPlanes;
+    renderer.autoClear = this.oldAutoClear;
+  }
+}

package/src/index.ts

@@ -26,7 +26,8 @@ export * from "./Viewer/commands";
 export * from "./Viewer/components";
 export * from "./Viewer/loaders";
 export * from "./Viewer/loaders/GLTFLoadingManager";
-export * from "./Viewer/model";
+export * from "./Viewer/models/IModelImpl";
+export * from "./Viewer/models/ModelImpl";
 export * from "./Viewer/Viewer";
 
 // the lines below are required for typedoc to include the viewer core and markups documentation