viral-viewer-2 6.8.7 → 6.8.9

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

@@ -1,7 +1,7 @@
 import CameraControls from "camera-controls";
 import { ViralCameraEventType, ViralViewerState } from "../../types";
 import { ViralViewerApi } from "../../viral-viewer-api";
-import { Vector3, Box3, Raycaster, PerspectiveCamera, Object3D, OrthographicCamera } from "three";
+import { Vector3, Raycaster, PerspectiveCamera, Object3D, OrthographicCamera } from "three";
 export declare class ViralCamera {
     viralViewerApi: ViralViewerApi;
     raycaster: Raycaster;
@@ -40,6 +40,7 @@ export declare class ViralCamera {
     worldToClient2(point: Vector3): Vector3 | null;
     private castRay;
     updateMainCamera(): void;
+    adjustCameraFarFromScene(margin?: number): void;
     private cameraWakeQueuedEvents;
     private cameraSleepQueuedEvents;
     private cameraUpdateQueuedEvents;
@@ -52,20 +53,4 @@ export declare class ViralCamera {
     addEventListener(type: ViralCameraEventType, key: string, resolve: () => void): void;
     removeEventListener(type: ViralCameraEventType, key: string): void;
     getAllEventListener(): void;
-    /**
-     * Calculate optimal spatial grid size based on camera far plane
-     */
-    getOptimalSpatialGridSize(worldBounds: Box3): Vector3;
-    taa: {
-        enabled: boolean;
-        samples: number;
-        index: number;
-        offsets: [number, number][];
-    };
-    private halton;
-    private buildJitterOffsets;
-    enableTAA(samples?: number): void;
-    disableTAA(): void;
-    applyJitter(): void;
-    clearJitter(): void;
 }

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

@@ -1,24 +1,42 @@
 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";
 export declare class ViralBatchedMesh extends Mesh {
     globalMaterialIndex: number;
-    constructor(geometry?: BufferGeometry, material?: Material);
+    private workerPool;
+    constructor(geometry?: BufferGeometry, material?: Material, workerPool?: WorkerThreadPool | null);
     /**
      * *for tracking and manage element visibility, for instance hide object
      */
     _bufferElements: BufferElement[];
-    private _colors;
-    private _originalColor;
+    protected _colors: Float32Array | null;
+    protected _originalColor: Color | null;
     /**
      * Stores mapping of model IDs to their element data.
      */
-    private _elementMap;
+    protected _elementMap: Map<string, Map<string, {
+        /** Start index of the element in the buffer */
+        start: number;
+        /** Number of vertices associated with the element */
+        count: number;
+        indices: number[];
+    }[]>>;
     addBufferElements(bufferElements: BufferElement[], materialColor: Color): void;
     rebuildGeometry(bufferElements: BufferElement[]): void;
-    private _isBatching;
+    protected _isBatching: boolean;
     get isBatching(): boolean;
     batch(newBufferElements: BufferElement[]): void;
+    private _batchQueue;
+    private _isProcessingQueue;
+    batchAsync(newBufferElements: BufferElement[]): Promise<void>;
+    private _processQueue;
+    private _performSingleBatch;
+    private _applyWorkerResult;
+    /**
+     * Finalize geometry after batch operation
+     */
+    private _finalizeGeometry;
     /**
      * get bufferEleemnts from given ids
      * @param elements
@@ -51,7 +69,10 @@ export declare class ViralBatchedMesh extends Mesh {
     }[]): void;
     /** Restore all edges */
     edgeReset(): void;
-    private _selectedElements;
+    protected _selectedElements: {
+        modelId: string;
+        elementId: string;
+    }[];
     select(elements: {
         modelId: string;
         elementId: string;
@@ -66,12 +87,18 @@ export declare class ViralBatchedMesh extends Mesh {
             b: number;
         };
     }[]): void;
-    private _hidingElements;
+    protected _hidingElements: {
+        modelId: string;
+        elementId: string;
+    }[];
     hide(elements?: {
         modelId: string;
         elementId: string;
     }[]): void;
-    private _isolatingElements;
+    protected _isolatingElements: {
+        modelId: string;
+        elementId: string;
+    }[];
     isolate(elements?: {
         modelId: string;
         elementId: string;

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

@@ -0,0 +1,133 @@
+import { Object3D } from "three";
+import { LineMaterial } from "three/examples/jsm/Addons";
+import { ViralBatchedMesh } from "./viral-batched-mesh";
+import { ViralInstancedMeshV2 } from "./viral-instanced-mesh-v2";
+export declare class ViralEdgeMesh extends Object3D {
+    private _edgeLines;
+    private _edgeMaterial;
+    private _edgeThreshold;
+    private _edgeRanges;
+    private _batchedMeshes;
+    private _instancedMeshes;
+    private _hiddenElements;
+    private _isolatedElements;
+    private _xrayMode;
+    constructor();
+    /**
+     * Initialize edge mesh with material and threshold
+     */
+    initialize(material: LineMaterial, thresholdDeg?: number): void;
+    /**
+     * Add a batched mesh to be included in edge generation
+     */
+    addBatchedMesh(mesh: ViralBatchedMesh): void;
+    /**
+     * Add an instanced mesh to be included in edge generation
+     */
+    addInstancedMesh(mesh: ViralInstancedMeshV2): void;
+    /**
+     * Remove a mesh from edge generation
+     */
+    removeMesh(mesh: ViralBatchedMesh | ViralInstancedMeshV2): void;
+    /**
+     * Build the unified edge mesh from all registered meshes
+     */
+    buildEdges(): void;
+    /**
+     * Extract edge data from a batched mesh
+     */
+    private _extractBatchedMeshEdges;
+    /**
+     * Extract edge data from an instanced mesh
+     */
+    private _extractInstancedMeshEdges;
+    /**
+     * Track edge ranges for batched mesh elements
+     */
+    private _trackBatchedEdgeRanges;
+    /**
+     * Track edge ranges for instanced mesh elements
+     */
+    private _trackInstancedEdgeRanges;
+    /**
+     * Rebuild edges when meshes are updated
+     */
+    refresh(): void;
+    /**
+     * Show edges
+     */
+    show(): void;
+    /**
+     * Hide edges
+     */
+    hide(): void;
+    /**
+     * Hide edges for specific elements
+     */
+    hideElements(elements: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    /**
+     * Show only specific elements (isolate) with x-ray mode option
+     */
+    isolateElements(elements: {
+        modelId: string;
+        elementId: string;
+    }[], xrayMode?: boolean): void;
+    /**
+     * Enable/disable x-ray mode for current isolation
+     */
+    setXrayMode(enabled: boolean): void;
+    /**
+     * Get current x-ray mode state
+     */
+    get isXrayMode(): boolean;
+    /**
+     * Reset all edge visibility
+     */
+    resetVisibility(): void;
+    /**
+     * Update edge visibility based on hidden/isolated elements
+     */
+    private _updateEdgeVisibility;
+    /**
+     * Set visibility for a specific element in the visibility mask
+     */
+    private _setElementVisibility;
+    /**
+     * Update edges when source meshes are modified
+     */
+    onMeshUpdated(mesh: ViralBatchedMesh | ViralInstancedMeshV2): void;
+    /**
+     * Get total vertex count in the edge mesh
+     */
+    getTotalEdgeVertexCount(): number;
+    /**
+     * Check if edges are currently visible
+     */
+    get isVisible(): boolean;
+    /**
+     * Get the number of registered meshes
+     */
+    getMeshCount(): {
+        batched: number;
+        instanced: number;
+    };
+    /**
+     * Clear all edge data
+     */
+    private _clearEdges;
+    /**
+     * Dispose of the edge mesh and clean up resources
+     */
+    dispose(): void;
+    /**
+     * Update edge material
+     */
+    updateMaterial(material: LineMaterial): void;
+    /**
+     * Update edge threshold and rebuild if necessary
+     */
+    updateThreshold(thresholdDeg: number): void;
+}

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

@@ -0,0 +1,142 @@
+import { Box3, BufferGeometry, Color, Material, Vector3, Matrix4, InstancedMesh, Object3D } from "three";
+import { BufferElement } from "../..";
+import { LineMaterial } from "three/examples/jsm/Addons";
+export declare class ViralInstancedMeshV2 extends Object3D {
+    protected material?: Material | undefined;
+    globalMaterialIndex: number;
+    constructor(material?: Material | undefined);
+    protected _instancedMeshes: Map<string, InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes>, Material | Material[], import("three").InstancedMeshEventMap>>;
+    _bufferElements: BufferElement[];
+    protected _originalColor: Color | null;
+    protected _elementMap: Map<string, Map<string, {
+        geometryKey: string;
+        instanceIndex: number;
+        instancedMesh: InstancedMesh;
+    }[]>>;
+    private _originalTransforms;
+    private _selectedElements;
+    private _hidingElements;
+    protected _isolatingElements: {
+        modelId: string;
+        elementId: string;
+    }[];
+    private _edgeLines;
+    private _edgeRanges;
+    private _edgeThreshold;
+    private _edgeMaterial;
+    private _isGeneratedLights;
+    private _pointLight;
+    addBufferElements(bufferElements: BufferElement[], materialColor: Color): void;
+    private rebuildInstances;
+    private _createInstancedMesh;
+    protected _createGeometryFromBuffer(buffer: Float32Array): BufferGeometry;
+    protected _transformArrayToMatrix4(transform: number[]): Matrix4;
+    protected _generateGeometryKey(buffer: Float32Array): string;
+    batch(newBufferElements: BufferElement[]): void;
+    select(elements: {
+        modelId: string;
+        elementId: string;
+    }[], excepts?: {
+        elements: {
+            modelId: string;
+            elementId: string;
+        }[];
+        color: {
+            r: number;
+            g: number;
+            b: number;
+        };
+    }[]): void;
+    changeColor(elements: {
+        modelId: string;
+        elementId: string;
+    }[], color: {
+        r: number;
+        g: number;
+        b: number;
+    }): void;
+    resetColor(modelId: string | null, elementId?: string, excepts?: {
+        elements: {
+            modelId: string;
+            elementId: string;
+        }[];
+        color: {
+            r: number;
+            g: number;
+            b: number;
+        };
+    }[]): void;
+    get selectedElements(): {
+        modelId: string;
+        elementId: string;
+    }[];
+    hide(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    isolate(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): {
+        modelId: string;
+        elementId: string;
+    }[];
+    isolateModel(modelIds: string[]): void;
+    reset(): void;
+    private showAllInstances;
+    enableEdgePerElement(material: LineMaterial, thresholdDeg?: number): void;
+    disableEdge(): void;
+    enableEdge(): void;
+    refreshEdgesIfAny(): void;
+    private _buildInstancedEdges;
+    isolateEdge(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    hideEdge(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    edgeReset(): void;
+    /**
+     * Enable raycasting for all instanced meshes
+     */
+    enableRaycasting(): void;
+    /**
+     * Custom raycast function for instanced meshes
+     */
+    private _instancedRaycast;
+    findElementByInstancedMeshAndIndex(instancedMesh: InstancedMesh, instanceIndex: number): {
+        modelId: string;
+        elementId: string;
+    } | null;
+    /**
+     * Alternative method: Find element by face index (similar to original)
+     * Note: This is more complex for instanced meshes
+     */
+    findElementByFaceIndex(faceIndex: number): {
+        modelId: string;
+        elementId: string;
+    } | null;
+    /**
+     * Get all instanced meshes for external raycast handling
+     */
+    getInstancedMeshes(): InstancedMesh[];
+    getElements(elements: {
+        modelId: string;
+        elementId: string;
+    }[]): BufferElement[];
+    getElementsByModel(modelIndex: number): BufferElement[];
+    getElementBoxs(elements: {
+        modelId: string;
+        elementId: string;
+    }[]): Box3 | null;
+    getTotalVertexCount(): number;
+    getObjectCount(): number;
+    get isBatching(): boolean;
+    enableLights(): void;
+    disableLights(): void;
+    calculateCenter(buffer: Float32Array): Vector3 | null;
+    private getFarthestDistance;
+    dispose(): void;
+}

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

@@ -0,0 +1,123 @@
+import { Box3, Color, Material, Vector3, InstancedMesh } from "three";
+import { BufferElement } from "../..";
+import { LineMaterial } from "three/examples/jsm/Addons";
+export declare class ViralInstancedMeshV3 extends InstancedMesh {
+    globalMaterialIndex: number;
+    private _bufferElement;
+    private _originalColor;
+    private _elementMap;
+    private _selectedElements;
+    private _hidingElements;
+    private _isolatingElements;
+    private _edgeLines;
+    private _edgeThreshold;
+    private _edgeMaterial;
+    private _isGeneratedLights;
+    private _pointLight;
+    private _originalTransforms;
+    constructor(material: Material);
+    addBufferElement(bufferElement: BufferElement, materialColor: Color): void;
+    private _setupInstanceData;
+    private _createGeometryFromBuffer;
+    private _transformArrayToMatrix4;
+    private _generateGeometryKey;
+    batch(newBufferElements: BufferElement[]): void;
+    select(elements: {
+        modelId: string;
+        elementId: string;
+    }[], excepts?: {
+        elements: {
+            modelId: string;
+            elementId: string;
+        }[];
+        color: {
+            r: number;
+            g: number;
+            b: number;
+        };
+    }[]): void;
+    changeColor(elements: {
+        modelId: string;
+        elementId: string;
+    }[], color: {
+        r: number;
+        g: number;
+        b: number;
+    }): void;
+    resetColor(modelId: string | null, elementId?: string, excepts?: {
+        elements: {
+            modelId: string;
+            elementId: string;
+        }[];
+        color: {
+            r: number;
+            g: number;
+            b: number;
+        };
+    }[]): void;
+    get selectedElements(): {
+        modelId: string;
+        elementId: string;
+    }[];
+    get bufferElements(): BufferElement[];
+    hide(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    isolate(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): {
+        modelId: string;
+        elementId: string;
+    }[];
+    isolateModel(modelIds: string[]): void;
+    reset(): void;
+    private showAllInstances;
+    enableEdgePerElement(material: LineMaterial, thresholdDeg?: number): void;
+    disableEdge(): void;
+    enableEdge(): void;
+    refreshEdgesIfAny(): void;
+    private _buildEdges;
+    isolateEdge(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    hideEdge(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    edgeReset(): void;
+    enableRaycasting(): void;
+    private _customRaycast;
+    findElementByInstanceIndex(instanceIndex: number): {
+        modelId: string;
+        elementId: string;
+    } | null;
+    findElementByInstancedMeshAndIndex(instancedMesh: InstancedMesh, instanceIndex: number): {
+        modelId: string;
+        elementId: string;
+    } | null;
+    findElementByFaceIndex(faceIndex: number): {
+        modelId: string;
+        elementId: string;
+    } | null;
+    getInstancedMeshes(): InstancedMesh[];
+    getElements(elements: {
+        modelId: string;
+        elementId: string;
+    }[]): BufferElement[];
+    getElementsByModel(modelIndex: number): BufferElement[];
+    getElementBoxs(elements: {
+        modelId: string;
+        elementId: string;
+    }[]): Box3 | null;
+    getTotalVertexCount(): number;
+    getObjectCount(): number;
+    get isBatching(): boolean;
+    enableLights(): void;
+    disableLights(): void;
+    calculateCenter(buffer: Float32Array): Vector3 | null;
+    private getFarthestDistance;
+    dispose(): this;
+}

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

@@ -2,25 +2,38 @@ import { Box3, Mesh } from "three";
 import { ViralBatchedMesh } from "./viral-batched-mesh";
 import { BufferElement } from "../..";
 import { LineMaterial } from "three/examples/jsm/lines/LineMaterial";
+import { ViralInstancedMeshV2 } from "./viral-instanced-mesh-v2";
+import { ViralEdgeMesh } from "./viral-edge-mesh";
+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.
  *
  */
 export declare class ViralMergedModel extends Mesh {
+    protected _edgeMesh: ViralEdgeMesh;
+    workerPool: WorkerThreadPool | null;
     constructor();
+    private _initializeWorkerPool;
     get bounds(): Box3;
     isReady: boolean;
     setReady(value: boolean): void;
-    private _mergedMeshes;
-    addMergedMesh(mesh: ViralBatchedMesh): void;
-    getMergedMesh(globalMaterialIndex: number): ViralBatchedMesh | undefined;
-    getMergedMeshes(): ViralBatchedMesh[];
+    protected _batchedMeshes: ViralBatchedMesh[];
+    addBatchedMesh(mesh: ViralBatchedMesh): void;
+    getBatchedMesh(globalMaterialIndex: number): ViralBatchedMesh | undefined;
+    getBatchedMeshes(): ViralBatchedMesh[];
+    protected _instancedMeshes: ViralInstancedMeshV2[];
+    addInstancedMesh(mesh: ViralInstancedMeshV2): void;
+    getInstancedMesh(globalMaterialIndex: number): ViralInstancedMeshV2 | undefined;
+    getInstancedMeshes(): ViralInstancedMeshV2[];
     hide(elements?: {
         modelId: string;
         elementId: string;
     }[]): void;
-    private _isolatingElements;
+    protected _isolatingElements: {
+        modelId: string;
+        elementId: string;
+    }[];
     isolate(elements?: {
         modelId: string;
         elementId: string;
@@ -84,9 +97,36 @@ export declare class ViralMergedModel extends Mesh {
      */
     resetVisibility(): void;
     resetColor(): void;
-    enableEdge(material: LineMaterial): void;
+    enableEdge(material: LineMaterial, thresholdDeg?: number): void;
     showEdge(): void;
     hideEdge(): void;
+    /**
+     * Refresh edges when meshes are updated
+     */
+    refreshEdges(): void;
+    /**
+     * Update edge material
+     */
+    updateEdgeMaterial(material: LineMaterial): void;
+    /**
+     * Update edge threshold
+     */
+    updateEdgeThreshold(thresholdDeg: number): void;
+    /**
+     * Get edge mesh statistics
+     */
+    getEdgeStats(): {
+        isVisible: boolean;
+        vertexCount: number;
+        meshCount: {
+            batched: number;
+            instanced: number;
+        };
+    };
+    /**
+     * Notify edge mesh when meshes are updated (call this after batching or rebuilding)
+     */
+    onMeshUpdated(mesh?: ViralBatchedMesh | ViralInstancedMeshV2): void;
     /**
      * *everytime add new model in scene this model will be regenerated again, for that reason we should dispose this model
      * *then regenerate again

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

@@ -9,6 +9,7 @@ export declare class ViralDataManager {
     private _checkClashWorker;
     constructor(viralViewerApi: ViralViewerApi);
     normalFetch(url: string, byteRangeStart?: number, byteRangeEnd?: number): Promise<Response>;
+    gzipFetch(url: string): Promise<Response>;
     /**
      * worker fetch can only return json or arraybuffer value
      * @param url

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

@@ -0,0 +1,74 @@
+import { ViralutionElement } from "../../types";
+export interface DuplicationAnalysis {
+    strategy: "BATCHING" | "INSTANCING" | "HYBRID";
+    totalElements: number;
+    totalInstances: number;
+    totalVertices: number;
+    uniqueGeometries: number;
+    averageVerticesPerElement: number;
+    averageInstancesPerGeometry: number;
+    highDuplicationElements: Array<{
+        element: ViralutionElement;
+        vertexCount: number;
+        instanceCount: number;
+        totalVertexInstances: number;
+        efficiencyScore: number;
+    }>;
+    lowDuplicationElements: Array<{
+        element: ViralutionElement;
+        vertexCount: number;
+        instanceCount: number;
+        totalVertexInstances: number;
+        efficiencyScore: number;
+    }>;
+    estimatedDrawCalls: number;
+    estimatedMemoryReduction: number;
+    details: {
+        batchedElements: number;
+        batchedVertices: number;
+        instancedElements: number;
+        instancedVertices: number;
+        instancedDrawCalls: number;
+    };
+}
+declare class ViralDuplicationAnalyzer {
+    private readonly MIN_VERTEX_INSTANCES_FOR_INSTANCING;
+    private readonly MIN_INSTANCES_FOR_INSTANCING;
+    private readonly MAX_DRAW_CALLS;
+    private readonly MIN_INSTANCED_VERTEX_RATIO;
+    private readonly HIGH_VERTEX_THRESHOLD;
+    /**
+     * Enhanced analysis considering vertex count × instance count
+     */
+    analyze(elements: ViralutionElement[]): DuplicationAnalysis;
+    private calculateElementMetrics;
+    private categorizeByEfficiency;
+    private determineStrategy;
+    private calculateDrawCalls;
+    private calculateMemoryReduction;
+    private calculateDetails;
+    private logAnalysis;
+    /**
+     * Get elements that should be instanced vs batched with the new logic
+     */
+    categorizeElements(elements: ViralutionElement[]): {
+        forInstancing: ViralutionElement[];
+        forBatching: ViralutionElement[];
+    };
+    /**
+     * Configure thresholds for vertex-aware analysis
+     */
+    setThresholds(config: {
+        minVertexInstancesForInstancing?: number;
+        minInstancesForInstancing?: number;
+        maxDrawCalls?: number;
+        minInstancedVertexRatio?: number;
+        highVertexThreshold?: number;
+    }): void;
+    /**
+     * Get a detailed recommendation with vertex information
+     */
+    getDetailedRecommendation(elements: ViralutionElement[]): string;
+}
+export declare const viralDuplicationAnalyzer: ViralDuplicationAnalyzer;
+export {};

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

@@ -0,0 +1,13 @@
+import { ViralutionElement } from "../../types";
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralFlatbufferLoader {
+    viralViewerApi: ViralViewerApi;
+    elements: ViralutionElement[];
+    private _loadElementPatchWorker;
+    constructor(viralViewerApi: ViralViewerApi);
+    load(trackingUrl: string, informationUrl: string, materialsUrl: string, elementsUrls: string[], callbackOnFinish?: () => void): Promise<void>;
+    private getInformations;
+    private getTracking;
+    private getMaterials;
+    private getElements;
+}