viral-viewer-2 7.2.0 → 7.2.2

package/dist/batched-mesh-simplifier-D-o3ukyo.mjs

@@ -0,0 +1,128 @@
+import { BufferGeometry as $, BufferAttribute as S } from "three";
+import { ViralBatchedMesh as B } from "./index.mjs";
+import { MeshoptSimplifier as w } from "meshoptimizer";
+let x = !1;
+w.ready.then(() => {
+  x = !0, console.log("✅ MeshoptSimplifier ready");
+}).catch((t) => {
+  console.error("❌ MeshoptSimplifier failed to load:", t);
+});
+async function A(t, a, e) {
+  if (x || await w.ready, t.length === 0 || a.length === 0)
+    throw new Error("Simplify: empty indices or positions array");
+  if (t.length % 3 !== 0)
+    throw new Error("Simplify: indices length must be a multiple of 3 (triangles)");
+  if (a.length % 3 !== 0)
+    throw new Error("Simplify: positions length must be a multiple of 3 (x,y,z)");
+  let i;
+  t instanceof Uint32Array ? i = t : t instanceof Uint16Array || t instanceof Uint8Array ? i = new Uint32Array(t) : i = new Uint32Array(t);
+  const s = a instanceof Float32Array ? a : new Float32Array(a), c = e.error ?? 0.01, n = e.ratio ?? 0.5, o = Math.floor(i.length / 3), d = Math.max(1, Math.floor(o * n)) * 3, g = [];
+  e.lockBorder && g.push("LockBorder"), e.sparse && g.push("Sparse"), e.errorAbsolute && g.push("ErrorAbsolute"), e.prune && g.push("Prune");
+  try {
+    const m = w.simplify(
+      i,
+      s,
+      3,
+      // stride: 3 floats per vertex (x, y, z)
+      d,
+      c,
+      g.length > 0 ? g : void 0
+    ), r = m[0], f = m[1];
+    e.logAppearanceError && console.log(`Simplify: appearance error: ${f}`);
+    const u = ((1 - r.length / i.length) * 100).toFixed(
+      1
+    );
+    r.length === i.length ? console.warn(
+      `Simplify: no reduction achieved (tried ratio=${n}, error=${c}). Consider increasing error tolerance or decreasing ratio.`
+    ) : console.log(
+      `✅ Simplification: ${i.length} → ${r.length} indices (${u}% reduction)`
+    );
+    const h = s.length / 3;
+    if (e.optimizeMemory && h <= 65535)
+      if (h <= 255) {
+        const y = new Uint8Array(r.length);
+        for (let l = 0; l < r.length; l++)
+          y[l] = r[l];
+        return [y, f];
+      } else {
+        const y = new Uint16Array(r.length);
+        for (let l = 0; l < r.length; l++)
+          y[l] = r[l];
+        return [y, f];
+      }
+    return [r, f];
+  } catch (m) {
+    throw console.error("Simplify failed:", m), m;
+  }
+}
+async function I(t, a) {
+  const e = t.buffer, i = e.length / 3;
+  if (i < 50)
+    return t;
+  const s = /* @__PURE__ */ new Map(), c = [], n = [], o = 1e-4;
+  for (let r = 0; r < i; r++) {
+    const f = e[r * 3], u = e[r * 3 + 1], h = e[r * 3 + 2], y = `${Math.round(f / o)},${Math.round(u / o)},${Math.round(h / o)}`;
+    let l = s.get(y);
+    l === void 0 && (l = c.length / 3, s.set(y, l), c.push(f, u, h)), n.push(l);
+  }
+  if (c.length / 3 >= i * 0.95)
+    return t;
+  const d = new Float32Array(c), g = new Uint32Array(n), m = {
+    ...a,
+    ratio: a.ratio ?? 0.5
+  };
+  try {
+    const [r] = await A(g, d, m);
+    if (r.length === 0 || r.length < 3)
+      return console.warn(
+        `Element ${t.elementId} simplified to ${r.length} indices (too small), keeping original`
+      ), t;
+    if (r.length === g.length)
+      return t;
+    const f = new Float32Array(r.length * 3);
+    for (let u = 0; u < r.length; u++) {
+      const h = r[u];
+      f[u * 3] = d[h * 3], f[u * 3 + 1] = d[h * 3 + 1], f[u * 3 + 2] = d[h * 3 + 2];
+    }
+    return {
+      ...t,
+      buffer: f
+    };
+  } catch (r) {
+    return console.warn(`Simplification failed for element ${t.elementId}:`, r), t;
+  }
+}
+async function C(t, a, e = 100) {
+  const i = [];
+  for (let s = 0; s < t.length; s += e) {
+    const n = t.slice(s, s + e).map((p) => !p.buffer || p.buffer.length < 9 ? Promise.resolve(p) : I(p, a).catch((d) => (console.warn(`Failed to simplify element ${p.elementId}:`, d), p))), o = await Promise.all(n);
+    if (i.push(...o), t.length > 1e3) {
+      const p = Math.min(100, (s + e) / t.length * 100);
+      console.log(`📊 Simplification progress: ${p.toFixed(1)}%`);
+    }
+  }
+  return i;
+}
+async function E(t, a) {
+  const e = t.geometry;
+  if (!e.index)
+    throw new Error("Batched mesh geometry must be indexed");
+  console.log(`🚀 Fast simplification: ${e.index.count} indices...`);
+  const i = e.index.array, s = e.attributes.position.array, [c] = await A(i, s, a);
+  console.log(
+    `✅ Fast simplification: ${i.length} → ${c.length} indices (${((1 - c.length / i.length) * 100).toFixed(1)}% reduction)`
+  );
+  const n = new $();
+  n.setAttribute("position", e.attributes.position.clone()), e.attributes.color && n.setAttribute("color", e.attributes.color.clone()), n.setIndex(new S(c, 1)), n.computeBoundingBox(), n.computeBoundingSphere();
+  const o = new B(
+    n,
+    Array.isArray(t.material) ? t.material[0] : t.material,
+    void 0
+    // Worker pool not needed for already-built geometry
+  );
+  return o.globalMaterialIndex = t.globalMaterialIndex, o.castShadow = t.castShadow, o.receiveShadow = t.receiveShadow, o.position.copy(t.position), o.rotation.copy(t.rotation), o.scale.copy(t.scale), o;
+}
+export {
+  E as simplifyBatchedMeshFast,
+  C as simplifyBufferElementsBatch
+};

package/dist/components/animation/viral-animation.d.ts

@@ -1,5 +1,5 @@
 import { Clock } from "three";
-import { ViralViewerApi } from "../../viral-viewer-api";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralAnimation {
     viralViewerApi: ViralViewerApi;
     clock: Clock;

package/dist/components/avatar-manager/viral-avatar-manager.d.ts

@@ -1,4 +1,4 @@
-import { ViralViewerApi } from "../..";
+import type { ViralViewerApi } from "../..";
 import { ViralAvatar } from "../custom-objects/viral-avatar";
 export declare class ViralAvatarManager {
     private viralViewerApi;

package/dist/components/camera/viral-camera.d.ts

@@ -1,7 +1,7 @@
 import CameraControls from "camera-controls";
-import { ViralViewerApi } from "../../viral-viewer-api";
-import { Vector3, Raycaster, PerspectiveCamera, Object3D, OrthographicCamera } from "three";
-import { ViralCameraEventType, ViralViewerState } from "../..";
+import { type Object3D, OrthographicCamera, PerspectiveCamera, Raycaster, Vector3 } from "three";
+import { ViralCameraEventType, type ViralutionCamera, type ViralViewerState } from "../..";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralCamera {
     viralViewerApi: ViralViewerApi;
     raycaster: Raycaster;
@@ -22,11 +22,6 @@ export declare class ViralCamera {
      */
     resizeCanvas(): void;
     resizeCanvas2(): void;
-    /**
-     * focuse model
-     * @param objectName :model name
-     */
-    focusModelByName(objectName?: string): void;
     getState(): ViralViewerState | null;
     restoreState(state: ViralViewerState): void;
     modelId: string;
@@ -53,4 +48,10 @@ export declare class ViralCamera {
     addEventListener(type: ViralCameraEventType, key: string, resolve: () => void): void;
     removeEventListener(type: ViralCameraEventType, key: string): void;
     getAllEventListener(): void;
+    backHome(): Promise<void>;
+    /**
+     * This function focus camera on model by given ViralutionCamera
+     * @param camera
+     */
+    focusCameraOnModel(camera: ViralutionCamera, transition?: boolean): Promise<void>;
 }

package/dist/components/custom-objects/index.d.ts

@@ -1,4 +1,3 @@
-import { ViralInstancedMesh } from "./viral-instanced-mesh";
 import { ViralBatchedMesh } from "./viral-batched-mesh";
-import { ViralMergedModel } from "./viral-merged-model";
-export { ViralInstancedMesh, ViralMergedModel, ViralBatchedMesh };
+import { ViralBIMWorld } from "./viral-bim-world";
+export { ViralBIMWorld, ViralBatchedMesh };

package/dist/components/custom-objects/viral-avatar.d.ts

@@ -1,5 +1,5 @@
-import { Object3D, Vector3 } from "three";
-import { ViralViewerApi } from "../..";
+import { type Object3D, Vector3 } from "three";
+import { type ViralViewerApi } from "../..";
 export declare class ViralAvatar {
     private viralViewerApi;
     scaleRatio: number;

package/dist/components/custom-objects/viral-batched-mesh.d.ts

@@ -1,10 +1,11 @@
-import { Box3, BufferGeometry, Color, Material, Mesh, Vector3 } from "three";
-import { BufferElement } from "../..";
-import { LineMaterial } from "three/examples/jsm/Addons";
-import { WorkerThreadPool } from "../worker/base/worker-pool";
+import { Box3, BufferGeometry, type Color, type Material, Mesh, Vector3 } from "three";
+import { type LineMaterial } from "three/examples/jsm/Addons";
+import { type BufferElement } from "../..";
+import type { WorkerThreadPool } from "../worker/base/worker-pool";
 export declare class ViralBatchedMesh extends Mesh {
     globalMaterialIndex: number;
     private workerPool;
+    private _depthPrePassMesh;
     constructor(geometry?: BufferGeometry, material?: Material, workerPool?: WorkerThreadPool | null);
     /**
      * *for tracking and manage element visibility, for instance hide object
@@ -200,6 +201,15 @@ export declare class ViralBatchedMesh extends Mesh {
         modelId: string;
         elementId: string;
     }[], ghostOpacity?: number): void;
+    /**
+     * Create a depth-only pre-pass mesh that writes depth for focused elements.
+     * Shares the same geometry; uses alphaTest to discard ghost fragments.
+     */
+    private _createDepthPrePass;
+    /**
+     * Remove and dispose the depth pre-pass mesh
+     */
+    private _removeDepthPrePass;
     /**
      * Reset all element opacities to fully opaque and restore original colors
      */

package/dist/components/custom-objects/{viral-merged-model.d.ts → viral-bim-world.d.ts}

@@ -1,15 +1,17 @@
 import { Box3, Mesh } from "three";
+import { type BufferElement } from "../..";
+import { WorkerThreadPool } from "../worker/base/worker-pool";
 import { ViralBatchedMesh } from "./viral-batched-mesh";
-import { BufferElement } from "../..";
+import type { ViralBIMModel } from "./viral-bim.model";
 import { ViralInstancedMeshV2 } from "./viral-instanced-mesh-v2";
-import { WorkerThreadPool } from "../worker/base/worker-pool";
 /**
- * this class is a wrapper, it stand for a clone of bim model (optimize version to increase performance when render)
- * it merge geometries follow material.
+ * this class is a wrapper, it stand for a world of bim models
+ * it merge geometries follow material or using instanced mesh.
  *
  */
-export declare class ViralMergedModel extends Mesh {
+export declare class ViralBIMWorld extends Mesh {
     workerPool: WorkerThreadPool | null;
+    bimModels: ViralBIMModel[];
     constructor();
     private _initializeWorkerPool;
     get bounds(): Box3;
@@ -24,7 +26,6 @@ export declare class ViralMergedModel extends Mesh {
      */
     getDiagnostics(): {
         totalChildren: number;
-        edgeMeshes: number;
         batchedMeshesInChildren: number;
         batchedMeshesInArray: number;
         instancedMeshes: number;
@@ -90,6 +91,13 @@ export declare class ViralMergedModel extends Mesh {
         modelId: string;
         elementId: string;
     }[];
+    /**
+     * Get merged position buffer for selected elements (for outline rendering)
+     * Returns all vertex positions merged into a single Float32Array
+     * Handles both batched meshes (direct buffer) and instanced meshes (applies transforms)
+     * @returns Float32Array of positions or null if no selection
+     */
+    getSelectedElementsPositions(): Float32Array | null;
     /**
      * Changes the color of multiple elements in the merged mesh.
      * Works with RGBA color buffer (preserves existing alpha values)

package/dist/components/custom-objects/viral-bim.model.d.ts

@@ -0,0 +1,11 @@
+import { Dictionary, type RenderMaterial, type ViralutionElement } from "../..";
+/**
+ * this is a wrapper to manage whole BIM Model
+ */
+export declare class ViralBIMModel {
+    modelId: number;
+    elements: ViralutionElement[];
+    materials: RenderMaterial[];
+    mapMaterialsToMaterialManager: Dictionary<number, number>;
+    dispose(): void;
+}

package/dist/components/custom-objects/viral-instanced-mesh-v2.d.ts

@@ -1,9 +1,10 @@
-import { Box3, BufferGeometry, Color, Material, Vector3, Matrix4, InstancedMesh, Object3D } from "three";
-import { BufferElement } from "../..";
-import { LineMaterial } from "three/examples/jsm/Addons";
+import { Box3, BufferGeometry, Color, InstancedMesh, type Material, Matrix4, Object3D, Vector3 } from "three";
+import { type LineMaterial } from "three/examples/jsm/Addons";
+import { type BufferElement } from "../..";
 export declare class ViralInstancedMeshV2 extends Object3D {
     protected material?: Material | undefined;
     globalMaterialIndex: number;
+    private _depthPrePassMeshes;
     constructor(material?: Material | undefined);
     protected _instancedMeshes: Map<string, InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, Material | Material[], import("three").InstancedMeshEventMap>>;
     _bufferElements: BufferElement[];
@@ -208,6 +209,16 @@ export declare class ViralInstancedMeshV2 extends Object3D {
         modelId: string;
         elementId: string;
     }[], ghostOpacity?: number): void;
+    /**
+     * Create depth-only pre-pass instanced meshes that write depth for focused instances.
+     * Shares the same geometry (including instanceOpacity attribute); uses shader discard
+     * to skip ghost instances (opacity < 0.5).
+     */
+    private _createDepthPrePass;
+    /**
+     * Remove and dispose all depth pre-pass meshes
+     */
+    private _removeDepthPrePass;
     /**
      * Desaturate instance color (turn whitish)
      * @param modelId - Model ID

package/dist/components/data-manager/viral-data-manager.d.ts

@@ -1,4 +1,4 @@
-import { CheckClashResult, CompareModelsResult, DataTree, GroupByResult, ViralutionInformation, ViralutionTrackingModel, ViralViewerApi } from "../..";
+import { CheckClashResult, CompareModelsResult, DataTree, GroupByResult, type ViralutionInformation, type ViralutionTrackingModel, type ViralViewerApi } from "../..";
 export declare class ViralDataManager {
     viralViewerApi: ViralViewerApi;
     dataTree: DataTree[];

package/dist/components/duplication-analyzer/viral-duplication-analyzer.d.ts

@@ -1,4 +1,4 @@
-import { ViralutionElement } from "../../..";
+import type { ViralutionElement } from "../..";
 export interface DuplicationAnalysis {
     strategy: "BATCHING" | "INSTANCING" | "HYBRID";
     totalElements: number;

package/dist/components/event-handler/keyboard/viral-keyboard.d.ts

@@ -1,4 +1,4 @@
-import { ViralKeyboardEventType, ViralViewerApi } from "../../..";
+import { ViralKeyboardEventType, type ViralViewerApi } from "../../..";
 export declare class ViralKeyboard {
     viralViewerApi: ViralViewerApi;
     constructor(viralViewerApi: ViralViewerApi);

package/dist/components/event-handler/mouse/viral-mouse.d.ts

@@ -1,6 +1,6 @@
 import { Vector2 } from "three";
-import { ViralViewerApi } from "../../../viral-viewer-api";
 import { ViralMouseEventType } from "../../..";
+import type { ViralViewerApi } from "../../../viral-viewer-api";
 export declare class ViralMouse {
     viralViewerApi: ViralViewerApi;
     position: Vector2;
@@ -22,9 +22,6 @@ export declare class ViralMouse {
     addEventListener(type: ViralMouseEventType, key: string, resolve: (result: any) => void): void;
     removeEventListener(type: ViralMouseEventType, key: string): void;
     getAllEventListener(): void;
-    private hoverMeshes;
-    private hover;
-    private reverseColor;
     private setupMouseDown;
     private handleClick;
     private setupMouseUp;

package/dist/components/event-handler/viral-centralized-event-handler.d.ts

@@ -1,4 +1,4 @@
-import { ViralViewerApi } from "../../viral-viewer-api";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralCentralizedEventHandler {
     viralViewerApi: ViralViewerApi;
     private _visibilityManager;
@@ -16,15 +16,6 @@ export declare class ViralCentralizedEventHandler {
     private resizeObserver;
     windowHandler(): void;
     disposeWindowHandler(): void;
-    private _hoverElementEnable;
-    hoverElementHandler(): void;
-    enableHoverElement(value: boolean): void;
-    private _selectElementEnable;
-    /**
-     * @deprecated use selectElementHandler2 instead
-     */
-    selectElementHandler(): void;
-    enableSelectElement(value: boolean): void;
     selectElementHandler2(): void;
     doubleClickElementHandler(): void;
     isShiftPressed: boolean;

package/dist/components/event-handler/viral-lifecycle-event-handler.d.ts

@@ -1,5 +1,5 @@
-import { ViewerOptions } from "../../..";
-import { ViralViewerApi } from "../../viral-viewer-api";
+import { type ViewerOptions } from "../..";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralLifecycleEventHandler {
     private viralViewerApi;
     options: ViewerOptions;

package/dist/components/loader/viral-point-cloud.loader.d.ts

@@ -1,5 +1,5 @@
-import { Potree, PointCloudOctree } from "potree-core-viral";
-import { ViralViewerApi } from "../../viral-viewer-api";
+import { type PointCloudOctree, Potree } from "potree-core-viral";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralPointCloudLoader {
     viralViewerApi: ViralViewerApi;
     potree: Potree;

package/dist/components/loader/viral-revit.loader.d.ts

@@ -1,14 +1,13 @@
-import { ViralViewerApi } from "../../viral-viewer-api";
-import { ViralutionElement, ViralutionTrackingModel } from "../..";
+import { type ViralutionElement } from "../..";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralRevitLoader {
     viralViewerApi: ViralViewerApi;
     elements: ViralutionElement[];
-    private _loadElementBatchWorker;
+    private _loadBatchedElementWorker;
     constructor(viralViewerApi: ViralViewerApi);
     load(trackingUrl: string, dataUrl: string, informationUrl: string, callbackOnFinish?: () => void): Promise<void>;
     getMaterials(dataUrl: string, byteRangeStart: number, byteRangeEnd: number): Promise<any>;
     getElements(dataUrl: string, chunk: number[][], callbackOnSuccess?: (model: any, index: number) => void): Promise<void>;
-    focusCameraOnModel(trackingModel: ViralutionTrackingModel): Promise<void>;
     getTranslation(translation: number[]): {
         x: number;
         y: number;

package/dist/components/loader/viral-three.loader.d.ts

@@ -1,6 +1,6 @@
 import { ObjectLoader } from "three";
-import { ViralViewerApi } from "../../viral-viewer-api";
-import { GLTF, GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+import { type GLTF, GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralThreeLoader {
     viralViewerApi: ViralViewerApi;
     objectLoader: ObjectLoader;

package/dist/components/loader/viral.loader.d.ts

@@ -1,4 +1,4 @@
-import { ViralViewerApi } from "../../viral-viewer-api";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 import { ViralPointCloudLoader } from "./viral-point-cloud.loader";
 import { ViralRevitLoader } from "./viral-revit.loader";
 import { ViralThreeLoader } from "./viral-three.loader";

package/dist/components/material/viral-material-manager.d.ts

@@ -1,6 +1,6 @@
-import { Material, MeshPhongMaterial, MeshStandardMaterial } from "three";
-import { ViralViewerApi } from "../../viral-viewer-api";
+import { type Material, MeshPhongMaterial, MeshStandardMaterial } from "three";
 import { LineMaterial } from "three/examples/jsm/lines/LineMaterial";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralMaterialManager {
     private viralViewerApi;
     hoverMaterial: MeshPhongMaterial;

package/dist/components/post-processing/post-processing-renderer.d.ts

@@ -1,12 +1,13 @@
-import { Camera, Color, Scene, WebGLRenderer } from "three";
-import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer";
-import { SMAAPass } from "three/examples/jsm/postprocessing/SMAAPass";
-import { ShaderPass } from "three/examples/jsm/postprocessing/ShaderPass";
+import { type Camera, Color, type Scene, type WebGLRenderer } from "three";
 import { SAOPass, SSAARenderPass, SSAOPass, TAARenderPass } from "three/examples/jsm/Addons";
-import { ViralViewerApi } from "../..";
+import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer";
 import { OutlinePass } from "three/examples/jsm/postprocessing/OutlinePass";
+import { ShaderPass } from "three/examples/jsm/postprocessing/ShaderPass";
+import { SMAAPass } from "three/examples/jsm/postprocessing/SMAAPass";
+import { type ViralViewerApi } from "../..";
 import { DevicePerformanceChecker } from "../../utils/device";
-import { ScreenSpaceEdgesPass, ScreenSpaceEdgesOptions } from "./screen-space-edges-pass";
+import { type ScreenSpaceEdgesOptions, ScreenSpaceEdgesPass } from "./screen-space-edges-pass";
+import { type SelectionOutlineOptions, SelectionOutlinePass } from "./selection-outline-pass";
 export declare class PostProcessingRenderer {
     private renderer;
     viralViewerApi: ViralViewerApi;
@@ -24,6 +25,7 @@ export declare class PostProcessingRenderer {
     shadowRemovalPass: ShaderPass | null;
     outlinePass: OutlinePass | null;
     screenSpaceEdgesPass: ScreenSpaceEdgesPass | null;
+    selectionOutlinePass: SelectionOutlinePass | null;
     n8aoPass: any;
     perfChecker: DevicePerformanceChecker;
     constructor(renderer: WebGLRenderer, viralViewerApi: ViralViewerApi);
@@ -113,4 +115,47 @@ export declare class PostProcessingRenderer {
     initOutlinePass(scene: Scene, camera: Camera): void;
     enableOutline(): void;
     disableOutline(): void;
+    /**
+     * Initialize lightweight selection outline pass
+     * Renders selected geometry to mask, then applies Sobel edge detection
+     * Cost: 1 extra draw call + 1 fullscreen pass
+     */
+    initSelectionOutlinePass(scene: Scene, camera: Camera): void;
+    /**
+     * Update selection outline geometry
+     * Call this when selection changes
+     * @param positions - Merged Float32Array of selected element positions, or null to clear
+     */
+    updateSelectionOutline(positions: Float32Array | null): void;
+    /**
+     * Enable selection outline rendering
+     */
+    enableSelectionOutline(): void;
+    /**
+     * Disable selection outline rendering
+     */
+    disableSelectionOutline(): void;
+    /**
+     * 🔧 FAST: Bypass selection outline (instant, no mask render)
+     * Use this during camera movement for smooth performance
+     * The pass stays in the pipeline but just copies input to output
+     */
+    bypassSelectionOutline(): void;
+    /**
+     * 🔧 FAST: Resume selection outline after bypassing
+     * Call this when camera stops moving
+     */
+    resumeSelectionOutline(): void;
+    /**
+     * Configure selection outline options
+     */
+    setSelectionOutlineOptions(options: Partial<SelectionOutlineOptions>): void;
+    /**
+     * Set selection outline color
+     */
+    setSelectionOutlineColor(color: Color | number | string): void;
+    /**
+     * Set selection outline thickness in pixels
+     */
+    setSelectionOutlineThickness(thickness: number): void;
 }

package/dist/components/post-processing/screen-space-edges-pass.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Color, Scene, Vector2, WebGLRenderer, WebGLRenderTarget } from "three";
+import { type Camera, Color, type Object3D, type Scene, Vector2, type WebGLRenderer, WebGLRenderTarget } from "three";
 import { Pass } from "three/examples/jsm/postprocessing/Pass";
 /**
  * Screen-Space Edge Detection Pass
@@ -45,6 +45,12 @@ export declare class ScreenSpaceEdgesPass extends Pass {
     private copyMaterial;
     private fsQuad;
     options: ScreenSpaceEdgesOptions;
+    /**
+     * Objects to exclude from edge detection.
+     * These objects will be temporarily hidden during the normal/depth render pass.
+     * Use this to exclude UI elements, section box visuals, helpers, etc.
+     */
+    excludeObjects: Object3D[];
     /**
      * 🔧 FAST TOGGLE: When true, skips geometry renders and just passes through the image
      * Use this instead of `enabled` for faster on/off during camera movement

package/dist/components/post-processing/selection-outline-pass.d.ts

@@ -0,0 +1,65 @@
+import type { Camera, WebGLRenderer } from "three";
+import { Color, Scene, type Vector2, WebGLRenderTarget } from "three";
+import { Pass } from "three/examples/jsm/postprocessing/Pass";
+/**
+ * Selection Outline Pass
+ *
+ * Lightweight outline effect for selected elements in merged geometry.
+ * Cost: 1 extra draw call (for mask) + 1 fullscreen Sobel pass
+ *
+ * Process:
+ * 1. Render selected geometry to mask texture (white on black)
+ * 2. Sobel edge detection on mask
+ * 3. Composite colored edges over scene
+ */
+export interface SelectionOutlineOptions {
+    /** Outline color (default: accent color) */
+    outlineColor: Color;
+    /** Outline opacity 0-1 (default: 1.0) */
+    outlineOpacity: number;
+    /** Outline thickness in pixels (default: 2.0) */
+    outlineThickness: number;
+    /** Show outline for occluded parts (default: true) */
+    showOccluded: boolean;
+    /** Occluded outline opacity multiplier (default: 0.5) */
+    occludedOpacity: number;
+}
+export declare class SelectionOutlinePass extends Pass {
+    private camera;
+    private resolution;
+    private options;
+    private maskRenderTarget;
+    private maskDepthRenderTarget;
+    private maskMaterial;
+    private outlineMaterial;
+    private copyMaterial;
+    private maskScene;
+    private selectionMesh;
+    private selectionGeometry;
+    private fsQuad;
+    private hasSelection;
+    /**
+     * 🔧 FAST TOGGLE:
+     * - `bypass = false`: Full outline rendering (normal mode)
+     * - `bypass = true`: Pass runs but just copies input to output (very fast, no mask render)
+     */
+    bypass: boolean;
+    constructor(_scene: Scene, camera: Camera, resolution: Vector2, options?: Partial<SelectionOutlineOptions>);
+    /**
+     * Update selection geometry from buffer elements
+     * Call this when selection changes
+     * @param positions - Merged Float32Array of all selected element positions
+     */
+    updateSelectionGeometry(positions: Float32Array | null): void;
+    /**
+     * Get whether there's an active selection
+     */
+    get hasActiveSelection(): boolean;
+    /**
+     * Update outline options
+     */
+    setOptions(options: Partial<SelectionOutlineOptions>): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, _deltaTime?: number, _maskActive?: boolean): void;
+    setSize(width: number, height: number): void;
+    dispose(): void;
+}

package/dist/components/renderer/viral-renderer.d.ts

@@ -1,5 +1,5 @@
 import { WebGLRenderer } from "three";
-import { ViralViewerApi } from "../../viral-viewer-api";
+import type { ViralViewerApi } from "../../viral-viewer-api";
 import { PostProcessingRenderer } from "../post-processing/post-processing-renderer";
 export declare class ViralRenderer {
     viralViewerApi: ViralViewerApi;

package/dist/components/scene/viral-scene.d.ts

@@ -1,16 +1,13 @@
-import { Scene, DirectionalLight, Mesh, Object3D, MeshBasicMaterial, Light, CameraHelper, Box3, OrthographicCamera, PerspectiveCamera } from "three";
-import { ViralViewerApi } from "../../viral-viewer-api";
-import { ViralMergedModel } from "../custom-objects/viral-merged-model";
-import { ViralMainModel } from "../custom-objects/viral-main.model";
+import { type Box3, CameraHelper, DirectionalLight, type Light, Mesh, MeshBasicMaterial, type Object3D, type OrthographicCamera, type PerspectiveCamera, Scene } from "three";
 import { TransformControls } from "three/examples/jsm/controls/TransformControls";
+import type { ViralViewerApi } from "../../viral-viewer-api";
+import { ViralBIMWorld } from "../custom-objects/viral-bim-world";
 export declare class ViralScene {
     viralViewerApi: ViralViewerApi;
     scene: Scene;
     objects: Object3D[];
     models: Object3D[];
-    mainModels: ViralMainModel[];
-    isolateModel: Mesh;
-    mergedModel: ViralMergedModel;
+    bimWorld: ViralBIMWorld;
     outlineModel: Mesh;
     hideables: Object3D[];
     selectables: Object3D[];