viral-viewer-2 6.8.3 → 6.8.4

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

@@ -0,0 +1,15 @@
+import { BufferElement, ViralViewerApi } from "../..";
+import { ViralMainModel } from "../custom-objects/viral-main.model";
+export declare class ViralBatcher {
+    viralViewerApi: ViralViewerApi;
+    constructor(viralViewerApi: ViralViewerApi);
+    makeBatches(mainModel: ViralMainModel, modelId: number, bufferElements: BufferElement[]): void;
+    private createSingleMergedMesh;
+    private createOptimizedMaterial;
+    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;
+}

package/dist/components/custom-objects/index.d.ts

@@ -1,4 +1,4 @@
 import { ViralInstancedMesh } from "./viral-instanced-mesh";
-import { ViralMergedMesh } from "./viral-merged-mesh";
+import { ViralBatchedMesh } from "./viral-batched-mesh";
 import { ViralMergedModel } from "./viral-merged-model";
-export { ViralInstancedMesh, ViralMergedModel, ViralMergedMesh };
+export { ViralInstancedMesh, ViralMergedModel, ViralBatchedMesh };

package/dist/components/custom-objects/{viral-merged-mesh.d.ts → viral-batched-mesh.d.ts}

@@ -1,6 +1,7 @@
-import { Box3, BufferGeometry, Color, LineBasicMaterial, Material, Mesh, Vector3 } from "three";
+import { Box3, BufferGeometry, Color, Material, Mesh, Vector3 } from "three";
 import { BufferElement } from "../..";
-export declare class ViralMergedMesh extends Mesh {
+import { LineMaterial } from "three/examples/jsm/Addons";
+export declare class ViralBatchedMesh extends Mesh {
     globalMaterialIndex: number;
     constructor(geometry?: BufferGeometry, material?: Material);
     /**
@@ -32,7 +33,7 @@ export declare class ViralMergedMesh extends Mesh {
     private _edgeRanges;
     private _edgeThreshold;
     private _edgeMaterial;
-    enableEdgePerElement(material: LineBasicMaterial, thresholdDeg?: number): void;
+    enableEdgePerElement(material: LineMaterial, thresholdDeg?: number): void;
     disableEdge(): void;
     enableEdge(): void;
     /** call this after rebuild/batch to keep edges in sync (if enabled) */
@@ -157,7 +158,7 @@ export declare class ViralMergedMesh extends Mesh {
     getTotalVertexCount(): number;
     getObjectCount(): number;
     /**
-     * ! Disposes of the ViralMergedMesh properly, when dispose we dont need to dispose material
+     * ! Disposes of the ViralBatchedMesh properly, when dispose we dont need to dispose material
      */
     dispose(): void;
 }

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

@@ -1,7 +1,7 @@
-import { Box3, LineBasicMaterial, Mesh } from "three";
-import { ViralMergedMesh } from "./viral-merged-mesh";
+import { Box3, Mesh } from "three";
+import { ViralBatchedMesh } from "./viral-batched-mesh";
 import { BufferElement } from "../..";
-import { ViralMergedEdges } from "./viral-merged-edge";
+import { LineMaterial } from "three/examples/jsm/lines/LineMaterial";
 /**
  * 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.
@@ -12,14 +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;
-    getMergedMeshes(): ViralMergedMesh[];
+    addMergedMesh(mesh: ViralBatchedMesh): void;
+    getMergedMesh(globalMaterialIndex: number): ViralBatchedMesh | undefined;
+    getMergedMeshes(): ViralBatchedMesh[];
     hide(elements?: {
         modelId: string;
         elementId: string;
@@ -88,7 +84,7 @@ export declare class ViralMergedModel extends Mesh {
      */
     resetVisibility(): void;
     resetColor(): void;
-    enableEdge(material: LineBasicMaterial): void;
+    enableEdge(material: LineMaterial): void;
     showEdge(): void;
     hideEdge(): void;
     /**

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

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

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

@@ -1,10 +1,11 @@
-import { LineBasicMaterial, Material, MeshPhongMaterial, MeshStandardMaterial } from "three";
+import { Material, MeshPhongMaterial, MeshStandardMaterial } from "three";
 import { ViralViewerApi } from "../../viral-viewer-api";
+import { LineMaterial } from "three/examples/jsm/lines/LineMaterial";
 export declare class ViralMaterialManager {
     private viralViewerApi;
     hoverMaterial: MeshPhongMaterial;
     selectedMaterial: MeshPhongMaterial;
-    edgeMaterial: LineBasicMaterial;
+    edgeMaterial: LineMaterial;
     outlineMaterial: MeshStandardMaterial;
     materials: Material[];
     mergeMaterials: Material[];

package/dist/components/post-processing/post-processing-renderer.d.ts

@@ -5,6 +5,7 @@ import { ShaderPass } from "three/examples/jsm/postprocessing/ShaderPass";
 import { SAOPass, SSAARenderPass, SSAOPass, TAARenderPass } from "three/examples/jsm/Addons";
 import { ViralViewerApi } from "../..";
 import { OutlinePass } from "three/examples/jsm/postprocessing/OutlinePass";
+import { DevicePerformanceChecker } from "../../utils/device";
 export declare class PostProcessingRenderer {
     private renderer;
     viralViewerApi: ViralViewerApi;
@@ -22,6 +23,7 @@ export declare class PostProcessingRenderer {
     shadowRemovalPass: ShaderPass | null;
     outlinePass: OutlinePass | null;
     n8aoPass: any;
+    perfChecker: DevicePerformanceChecker;
     constructor(renderer: WebGLRenderer, viralViewerApi: ViralViewerApi);
     isWebGL2Available(): boolean;
     render(): void;

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

@@ -0,0 +1,96 @@
+import { WebGLRenderer } from "three";
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { PostProcessingRenderer } from "../post-processing/post-processing-renderer";
+interface PerformanceConfig {
+    antialias: boolean;
+    logarithmicDepthBuffer: boolean;
+    preserveDrawingBuffer: boolean;
+    pixelRatio: number;
+    shadowMapEnabled: boolean;
+    shadowMapType: any;
+    shadowMapSize: number;
+    shadowMapAutoUpdate: boolean;
+    enablePostProcessing: boolean;
+    enableTAA: boolean;
+    taaSamples: number;
+    enableSSAO: boolean;
+    enableBloom: boolean;
+    enableFXAA: boolean;
+    enableSMAA: boolean;
+    toneMapping: any;
+    toneMappingExposure: number;
+    performanceLogging: boolean;
+    renderStatsInterval: number;
+    enableFrustumCulling: boolean;
+    enableLOD: boolean;
+    maxDrawCalls: number;
+    maxTextureSize: number;
+    textureFilter: any;
+    showPerformanceOverlay: boolean;
+}
+export declare class OptimizedViralRenderer {
+    viralViewerApi: ViralViewerApi;
+    renderer: WebGLRenderer;
+    postProcessingRenderer: PostProcessingRenderer;
+    private performanceChecker;
+    private deviceType;
+    private config;
+    private _t;
+    private _lastSpatialStatsTime;
+    private _frameCount;
+    private _lastFPSCheck;
+    private _currentFPS;
+    private _adaptiveQualityEnabled;
+    constructor(viralViewerApi: ViralViewerApi);
+    private generatePerformanceConfig;
+    private initializeRenderer;
+    private initializePostProcessing;
+    private configurePostProcessingEffects;
+    private setupPerformanceMonitoring;
+    updateSize(width: number, height: number): void;
+    render(): void;
+    private performRender;
+    private updateFPSCounter;
+    private checkAdaptiveQuality;
+    private adaptQualityDown;
+    private adaptQualityUp;
+    private canImproveQuality;
+    private logPerformanceMetrics;
+    private logRenderStats;
+    private logSpatialStats;
+    getPerformanceInfo(): {
+        rendering: {
+            calls: number;
+            triangles: number;
+            points: number;
+            lines: number;
+        };
+        memory: {
+            geometries: number;
+            textures: number;
+        };
+        performance: {
+            fps: number;
+            profile: "low" | "medium" | "high" | "potato" | "ultra";
+            pixelRatio: number;
+            deviceType: "mobile" | "tablet" | "pc";
+        };
+        spatial: {
+            totalCells: number;
+            loadedCells: number;
+            visibleCells: number;
+            cullingEfficiency: string;
+            memoryEfficiency: string;
+        } | null;
+        isSpatialActive: boolean;
+    };
+    setAdaptiveQuality(enabled: boolean): void;
+    forceQualityProfile(profile: "potato" | "low" | "medium" | "high" | "ultra"): void;
+    private applyNewConfiguration;
+    getCurrentConfig(): PerformanceConfig;
+    benchmarkDevice(): Promise<number>;
+    screenshot(): string;
+    screenshotWithSpatialDebug(): string;
+    renderVisibleCellsOnly(): void;
+}
+export {};

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

@@ -58,7 +58,6 @@ export declare class LoadElementPatchWorker {
      * Create single merged mesh (traditional implementation)
      */
     private createSingleMergedMesh;
-    private createSingleMergedEdge;
     /**
      * Create optimized material for merging
      */