viral-viewer-2 6.9.1 → 6.9.3

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

@@ -119,7 +119,42 @@ export declare class ViralBatchedMesh extends Mesh {
      * reset visibility also color
      */
     reset(): void;
+    optimizeVertices(): void;
     updateVisibility(bufferElements: BufferElement[]): void;
+    private _hiddenSet;
+    private _isolatedSet;
+    private _originalColorSize;
+    /**
+     * 🚀 ULTRA FAST: Hide elements by setting alpha to 0
+     * Preserves raycasting - hidden elements can still be clicked
+     */
+    hideFast(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    /**
+     * 🚀 ULTRA FAST: Isolate elements by setting non-isolated alpha to 0
+     */
+    isolateFast(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): {
+        modelId: string;
+        elementId: string;
+    }[];
+    /**
+     * 🚀 INTERNAL: Update visibility by modifying alpha channel
+     * Sets alpha to 0.001 (nearly invisible) + alphaTest to skip rendering
+     */
+    private _updateVisibilityByAlpha;
+    /**
+     * Check if an element is currently visible
+     */
+    isElementVisible(modelId: string, elementId: string): boolean;
+    /**
+     * 🚀 ULTRA FAST: Reset visibility - restore everything to normal
+     */
+    resetFast(): void;
     findElementByFaceIndex(faceIndex: number): {
         modelId: string;
         elementId: string;
@@ -184,6 +219,51 @@ export declare class ViralBatchedMesh extends Mesh {
     }[]): Box3 | null;
     getTotalVertexCount(): number;
     getObjectCount(): number;
+    /**
+     * Create simplified LOD versions of this batched mesh
+     * All LOD meshes maintain full element mapping functionality (hide, isolate, changeColor)
+     *
+     * @param lodLevels - Array of simplification options for each LOD level
+     * @returns Promise resolving to array of meshes [original, LOD1, LOD2, ...]
+     *
+     * @example
+     * ```typescript
+     * const lodMeshes = await originalMesh.createSimplifiedLODs([
+     *   { ratio: 0.7, error: 0.01 }, // LOD1: 70% detail
+     *   { ratio: 0.4, error: 0.02 }, // LOD2: 40% detail
+     *   { ratio: 0.2, error: 0.05 }, // LOD3: 20% detail
+     * ]);
+     *
+     * // All LODs support full operations
+     * lodMeshes.forEach(mesh => mesh.hide(elements)); // Works on all!
+     * ```
+     */
+    createSimplifiedLODs(lodLevels: Array<{
+        ratio?: number;
+        error?: number;
+        lockBorder?: boolean;
+        optimizeMemory?: boolean;
+    }>): Promise<ViralBatchedMesh[]>;
+    /**
+     * FAST: Create simplified LOD by simplifying entire geometry at once
+     * ⚠️ This breaks element mapping - hide/isolate/changeColor won't work on simplified mesh
+     * Use this when you only need visual LOD without element operations
+     *
+     * @param options - Simplification options
+     * @returns Promise resolving to simplified mesh
+     *
+     * @example
+     * ```typescript
+     * const lodMesh = await originalMesh.createSimplifiedLODFast({ ratio: 0.5 });
+     * // 10x-100x faster than createSimplifiedLODs but no element operations
+     * ```
+     */
+    createSimplifiedLODFast(options: {
+        ratio?: number;
+        error?: number;
+        lockBorder?: boolean;
+        optimizeMemory?: boolean;
+    }): Promise<ViralBatchedMesh>;
     /**
      * ! Disposes of the ViralBatchedMesh properly, when dispose we dont need to dispose material
      */

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

@@ -5,7 +5,7 @@ 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>>;
+    protected _instancedMeshes: Map<string, InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, Material | Material[], import("three").InstancedMeshEventMap>>;
     _bufferElements: BufferElement[];
     protected _originalColor: Color | null;
     protected _elementMap: Map<string, Map<string, {
@@ -70,6 +70,9 @@ export declare class ViralInstancedMeshV2 extends Object3D {
         modelId: string;
         elementId: string;
     }[];
+    private _hiddenSet;
+    private _isolatedSet;
+    private _originalColorSize;
     hide(elements?: {
         modelId: string;
         elementId: string;
@@ -81,6 +84,32 @@ export declare class ViralInstancedMeshV2 extends Object3D {
         modelId: string;
         elementId: string;
     }[];
+    /**
+     * 🚀 FAST: Hide instances by setting alpha to 0
+     * Preserves raycasting - hidden instances can still be clicked
+     */
+    hideFast(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): void;
+    /**
+     * 🚀 FAST: Isolate instances by setting non-isolated alpha to 0
+     */
+    isolateFast(elements?: {
+        modelId: string;
+        elementId: string;
+    }[]): {
+        modelId: string;
+        elementId: string;
+    }[];
+    /**
+     * 🚀 INTERNAL: Update instance visibility by modifying instance colors alpha
+     */
+    private _updateInstanceVisibilityByAlpha;
+    /**
+     * 🚀 FAST: Reset visibility - restore everything to normal
+     */
+    resetFast(): void;
     isolateModel(modelIds: string[]): void;
     reset(): void;
     private showAllInstances;

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

@@ -22,6 +22,18 @@ export declare class ViralMergedModel extends Mesh {
     addBatchedMesh(mesh: ViralBatchedMesh): void;
     getBatchedMesh(globalMaterialIndex: number): ViralBatchedMesh | undefined;
     getBatchedMeshes(): ViralBatchedMesh[];
+    /**
+     * Get diagnostic info about merged model structure
+     */
+    getDiagnostics(): {
+        totalChildren: number;
+        edgeMeshes: number;
+        batchedMeshesInChildren: number;
+        batchedMeshesInArray: number;
+        instancedMeshes: number;
+        totalVertices: number;
+        childrenTypes: string[];
+    };
     protected _instancedMeshes: ViralInstancedMeshV2[];
     addInstancedMesh(mesh: ViralInstancedMeshV2): void;
     getInstancedMesh(globalMaterialIndex: number): ViralInstancedMeshV2 | undefined;
@@ -127,6 +139,7 @@ export declare class ViralMergedModel extends Mesh {
      * Notify edge mesh when meshes are updated (call this after batching or rebuilding)
      */
     onMeshUpdated(mesh?: ViralBatchedMesh | ViralInstancedMeshV2): void;
+    optimizeVertices(): 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

@@ -1,13 +1,15 @@
-import { CheckClashResult, CompareModelsResult, DataTree, GroupByResult, ViralViewerApi } from "../..";
+import { CheckClashResult, CompareModelsResult, DataTree, GroupByResult, ViralutionTrackingModel, ViralViewerApi } from "../..";
 export declare class ViralDataManager {
     viralViewerApi: ViralViewerApi;
     dataTree: DataTree[];
+    trackingData: Map<number, ViralutionTrackingModel>;
     private fetchDataWorker;
     private buildTreeNodeWorker;
     private _boundingBoxWorker;
     private _boundingBoxIntersectWorker;
     private _checkClashWorker;
     constructor(viralViewerApi: ViralViewerApi);
+    addTrackingData(modelId: number, data: ViralutionTrackingModel): void;
     normalFetch(url: string, byteRangeStart?: number, byteRangeEnd?: number): Promise<Response>;
     gzipFetch(url: string): Promise<Response>;
     /**

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

@@ -23,6 +23,7 @@ export declare class ViralCentralizedEventHandler {
     selectElementHandler(): void;
     enableSelectElement(value: boolean): void;
     selectElementHandler2(): void;
+    doubleClickElementHandler(): void;
     isShiftPressed: boolean;
     keyboardHandler(): void;
 }

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

@@ -1,4 +1,4 @@
-import { RevitTransform, ViralPoint, ViralViewerRevitProject, ViralutionElement, ViralutionFragmentModel } from "../../types";
+import { RevitTransform, ViralPoint, ViralViewerRevitProject, ViralutionElement, ViralutionFragmentModel, ViralutionTrackingModel } from "../../types";
 import { ViralViewerApi } from "../../viral-viewer-api";
 export declare class ViralRevitLoader {
     viralViewerApi: ViralViewerApi;
@@ -6,7 +6,7 @@ export declare class ViralRevitLoader {
     private _loadElementStandaloneWorker;
     private _loadElementByMaterialWorker;
     private _loadElementByMaterialV2Worker;
-    private _loadElementPatchWorker;
+    private _loadElementBatchWorker;
     constructor(viralViewerApi: ViralViewerApi);
     /**
      * @deprecated This function is deprecated. Use the loadRevit2 instead.
@@ -22,6 +22,12 @@ export declare class ViralRevitLoader {
     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>;
+    focusCameraOnModel(trackingModel: ViralutionTrackingModel): Promise<void>;
+    getTranslation(translation: number[]): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
     loadByMaterial(trackingUrl: string, dataUrl: string, informationUrl: string): Promise<void>;
     /**
      * dispose all current model

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

@@ -4,7 +4,7 @@ import { PostProcessingRenderer } from "../post-processing/post-processing-rende
 export declare class ViralRenderer {
     viralViewerApi: ViralViewerApi;
     renderer: WebGLRenderer;
-    postProcessingRenderer: PostProcessingRenderer;
+    postProcessingRenderer?: PostProcessingRenderer;
     private _t;
     private _lastSpatialStatsTime;
     constructor(viralViewerApi: ViralViewerApi);

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

@@ -105,7 +105,7 @@ export declare class ViralVisibilityManager {
     private _fog;
     enableFog(): void;
     disableFog(): void;
-    rainGeometry: BufferGeometry<import("three").NormalBufferAttributes>;
+    rainGeometry: BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
     rain: Points | null;
     private _isGeneratedRain;
     enableRain(): void;
@@ -117,4 +117,28 @@ export declare class ViralVisibilityManager {
     enableSampling(numberOfSampling?: number): void;
     disableSampling(): void;
     generateLOD(): void;
+    private _batchColors;
+    private _originalBatchMaterials;
+    private _batchVisualizationEnabled;
+    /**
+     * Generate a random but distinct color for each material ID
+     */
+    private _generateDistinctColor;
+    /**
+     * Show batches with distinct colors based on their globalMaterialId
+     * Each batch with the same globalMaterialId will have the same random color
+     */
+    showBatches(): void;
+    /**
+     * Hide batches and restore original materials
+     */
+    hideBatches(): void;
+    /**
+     * Check if batch visualization is currently enabled
+     */
+    isBatchVisualizationEnabled(): boolean;
+    showHidePercentage: number;
+    showHideByPercentage(value?: number): void;
+    randomColor: number;
+    changeRandomColor(value?: number): void;
 }

package/dist/components/worker/{load-element-patch.worker.d.ts → load-element-batch.worker.d.ts}

@@ -3,12 +3,15 @@ import { RenderMaterial, ViralutionElement } from "../../types";
 import { Box3, Vector3 } from "three";
 import { WorkerThreadPool } from "./base/worker-pool";
 import { ViralSpatialMeshManager } from "../custom-objects/viral-spatial-mesh-manager";
-export declare class LoadElementPatchWorker {
+export declare class LoadElementBatchWorker {
     viralViewerApi: ViralViewerApi;
     workerPool: WorkerThreadPool;
     workerPool2: WorkerThreadPool;
     private lastRenderTime;
     private useSpatialMerging;
+    private elementBuffer;
+    private readonly BATCH_THRESHOLD_VERTICES;
+    private readonly BATCH_THRESHOLD_OBJECTS;
     constructor(viralViewerApi: ViralViewerApi);
     /**
      * Initialize model with materials
@@ -19,16 +22,16 @@ export declare class LoadElementPatchWorker {
     /**
      * Main load method - automatically routes to spatial or traditional approach
      */
-    loadElement(modelId: number, elements: ViralutionElement[], callbackOnSuccess?: () => void): void;
+    loadElement(modelId: number, elements: ViralutionElement[], callbackOnSuccess?: () => void, globalTranslation?: {
+        x: number;
+        y: number;
+        z: number;
+    } | null): void;
     private loadInstancedElement;
     /**
      * Traditional load implementation (renamed for clarity)
      */
     private loadBatchedElement;
-    /** 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;
@@ -45,6 +48,18 @@ export declare class LoadElementPatchWorker {
      * Throttled render to avoid excessive render calls
      */
     private throttledRender;
+    /**
+     * 🚀 Add elements to buffer and batch when threshold is reached
+     */
+    private addToBuffer;
+    /**
+     * 🚀 Flush accumulated elements for a specific material
+     */
+    private flushBuffer;
+    /**
+     * 🚀 Flush all remaining buffers (call this when loading is complete)
+     */
+    flushAllBuffers(): void;
     /**
      * Get spatial mesh manager (delegate to scene)
      */

package/dist/gui/batch-debug-panel/viral-batch-debug-panel.d.ts

@@ -0,0 +1,20 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralBatchDebugPanel {
+    viralViewerApi: ViralViewerApi;
+    private panel;
+    private batchListContainer;
+    private isVisible;
+    private selectedBatchMesh;
+    constructor(viralViewerApi: ViralViewerApi);
+    private inject;
+    private createButton;
+    private injectStyles;
+    private attachEventListeners;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    private refreshBatchList;
+    private isolateBatch;
+    private clearIsolation;
+    dispose(): void;
+}

package/dist/gui/tools/tools/viral-tool-measure.d.ts

@@ -7,7 +7,7 @@ interface ViralMeasure {
 }
 export declare class ViralToolMeasure {
     viralTools: ViralTools;
-    viralToolMeasureScene: Scene;
+    viralToolMeasureScene: Scene<import("three").Object3DEventMap>;
     isActivated: boolean;
     measures: ViralMeasure[];
     private point1;