viral-viewer-2 7.2.1 → 7.2.2

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

@@ -1,6 +1,6 @@
 import CameraControls from "camera-controls";
 import { type Object3D, OrthographicCamera, PerspectiveCamera, Raycaster, Vector3 } from "three";
-import { ViralCameraEventType, type ViralViewerState } from "../..";
+import { ViralCameraEventType, type ViralutionCamera, type ViralViewerState } from "../..";
 import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralCamera {
     viralViewerApi: ViralViewerApi;
@@ -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/viral-bim-world.d.ts

@@ -91,6 +91,13 @@ export declare class ViralBIMWorld 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/loader/viral-revit.loader.d.ts

@@ -1,4 +1,4 @@
-import { type ViralutionElement, type ViralutionTrackingModel } from "../..";
+import { type ViralutionElement } from "../..";
 import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralRevitLoader {
     viralViewerApi: ViralViewerApi;
@@ -8,7 +8,6 @@ export declare class ViralRevitLoader {
     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/post-processing/post-processing-renderer.d.ts

@@ -7,6 +7,7 @@ import { SMAAPass } from "three/examples/jsm/postprocessing/SMAAPass";
 import { type ViralViewerApi } from "../..";
 import { DevicePerformanceChecker } from "../../utils/device";
 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/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/visibility-manager/viral-visibility-manager.d.ts

@@ -3,8 +3,17 @@ import { type SunLightConfiguration } from "../..";
 import type { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralVisibilityManager {
     private viralViewerApi;
+    /** Whether selection outline is enabled (default: true) */
+    private _selectionOutlineEnabled;
     constructor(viralViewerApi: ViralViewerApi);
+    /**
+     * show all elements and reset back to normal visualization
+     */
     showAll2(): void;
+    /**
+     * hide all elements and reset back to normal visualization
+     */
+    hideAllElements(): void;
     /**
      *
      * @param elements default will get selected elements or we can input specific elements
@@ -114,6 +123,15 @@ export declare class ViralVisibilityManager {
      * 🔧 FAST: Resume screen-space edges after camera stops
      */
     resumeScreenSpaceEdge(): void;
+    /**
+     * 🔧 FAST: Bypass selection outline during camera movement
+     * Much faster than disable - skips mask render but keeps pass in pipeline
+     */
+    bypassSelectionOutline(): void;
+    /**
+     * 🔧 FAST: Resume selection outline after camera stops
+     */
+    resumeSelectionOutline(): void;
     /**
      * Configure screen-space edge detection
      */
@@ -144,6 +162,28 @@ export declare class ViralVisibilityManager {
         modelId: string;
         elementId: string;
     }[]): void;
+    /**
+     * Update selection outline pass with current selection
+     * Uses merged geometry for efficient rendering
+     */
+    updateSelectionOutline(): void;
+    /**
+     * Enable selection outline effect
+     */
+    enableSelectionOutline(): void;
+    /**
+     * Disable selection outline effect
+     */
+    disableSelectionOutline(): void;
+    /**
+     * Set whether selection outline mode is enabled
+     * @param enabled - true to enable outline on selection, false to disable
+     */
+    setSelectionOutlineMode(enabled: boolean): void;
+    /**
+     * Get whether selection outline mode is enabled
+     */
+    get selectionOutlineEnabled(): boolean;
     enableNight(): void;
     disableNight(): void;
     enableSectionBox(): void;

package/dist/entities/data-tree.d.ts

@@ -117,7 +117,12 @@ export declare class DataTree {
      * @param layoutOptions Layout options
      * @returns Promise that resolves with nodes and edges
      */
-    toGraphAsync(layoutOptions?: GraphLayoutOptions): Promise<{
+    toGraphAsync(layoutOptions?: GraphLayoutOptions, onProgress?: (progress: {
+        phase: string;
+        percent: number;
+        current: number;
+        total: number;
+    }) => void): Promise<{
         nodes: GraphNode[];
         edges: GraphEdge[];
     }>;