viral-viewer-2 6.8.2 → 6.8.3

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

@@ -3,10 +3,46 @@ import { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralAnimation {
     viralViewerApi: ViralViewerApi;
     clock: Clock;
+    private lastSpatialUpdateTime;
+    private lastCleanupTime;
+    private spatialUpdateInterval;
+    private cleanupInterval;
     constructor(viralViewerApi: ViralViewerApi);
     devAnimation(): void;
     animation(): void;
     rainAnimation(): void;
     private isRainEnabled;
     toggleRain(value: boolean): void;
+    /**
+     * Update spatial visibility based on current camera position
+     */
+    private updateSpatialVisibility;
+    /**
+     * Cleanup distant spatial meshes to free memory
+     */
+    private cleanupDistantSpatialMeshes;
+    /**
+     * Get spatial mesh statistics for debugging
+     */
+    getSpatialStats(): {
+        totalCells: number;
+        loadedCells: number;
+        visibleCells: number;
+    } | null;
+    /**
+     * Log spatial mesh statistics to console (for debugging)
+     */
+    logSpatialStats(): void;
+    /**
+     * Set spatial update frequency (for performance tuning)
+     */
+    setSpatialUpdateFrequency(fps: number): void;
+    /**
+     * Set cleanup frequency (for memory management tuning)
+     */
+    setCleanupFrequency(seconds: number): void;
+    /**
+     * Toggle debug mode for spatial meshes
+     */
+    toggleSpatialDebug(enabled: boolean): void;
 }

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, Raycaster, PerspectiveCamera, Object3D, OrthographicCamera } from "three";
+import { Vector3, Box3, Raycaster, PerspectiveCamera, Object3D, OrthographicCamera } from "three";
 export declare class ViralCamera {
     viralViewerApi: ViralViewerApi;
     raycaster: Raycaster;
@@ -52,4 +52,20 @@ 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-main.model.d.ts

@@ -8,6 +8,9 @@ export declare class ViralMainModel {
     elements: ViralutionElement[];
     materials: RenderMaterial[];
     mapMaterialsToMaterialManager: Dictionary<number, number>;
+    /**
+     * @deprecated don't use this anymore
+     */
     seperateModel: ViralSeperateModel;
     dispose(): void;
 }

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

@@ -0,0 +1,32 @@
+import { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
+type ElemKey = {
+    modelId: string;
+    elementId: string;
+};
+type BufferElement = {
+    buffer: Float32Array | null;
+    elementId: string;
+    modelId: number;
+};
+export declare class ViralMergedEdges extends LineSegments2 {
+    globalMaterialIndex: number;
+    private _positions;
+    private _elementMap;
+    private _totalSegments;
+    constructor(color?: number, linewidth?: number);
+    /** Phải gọi khi resize để line dày đúng theo px */
+    setResolution(width: number, height: number): void;
+    /** Thêm edges cho 1 batch BufferElement[] */
+    addBufferElements(bufferElements: BufferElement[], boundaryOnly?: boolean): void;
+    /** Bật/tắt theo danh sách element: rebuild nhanh mảng positions hiển thị */
+    setVisibleElements(els: ElemKey[]): void;
+    /** Hiện tất cả edges */
+    showAll(): void;
+    /** Ẩn tất cả edges */
+    hideAll(): void;
+    /** Vẽ tất cả cạnh của từng tam giác: (0,1,2), (3,4,5), ... */
+    private _buildAllTriangleEdges;
+    /** Chỉ cạnh biên: weld đỉnh ~ gộp vertex gần nhau, đếm cạnh xuất hiện 1 lần */
+    private _buildBoundarySegments;
+}
+export {};

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

@@ -29,8 +29,27 @@ export declare class ViralMergedMesh extends Mesh {
     }[]): BufferElement[];
     getElementsByModel(modelIndex: number): BufferElement[];
     private _edgeLines;
-    enableEdge(material: LineBasicMaterial): void;
+    private _edgeRanges;
+    private _edgeThreshold;
+    private _edgeMaterial;
+    enableEdgePerElement(material: LineBasicMaterial, thresholdDeg?: number): void;
     disableEdge(): void;
+    enableEdge(): void;
+    /** call this after rebuild/batch to keep edges in sync (if enabled) */
+    refreshEdgesIfAny(): void;
+    private _buildMergedEdges;
+    /** Show edges ONLY for the given elements */
+    isolateEdge(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    /** Hide edges for the given elements (keep all others) */
+    hideEdge(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    /** Restore all edges */
+    edgeReset(): void;
     private _selectedElements;
     select(elements: {
         modelId: string;
@@ -55,7 +74,10 @@ export declare class ViralMergedMesh extends Mesh {
     isolate(elements?: {
         modelId: string;
         elementId: string;
-    }[]): void;
+    }[]): {
+        modelId: string;
+        elementId: string;
+    }[];
     get selectedElements(): {
         modelId: string;
         elementId: string;
@@ -132,6 +154,8 @@ export declare class ViralMergedMesh extends Mesh {
         modelId: string;
         elementId: string;
     }[]): Box3 | null;
+    getTotalVertexCount(): number;
+    getObjectCount(): number;
     /**
      * ! Disposes of the ViralMergedMesh properly, when dispose we dont need to dispose material
      */

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

@@ -1,6 +1,7 @@
 import { Box3, LineBasicMaterial, Mesh } from "three";
 import { ViralMergedMesh } from "./viral-merged-mesh";
 import { BufferElement } from "../..";
+import { ViralMergedEdges } from "./viral-merged-edge";
 /**
  * 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.
@@ -11,6 +12,10 @@ export declare class ViralMergedModel extends Mesh {
     get bounds(): Box3;
     isReady: boolean;
     setReady(value: boolean): void;
+    private _mergedEdges;
+    addMergedEdge(edge: ViralMergedEdges): void;
+    getMergedEdge(globalMaterialIndex: number): ViralMergedEdges | undefined;
+    getMergedEdges(): ViralMergedEdges[];
     private _mergedMeshes;
     addMergedMesh(mesh: ViralMergedMesh): void;
     getMergedMesh(globalMaterialIndex: number): ViralMergedMesh | undefined;
@@ -19,10 +24,15 @@ export declare class ViralMergedModel extends Mesh {
         modelId: string;
         elementId: string;
     }[]): void;
+    private _isolatingElements;
     isolate(elements?: {
         modelId: string;
         elementId: string;
     }[]): void;
+    getIsolatingElements(): {
+        modelId: string;
+        elementId: string;
+    }[];
     /**
      * Isolate whole model
      * @param modelIds
@@ -79,7 +89,8 @@ export declare class ViralMergedModel extends Mesh {
     resetVisibility(): void;
     resetColor(): void;
     enableEdge(material: LineBasicMaterial): void;
-    disableEdge(): void;
+    showEdge(): void;
+    hideEdge(): 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/custom-objects/viral-spatial-merged-mesh.d.ts

@@ -0,0 +1,7 @@
+import { Box3, BufferGeometry, Material } from "three";
+import { ViralMergedMesh } from "./viral-merged-mesh";
+export declare class ViralSpatialMergedMesh extends ViralMergedMesh {
+    spatialBounds: Box3;
+    spatialId: string;
+    constructor(bounds: Box3, spatialId: string, geometry?: BufferGeometry, material?: Material);
+}

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

@@ -0,0 +1,70 @@
+import { Box3, Camera, Color, Material, Mesh, Vector3 } from "three";
+import { ViralSpatialMergedMesh } from "./viral-spatial-merged-mesh";
+import { BufferElement } from "../..";
+export declare class ViralSpatialMeshManager {
+    private spatialGrid;
+    private gridSize;
+    private worldBounds;
+    constructor(worldBounds: Box3, gridSize?: Vector3);
+    private getGridKey;
+    private getGridBounds;
+    getSpatialMesh(gridKey: string, materialIndex: number, material: Material): ViralSpatialMergedMesh;
+    private calculateElementCenter;
+    getVisibleMeshes(camera: Camera): ViralSpatialMergedMesh[];
+    updateVisibility(camera: Camera, parentMesh: Mesh): void;
+    /**
+     * 🔥 FIXED: Add buffer elements with material color support
+     */
+    addBufferElements(bufferElements: BufferElement[], material: Material, globalMaterialIndex: number, materialColor?: Color): void;
+    /**
+     * Get statistics about spatial mesh usage
+     */
+    getStats(): {
+        totalCells: number;
+        loadedCells: number;
+        visibleCells: number;
+    };
+    /**
+     * Clean up distant meshes to free memory
+     */
+    cleanupDistantMeshes(cameraPosition: Vector3, maxDistance: number): void;
+    /**
+     * Get center point of a grid cell
+     */
+    private getGridCenter;
+    /**
+     * Get world bounds for debugging
+     */
+    getWorldBounds(): Box3;
+    /**
+     * 🔥 ADDED: Methods for element interaction (select, hide, isolate)
+     */
+    selectElements(elements: {
+        modelId: string;
+        elementId: string;
+    }[], excepts?: {
+        elements: {
+            modelId: string;
+            elementId: string;
+        }[];
+        color: {
+            r: number;
+            g: number;
+            b: number;
+        };
+    }[]): void;
+    hideElements(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    isolateElements(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    resetVisibility(): void;
+    resetColor(): void;
+    /**
+     * Dispose all spatial meshes
+     */
+    dispose(): void;
+}

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

@@ -8,6 +8,7 @@ export declare class ViralCentralizedEventHandler {
     /**
      ** this for optimize purpose; when renderer become too heavy, it will hide object when camera move
      */
+    private sleepTimer;
     cameraHandler(): void;
     windowHandler(): void;
     handleResize(entries: any): void;

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

@@ -19,6 +19,7 @@ export declare class ViralRevitLoader {
     loadRevitGroupByMaterial(model: ViralutionFragmentModel): void;
     getVerticePoints(indices: number[], vertices: ViralPoint[], instances?: RevitTransform[]): number[];
     loadStandalone(trackingUrl: string, dataUrl: string, informationUrl: string, callbackOnFinish?: () => void): Promise<void>;
+    loadFlatBufferStandalone(informationUrl: string, geometriesUrl: 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>;
     loadByMaterial(trackingUrl: string, dataUrl: string, informationUrl: string): Promise<void>;

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

@@ -5,12 +5,49 @@ export declare class ViralRenderer {
     viralViewerApi: ViralViewerApi;
     renderer: WebGLRenderer;
     postProcessingRenderer: PostProcessingRenderer;
+    private _t;
+    private _lastSpatialStatsTime;
     constructor(viralViewerApi: ViralViewerApi);
     updateSize(width: number, height: number): void;
     private renderTimeout;
     render(): void;
-    private _t;
     private performRender;
+    accumulateTAAFrames(sampleFrames?: number): void;
+    /**
+     * Log standard WebGL render statistics
+     */
+    private logRenderStats;
+    /**
+     * Log spatial mesh statistics if spatial merging is active
+     */
+    private logSpatialStats;
+    /**
+     * Get detailed rendering performance info
+     */
+    getPerformanceInfo(): {
+        rendering: {
+            calls: number;
+            triangles: number;
+            points: number;
+            lines: number;
+        };
+        memory: {
+            geometries: number;
+            textures: number;
+        };
+        spatial: {
+            totalCells: number;
+            loadedCells: number;
+            visibleCells: number;
+            cullingEfficiency: string;
+            memoryEfficiency: string;
+        } | null;
+        isSpatialActive: boolean;
+    };
+    /**
+     * Enable/disable performance logging
+     */
+    setPerformanceLogging(enabled: boolean, interval?: number): void;
     private jitterOffsets;
     private jitterIndex;
     private size;
@@ -18,4 +55,12 @@ export declare class ViralRenderer {
     applyJitter(): void;
     generateJitterOffsets(samples?: number): number[][];
     screenshot(): string;
+    /**
+     * Take a screenshot with spatial mesh debug overlay
+     */
+    screenshotWithSpatialDebug(): string;
+    /**
+     * Render only visible spatial cells (for debugging)
+     */
+    renderVisibleCellsOnly(): void;
 }

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

@@ -1,8 +1,9 @@
-import { Scene, DirectionalLight, Mesh, Object3D, MeshBasicMaterial, Light, CameraHelper, Box3, OrthographicCamera, PerspectiveCamera } from "three";
+import { Scene, DirectionalLight, Mesh, Object3D, MeshBasicMaterial, Light, CameraHelper, Vector3, Box3, OrthographicCamera, PerspectiveCamera, Camera } 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 { TransformControls } from "three/examples/jsm/controls/TransformControls";
+import { ViralSpatialMeshManager } from "../custom-objects/viral-spatial-mesh-manager";
 export declare class ViralScene {
     viralViewerApi: ViralViewerApi;
     scene: Scene;
@@ -12,6 +13,9 @@ export declare class ViralScene {
     isolateModel: Mesh;
     mergedModel: ViralMergedModel;
     outlineModel: Mesh;
+    spatialMeshManager: ViralSpatialMeshManager | null;
+    spatialMeshContainer: Mesh;
+    private useSpatialMerging;
     hideables: Object3D[];
     selectables: Object3D[];
     edges: Object3D[];
@@ -21,6 +25,42 @@ export declare class ViralScene {
     transformControls: TransformControls | null;
     lightHelpers: CameraHelper[];
     constructor(viralViewerApi: ViralViewerApi);
+    /**
+     * Initialize spatial mesh manager with world bounds
+     */
+    initializeSpatialManager(worldBounds: Box3, gridSize?: Vector3): void;
+    /**
+     * Enable/disable spatial merging
+     */
+    setSpatialMerging(enabled: boolean): void;
+    /**
+     * Update spatial visibility based on camera (call this in render loop)
+     */
+    updateSpatialVisibility(camera: Camera): void;
+    /**
+     * Get spatial mesh manager
+     */
+    getSpatialMeshManager(): ViralSpatialMeshManager | null;
+    /**
+     * Check if spatial merging is active
+     */
+    isSpatialMergingActive(): boolean;
+    /**
+     * Add spatial mesh to the spatial container
+     */
+    addSpatialMesh(mesh: Object3D): void;
+    /**
+     * Clean up distant spatial meshes
+     */
+    cleanupDistantSpatialMeshes(cameraPosition: Vector3, maxDistance?: number): void;
+    /**
+     * Get spatial mesh statistics
+     */
+    getSpatialStats(): {
+        totalCells: number;
+        loadedCells: number;
+        visibleCells: number;
+    } | null;
     addObject(object: Object3D): void;
     addModel(object: Object3D): void;
     addEdge(object: Object3D): void;

package/dist/components/worker/load-element-patch.worker.d.ts

@@ -1,15 +1,98 @@
 import { ViralViewerApi } from "../../viral-viewer-api";
 import { RenderMaterial, ViralutionElement } from "../../types";
+import { Box3, Camera, Vector3 } from "three";
 import { WorkerThreadPool } from "./base/worker-pool";
+import { ViralSpatialMeshManager } from "../custom-objects/viral-spatial-mesh-manager";
 export declare class LoadElementPatchWorker {
     viralViewerApi: ViralViewerApi;
     workerPool: WorkerThreadPool;
+    private lastRenderTime;
+    private useSpatialMerging;
     constructor(viralViewerApi: ViralViewerApi);
     /**
-     *
+     * Initialize model with materials
      * @param materials
      * @returns modelId
      */
     initial(materials: RenderMaterial[]): number;
+    /**
+     * Main load method - automatically routes to spatial or traditional approach
+     */
     loadElement(modelId: number, elements: ViralutionElement[], callbackOnSuccess?: () => void): void;
+    /**
+     * Traditional load implementation (renamed for clarity)
+     */
+    private loadTraditionalElement;
+    /** How many vec4 slots your per-object data needs (mat4 -> 4, id/color -> 1, none -> 0). */
+    private get perObjectUniformVec4();
+    /** Reserve some vec4 slots for built-ins (MVP, lights, fog, etc.). Tweak if you use heavy materials. */
+    private get reservedUniformVec4();
+    private computeBatchLimits;
+    /** Split elements to chunks that satisfy both vertex and object limits. */
+    private splitByLimits;
+    /**
+     * Initialize spatial mesh manager in scene only
+     */
+    initializeSpatialManager(worldBounds: Box3): void;
+    /**
+     * Disable spatial merging and fall back to original method
+     */
+    disableSpatialMerging(): void;
+    /**
+     * Enable spatial merging (requires spatial manager to be initialized in scene)
+     */
+    enableSpatialMerging(): void;
+    /**
+     * Load elements using spatial merging
+     */
+    private loadSpatialElement;
+    /**
+     * Create spatial meshes for elements
+     */
+    private createSpatialMeshes;
+    /**
+     * Update camera-based visibility for spatial meshes
+     */
+    updateSpatialVisibility(camera: Camera): void;
+    /**
+     * Create single merged mesh (traditional implementation)
+     */
+    private createSingleMergedMesh;
+    private createSingleMergedEdge;
+    /**
+     * Create optimized material for merging
+     */
+    private createOptimizedMaterial;
+    /**
+     * Throttled render to avoid excessive render calls
+     */
+    private throttledRender;
+    /**
+     * Get spatial mesh manager (delegate to scene)
+     */
+    getSpatialMeshManager(): ViralSpatialMeshManager | null;
+    /**
+     * Check if spatial merging is enabled
+     */
+    isSpatialMergingEnabled(): boolean;
+    /**
+     * Get spatial mesh statistics
+     */
+    getSpatialStats(): {
+        totalCells: number;
+        loadedCells: number;
+        visibleCells: number;
+    } | null;
+    /**
+     * Clean up distant spatial meshes to free memory
+     */
+    cleanupDistantMeshes(cameraPosition: Vector3, maxDistance?: number): void;
+    /**
+     * Calculate world bounds from elements (utility method)
+     */
+    calculateWorldBounds(elements: ViralutionElement[]): Box3;
+    /**
+     * Apply RevitTransform to a point (utility method)
+     */
+    private applyTransform;
 }

package/dist/gui/pivot-point/viral-pivot-point.d.ts

@@ -0,0 +1,9 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralPivotPoint {
+    viralViewerApi: ViralViewerApi;
+    private contextMenu;
+    constructor(viralViewerApi: ViralViewerApi);
+    private injectContextMenu;
+    show(top: number, left: number): void;
+    hide(): void;
+}

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export * from './types';
 export * from './viral-viewer-api';
 export * from './utils';
 export * from './components/custom-objects';
-export * from './models';
+export * from './serializers';