viral-viewer-2 6.8.8 → 6.9.0

package/dist/components/lod-generator/viral-lod-generator.d.ts

@@ -0,0 +1,116 @@
+import { BufferGeometry, Vector3 } from "three";
+import { ViralBatchedMesh, ViralMergedModel } from "../..";
+export declare enum LODStrategy {
+    VERTEX_DECIMATION = "vertex_decimation",
+    TRIANGLE_REDUCTION = "triangle_reduction",
+    GEOMETRIC_SIMPLIFICATION = "geometric_simplification",
+    BOUNDING_BOX_REPLACEMENT = "bounding_box_replacement"
+}
+export interface LODLevel {
+    distance: number;
+    reductionRatio: number;
+    strategy: LODStrategy;
+}
+export interface LODResult {
+    level: number;
+    geometry: BufferGeometry;
+    vertexCount: number;
+    triangleCount: number;
+    reductionRatio: number;
+}
+export declare class FastLODGenerator {
+    private workerPool;
+    private lodLevels;
+    constructor(numberOfWorkers?: number);
+    private initializeWorkerPool;
+    /**
+     * Generate all LOD levels for a mesh concurrently
+     */
+    generateLODsForMesh(mesh: ViralBatchedMesh, customLODLevels?: LODLevel[]): Promise<Map<number, LODResult>>;
+    /**
+     * Generate LODs for entire merged model
+     */
+    generateLODsForMergedModel(mergedModel: ViralMergedModel): Promise<Map<string, Map<number, LODResult>>>;
+    /**
+     * Generate LOD for instanced mesh (base geometry only)
+     */
+    private generateLODsForInstancedMesh;
+    /**
+     * Generate single LOD level
+     */
+    private generateSingleLOD;
+    /**
+     * Quick LOD generation with preset configurations
+     */
+    generateQuickLODs(mergedModel: ViralMergedModel, preset?: "performance" | "balanced" | "quality"): Promise<Map<string, Map<number, LODResult>>>;
+    /**
+     * Set custom LOD levels
+     */
+    setLODLevels(levels: LODLevel[]): void;
+    /**
+     * Get current LOD configuration
+     */
+    getLODLevels(): LODLevel[];
+    dispose(): void;
+}
+export declare class LODManager {
+    private lodData;
+    private mergedModel;
+    private originalMeshes;
+    private currentLODLevels;
+    constructor(mergedModel: ViralMergedModel, lodData: Map<string, Map<number, LODResult>>);
+    private cacheOriginalMeshes;
+    /**
+     * Update LOD levels based on camera distance
+     */
+    updateLODBasedOnCamera(cameraPosition: Vector3): void;
+    private calculateDistanceToMesh;
+    private determineOptimalLODLevel;
+    private switchToLODLevel;
+    /**
+     * Get current LOD statistics
+     */
+    getLODStats(): Map<string, {
+        level: number;
+        vertexCount: number;
+        reductionRatio: number;
+    }>;
+    /**
+     * Force specific LOD level for all meshes
+     */
+    setGlobalLODLevel(level: number): void;
+    /**
+     * Reset all meshes to highest detail (LOD 0)
+     */
+    resetToHighestDetail(): void;
+    /**
+     * Get available LOD levels for a specific mesh
+     */
+    getAvailableLODLevels(meshId: string): number[];
+}
+export declare class LODPerformanceMonitor {
+    private frameCount;
+    private lastFrameTime;
+    private currentFPS;
+    private lodManager;
+    private performanceHistory;
+    constructor(lodManager: LODManager);
+    private startMonitoring;
+    private recordPerformanceData;
+    getCurrentFPS(): number;
+    getAverageFPS(): number;
+    getPerformanceReport(): {
+        currentFPS: number;
+        averageFPS: number;
+        currentLODStats: any;
+        recommendations: string[];
+    };
+}
+export interface LODPresetConfig {
+    name: string;
+    levels: LODLevel[];
+    description: string;
+}
+export declare const LODPresets: Record<string, LODPresetConfig>;
+export declare function detectDeviceCapability(): "mobile" | "desktop" | "workstation";
+export declare function getOptimalWorkerCount(): number;

package/dist/components/worker/base/worker-pool.d.ts

@@ -20,4 +20,5 @@ export declare class WorkerThreadPool {
      */
     Enqueue<T, M>(inputData: T, resolve: (result: M) => void): void;
     private _PumpQueue;
+    dispose(): void;
 }

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

@@ -1,11 +1,12 @@
 import { ViralViewerApi } from "../../viral-viewer-api";
 import { RenderMaterial, ViralutionElement } from "../../types";
-import { Box3, Camera, Vector3 } from "three";
+import { Box3, 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;
+    workerPool2: WorkerThreadPool;
     private lastRenderTime;
     private useSpatialMerging;
     constructor(viralViewerApi: ViralViewerApi);
@@ -19,10 +20,11 @@ export declare class LoadElementPatchWorker {
      * Main load method - automatically routes to spatial or traditional approach
      */
     loadElement(modelId: number, elements: ViralutionElement[], callbackOnSuccess?: () => void): void;
+    private loadInstancedElement;
     /**
      * Traditional load implementation (renamed for clarity)
      */
-    private loadTraditionalElement;
+    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. */
@@ -30,34 +32,11 @@ export declare class LoadElementPatchWorker {
     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 createSingleInstancedMesh;
     /**
      * Create optimized material for merging
      */

package/dist/components/worker-script/load-instanced-element.script.d.ts

@@ -0,0 +1 @@
+export declare const workerCode: any;