viral-viewer-2 6.9.0 → 6.9.2

package/dist/types.d.ts

@@ -5,6 +5,7 @@ export interface ViewerOptions {
     numberOfWorker: number;
     enableNavigationCube: boolean;
     enableTools: boolean;
+    enablePostProcessing?: boolean;
 }
 export interface ViralViewerRevitProject {
     Materials: RenderMaterial[];

package/dist/utils/batched-mesh-simplifier.d.ts

@@ -0,0 +1,36 @@
+import { SimplifyOptions } from "./geometry-simplifier";
+import { BufferElement } from "../types";
+import { ViralBatchedMesh } from "../components/custom-objects/viral-batched-mesh";
+/**
+ * Simplify buffer elements while preserving the ability to batch them
+ * This simplifies each element's geometry individually, so element mapping remains valid
+ */
+export declare function simplifyBufferElements(bufferElements: BufferElement[], options: SimplifyOptions): Promise<BufferElement[]>;
+/**
+ * Create a simplified version of a ViralBatchedMesh by simplifying its buffer elements
+ * This preserves element mapping functionality (hide, isolate, changeColor)
+ *
+ * @param originalMesh - The original batched mesh
+ * @param options - Simplification options
+ * @returns Object containing simplified buffer elements and original color
+ */
+export declare function getSimplifiedBatchedMeshData(originalMesh: any, // ViralBatchedMesh
+options: SimplifyOptions): Promise<{
+    simplifiedElements: BufferElement[];
+    originalColor: any;
+}>;
+/**
+ * Simplify buffer elements in batches for better performance
+ * Uses parallel processing when possible
+ */
+export declare function simplifyBufferElementsBatch(bufferElements: BufferElement[], options: SimplifyOptions, batchSize?: number): Promise<BufferElement[]>;
+/**
+ * FAST: Simplify entire batched mesh geometry at once
+ * This is much faster than per-element simplification but breaks element mapping
+ * Use this when you don't need hide/isolate/changeColor functionality
+ *
+ * @param batchedMesh - The batched mesh to simplify
+ * @param options - Simplification options
+ * @returns New simplified ViralBatchedMesh
+ */
+export declare function simplifyBatchedMeshFast(batchedMesh: ViralBatchedMesh, options: SimplifyOptions): Promise<ViralBatchedMesh>;

package/dist/utils/geometry-simplifier.d.ts

@@ -0,0 +1,108 @@
+import { BufferGeometry } from "three";
+/**
+ * Options for geometry simplification
+ */
+export interface SimplifyOptions {
+    /** Target ratio of triangles to keep (0-1) */
+    ratio?: number;
+    /** Maximum error tolerance */
+    error?: number;
+    /** Lock border vertices during simplification */
+    lockBorder?: boolean;
+    /** Use sparse simplification */
+    sparse?: boolean;
+    /** Use absolute error metric */
+    errorAbsolute?: boolean;
+    /** Prune unnecessary vertices */
+    prune?: boolean;
+    /** Optimize memory by using smaller index types */
+    optimizeMemory?: boolean;
+    /** Log appearance error after simplification */
+    logAppearanceError?: boolean;
+}
+/**
+ * LOD (Level of Detail) configuration
+ */
+export interface LODConfig {
+    ratio: number;
+    error?: number;
+}
+/**
+ * Predefined LOD ranges optimized for performance
+ */
+export declare const performanceRangeLOD: number[];
+/**
+ * Predefined LOD ranges with balanced quality/performance
+ */
+export declare const balancedRangeLOD: number[];
+/**
+ * Predefined LOD ranges optimized for quality
+ */
+export declare const qualityRangeLOD: number[];
+/**
+ * Core simplification function using meshoptimizer
+ * @param indices - Index buffer array
+ * @param positions - Position buffer array
+ * @param options - Simplification options
+ * @returns Tuple of [simplified indices, appearance error]
+ */
+declare function simplify(indices: Uint8Array | Uint16Array | Uint32Array | number[], positions: Float32Array | number[], options: SimplifyOptions): Promise<[Uint8Array | Uint16Array | Uint32Array, number]>;
+/**
+ * Simplify a BufferGeometry
+ * @param geometry - Input geometry (must be indexed)
+ * @param options - Simplification options
+ * @returns Simplified geometry clone
+ */
+export declare function simplifyGeometry(geometry: BufferGeometry, options: SimplifyOptions): Promise<BufferGeometry>;
+/**
+ * Simplify multiple geometries
+ * @param geometries - Array of geometries to simplify
+ * @param options - Simplification options (can be array for per-geometry options)
+ * @returns Array of simplified geometries
+ */
+export declare function simplifyGeometries(geometries: BufferGeometry[], options: SimplifyOptions | SimplifyOptions[]): Promise<BufferGeometry[]>;
+/**
+ * Simplify geometry by error tolerance (ratio = 0)
+ * @param geometry - Input geometry
+ * @param error - Maximum error tolerance
+ * @returns Simplified geometry
+ */
+export declare function simplifyGeometryByError(geometry: BufferGeometry, error: number): Promise<BufferGeometry>;
+/**
+ * Simplify multiple geometries by error tolerance
+ * @param geometries - Array of geometries
+ * @param errors - Error tolerance (can be array for per-geometry errors)
+ * @returns Array of simplified geometries
+ */
+export declare function simplifyGeometriesByError(geometries: BufferGeometry[], errors: number | number[]): Promise<BufferGeometry[]>;
+/**
+ * Create multiple LOD levels for a geometry using error-based simplification
+ * @param geometry - Input geometry
+ * @param lodCount - Number of LOD levels to generate
+ * @param errorRange - Array of error values for each LOD level (default: balancedRangeLOD)
+ * @returns Array of geometries [original, LOD1, LOD2, ...]
+ */
+export declare function simplifyGeometryByErrorLOD(geometry: BufferGeometry, lodCount: number, errorRange?: number[]): Promise<BufferGeometry[]>;
+/**
+ * Create multiple LOD levels for multiple geometries using error-based simplification
+ * @param geometries - Array of input geometries
+ * @param lodCounts - Number of LOD levels per geometry (can be array or single value)
+ * @param errorRanges - Error ranges per geometry (default: balancedRangeLOD)
+ * @returns Array of LOD arrays
+ */
+export declare function simplifyGeometriesByErrorLOD(geometries: BufferGeometry[], lodCounts: number | number[], errorRanges?: number[] | number[][]): Promise<BufferGeometry[][]>;
+/**
+ * Create multiple LOD levels for a geometry using custom options
+ * @param geometry - Input geometry
+ * @param lodOptions - Array of simplification options for each LOD level
+ * @returns Array of geometries [original, LOD1, LOD2, ...]
+ */
+export declare function simplifyGeometryLOD(geometry: BufferGeometry, lodOptions: SimplifyOptions[]): Promise<BufferGeometry[]>;
+/**
+ * Create multiple LOD levels for multiple geometries using custom options
+ * @param geometries - Array of input geometries
+ * @param lodOptions - LOD options per geometry (can be array of arrays or single array)
+ * @returns Array of LOD arrays
+ */
+export declare function simplifyGeometriesLOD(geometries: BufferGeometry[], lodOptions: SimplifyOptions[] | SimplifyOptions[][]): Promise<BufferGeometry[][]>;
+export { simplify };

package/dist/utils/threejs.d.ts

@@ -12,5 +12,5 @@ export declare class THREEUtil {
     static rgbToThreejsColor(r: number, g: number, b: number): string;
     private static componentToHex;
     static mergeBoundingBoxes(boxes: Box3[]): Box3;
-    static createLowResMesh(mesh: Mesh, simplificationFactor?: number): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>;
+    static createLowResMesh(mesh: Mesh, simplificationFactor?: number): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>;
 }

package/dist/viral-viewer-api.d.ts

@@ -25,6 +25,7 @@ import { ViralAvatarManager } from "./components/avatar-manager/viral-avatar-man
 import { ViralGeometryHandler } from "./components/handler/geometry.handler";
 import { ViralSectionBox } from "./components/section-box/viral-section-box";
 import { ViralPivotPoint } from "./gui/pivot-point/viral-pivot-point";
+import { ViralBatchDebugPanel } from "./gui/batch-debug-panel/viral-batch-debug-panel";
 /**
  * Root of library
  */
@@ -56,5 +57,6 @@ export declare class ViralViewerApi extends EventDispatcher {
     viralStats: ViralStats | null;
     viralGeometryHandler: ViralGeometryHandler | null;
     viralSectionBox: ViralSectionBox | null;
+    viralBatchDebugPanel: ViralBatchDebugPanel | null;
     constructor(options?: ViewerOptions);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "viral-viewer-2",
-    "version": "6.9.0",
+    "version": "6.9.2",
     "description": "",
     "main": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "devDependencies": {
         "@types/node": "^20.2.5",
         "@types/pako": "^2.0.0",
-        "@types/three": "^0.171.0",
+        "@types/three": "^0.181.0",
         "flatbuffers": "^25.2.10",
         "lil-gui": "^0.20.0",
         "typescript": "^5.0.4",
@@ -32,10 +32,12 @@
     },
     "dependencies": {
         "camera-controls": "^2.9.0",
+        "meshoptimizer": "^0.25.0",
         "n8ao": "^1.10.1",
         "pako": "^2.1.0",
+        "postprocessing": "^6.38.0",
         "potree-core-viral": "^0.3.0",
-        "three": "^0.171.0",
-        "three-mesh-bvh": "^0.9.1"
+        "three": "^0.181.2",
+        "three-mesh-bvh": "^0.9.2"
     }
 }

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

@@ -1,15 +0,0 @@
-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;
-}