viral-viewer-2 6.9.0 → 6.9.2

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

@@ -119,6 +119,7 @@ export declare class ViralBatchedMesh extends Mesh {
      * reset visibility also color
      */
     reset(): void;
+    optimizeVertices(): void;
     updateVisibility(bufferElements: BufferElement[]): void;
     findElementByFaceIndex(faceIndex: number): {
         modelId: string;
@@ -184,6 +185,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, {

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/loader/viral-revit.loader.d.ts

@@ -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.

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,24 @@ 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;
 }

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
@@ -25,10 +28,6 @@ export declare class LoadElementPatchWorker {
      * 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 +44,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;