@rings-webgpu/core 1.0.36 → 1.0.37

package/dist/types/components/renderer/GSplatStreamRenderer.d.ts

@@ -0,0 +1,176 @@
+import { RenderNode } from "./RenderNode";
+import { GSplatMaterial } from "../../materials/GSplatMaterial";
+import { View3D } from "../../core/View3D";
+import { RendererPassState } from "../../gfx/renderJob/passRenderer/state/RendererPassState";
+import { ClusterLightingBuffer } from "../../gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer";
+import { PassType } from "../../gfx/renderJob/passRenderer/state/PassType";
+import { Uint8ArrayTexture } from "../../textures/Uint8ArrayTexture";
+import { Uint32ArrayTexture } from "../../textures/Uint32ArrayTexture";
+import { R32UintTexture } from "../../textures/R32UintTexture";
+import { Float16ArrayTexture } from "../../textures/Float16ArrayTexture";
+import { Vector2 } from "../../math/Vector2";
+import { BoundingBox } from "../../core/bound/BoundingBox";
+/**
+ * Single splat data structure for streaming
+ */
+export type SplatData = {
+    position: [number, number, number];
+    rotation?: [number, number, number, number];
+    scale?: [number, number, number];
+    opacity?: number;
+    sh?: {
+        order: number;
+        coeffs: Float32Array;
+    };
+};
+/**
+ * Gaussian Splat Stream Renderer Component
+ */
+export declare class GSplatStreamRenderer extends RenderNode {
+    totalCount: number;
+    size: Vector2;
+    worldBoundBox: BoundingBox;
+    splatColor: Uint8ArrayTexture;
+    transformA: Uint32ArrayTexture;
+    transformB: Float16ArrayTexture;
+    texParams: Float32Array;
+    splatOrder: R32UintTexture;
+    gsplatMaterial: GSplatMaterial;
+    private _colorData;
+    private _transformAData;
+    private _transformBData;
+    private _orderData;
+    private _positions;
+    private _worldPositions;
+    private _splatSetFlags;
+    private _validCount;
+    private _sortWorker;
+    private _lastSentTime;
+    private _minIntervalMs;
+    private _centersSent;
+    private _lastViewMatrixHash;
+    private _lastCameraSpeed;
+    private _adaptiveSorting;
+    private _lastPixelCullParams;
+    private _texturesInitialized;
+    private _minPixelCoverage;
+    private _maxPixelCoverage;
+    private _maxPixelCullDistance;
+    private _batchSize;
+    instanceCount: number;
+    private _pendingUpdates;
+    private _autoFlushThreshold;
+    private _frameCount;
+    constructor();
+    /**
+     * Initialize renderer with total splat count
+     * Pre-allocates all GPU resources with zero-initialized data
+     * @param totalCount Total number of splats that will be streamed
+     * @param batchSize Splats per draw call (default: 128)
+     */
+    initCount(totalCount: number, batchSize?: number): void;
+    /**
+     * Set data for a single splat at the given index
+     * Updates CPU buffers and marks for GPU update
+     * @param index Splat index (0 to count-1)
+     * @param data Splat data (position is required, others optional)
+     */
+    setSplatData(index: number, data: SplatData): void;
+    /**
+     * Update transform data for a single splat
+     */
+    private updateTransformData;
+    /**
+     * Flush pending updates to GPU
+     * Updates GPU textures with all pending changes
+     */
+    flushUpdates(): void;
+    /**
+     * Set auto-flush threshold
+     * @param threshold Number of pending updates before auto-flush (default: 100)
+     */
+    setAutoFlushThreshold(threshold: number): void;
+    /**
+     * Get current streaming statistics
+     */
+    getStreamingStats(): {
+        totalCount: number;
+        validCount: number;
+        pendingUpdates: number;
+        progress: number;
+    };
+    /**
+     * Update splat sorting before rendering
+     * Uses the same logic as GSplatRenderer for reliable sorting
+     */
+    onBeforeUpdate(view?: View3D): void;
+    /**
+     * Update world space positions when transform changes
+     */
+    private updateWorldPositions;
+    private updatePendingWorldPositions;
+    /**
+     * Schedule Web Worker-based sorting task
+     * Uses the same logic as GSplatRenderer for consistency
+     */
+    private scheduleOrder;
+    /**
+     * Create Web Worker for sorting
+     * Uses the exact same logic as GSplatRenderer for consistency
+     */
+    private createSortWorker;
+    /**
+     * Set visibility boost factor
+     */
+    setVisBoost(v: number): void;
+    setCount(c: number): void;
+    private _updateTexParams;
+    /**
+     * Set sort throttle interval (milliseconds)
+     */
+    setSortThrottle(ms: number): void;
+    /**
+     * Enable/disable adaptive sorting
+     */
+    setAdaptiveSorting(enabled: boolean): void;
+    /**
+     * Set pixel coverage culling thresholds
+     */
+    setPixelCulling(minPixels: number, maxPixels?: number, maxPixelCullDistance?: number): void;
+    /**
+     * Get current pixel culling settings
+     */
+    getPixelCullingStats(): {
+        minPixels: number;
+        maxPixels: number;
+        maxPixelCullDistance: number;
+        maxEnabled: boolean;
+        distanceEnabled: boolean;
+    };
+    /**
+     * Get batching statistics
+     */
+    getBatchingStats(): {
+        enabled: boolean;
+        batchSize: number;
+        instanceCount: number;
+        splatCount: number;
+        reduction: number;
+    };
+    /**
+     * Calculate texture size for given splat count
+     */
+    private evalTextureSize;
+    /**
+     * Update node before rendering
+     */
+    nodeUpdate(view: View3D, passType: PassType, renderPassState: RendererPassState, clusterLightingBuffer?: ClusterLightingBuffer): void;
+    /**
+     * Render pass
+     */
+    renderPass(view: View3D, passType: PassType, renderContext: any): void;
+    /**
+     * Clean up resources
+     */
+    destroy(force?: boolean): void;
+}

package/dist/types/index.d.ts

@@ -183,6 +183,7 @@ export * from "./components/lights/SpotLight";
 export * from "./components/post/PostProcessingComponent";
 export * from "./components/renderer/FatLineRenderer";
 export * from "./components/renderer/GSplatRenderer";
+export * from "./components/renderer/GSplatStreamRenderer";
 export * from "./components/renderer/GlobalIlluminationComponent";
 export * from "./components/renderer/InstanceDrawComponent";
 export * from "./components/renderer/MeshFilter";
@@ -380,8 +381,10 @@ export * from "./loader/FileLoader";
 export * from "./loader/LoaderBase";
 export * from "./loader/LoaderFunctions";
 export * from "./loader/LoaderManager";
+export * from "./loader/StreamLoader";
 export * from "./loader/parser/3dgs/GaussianSplatAsset";
 export * from "./loader/parser/3dgs/GaussianSplatParser";
+export * from "./loader/parser/3dgs/StreamingGaussianSplatParser";
 export * from "./loader/parser/3dgs/loaders/FormatDetector";
 export * from "./loader/parser/AtlasParser";
 export * from "./loader/parser/B3DMParser";
@@ -434,6 +437,7 @@ export * from "./loader/parser/las/LASTypes";
 export * from "./loader/parser/las/LASUtils";
 export * from "./loader/parser/ply/PlyLoader";
 export * from "./loader/parser/ply/PlyParser";
+export * from "./loader/parser/ply/PlyStreamParser";
 export * from "./loader/parser/ply/PlyTypes";
 export * from "./loader/parser/ply/PlyUtils";
 export * from "./loader/parser/pnts/PNTSLoader";

package/dist/types/loader/StreamLoader.d.ts

@@ -0,0 +1,26 @@
+import { LoaderBase } from "./LoaderBase";
+import { LoaderFunctions } from "./LoaderFunctions";
+import { ParserBase } from "./parser/ParserBase";
+import { Parser } from "../util/Global";
+/**
+ * Stream loader result with cancel capability
+ */
+export interface StreamLoadResult<T extends ParserBase> {
+    parser: T;
+    cancel: () => void;
+}
+/**
+ * Stream loader for progressive resource loading
+ * Supports streaming data as it arrives, enabling progressive rendering
+ */
+export declare class StreamLoader extends LoaderBase {
+    /**
+     * Load resource with streaming support
+     * @param url Resource URL
+     * @param parserClass Parser class that supports streaming
+     * @param loaderFunctions Optional loader callbacks
+     * @param userData Optional user data
+     * @returns Promise that resolves when initial data is ready (header parsed), includes cancel method
+     */
+    loadStream<T extends ParserBase>(url: string, parserClass: Parser<T>, loaderFunctions?: LoaderFunctions, userData?: any): Promise<StreamLoadResult<T>>;
+}

package/dist/types/loader/parser/3dgs/StreamingGaussianSplatParser.d.ts

@@ -0,0 +1,53 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+/**
+ * Streaming Gaussian Splat Parser
+ *
+ * Supports progressive loading and rendering of Gaussian Splat files.
+ * Parses header first, then streams vertex data as it arrives.
+ */
+export declare class StreamingGaussianSplatParser extends ParserBase {
+    static format: ParserFormat;
+    private _streamParser;
+    private _streamingRenderer;
+    private _rendererObject;
+    private _chunksPerBatch;
+    private _headerParsed;
+    private _onHeaderParsed;
+    private _cancelled;
+    /**
+     * Initialize streaming parser
+     * @param contentLength Total content length (if known)
+     * @param onHeaderParsed Optional callback when header is parsed (parser is ready)
+     */
+    initStream(contentLength: number, onHeaderParsed?: () => void): Promise<void>;
+    /**
+     * Process incoming data chunk
+     * @param chunk Data chunk
+     * @param receivedLength Total bytes received so far
+     * @param contentLength Total content length (if known)
+     */
+    processChunk(chunk: Uint8Array, receivedLength: number, contentLength: number): Promise<void>;
+    /**
+     * Cancel streaming loading
+     * Stops processing new chunks and cleans up resources
+     */
+    cancel(): void;
+    /**
+     * Check if loading is cancelled
+     */
+    isCancelled(): boolean;
+    /**
+     * Finalize streaming parsing
+     */
+    finalizeStream(): Promise<void>;
+    /**
+     * Get parsing progress
+     */
+    getProgress(): {
+        processed: number;
+        total: number;
+        percentage: number;
+    };
+    verification(): boolean;
+}

package/dist/types/loader/parser/ply/PlyStreamParser.d.ts

@@ -0,0 +1,66 @@
+import { PlyHeader } from './PlyTypes';
+import { SplatData } from '../../../components/renderer/GSplatStreamRenderer';
+/**
+ * Streaming PLY parser for Gaussian Splatting
+ *
+ * Handles incremental parsing of PLY binary data as chunks arrive.
+ * Maintains state to handle partial vertex data at chunk boundaries.
+ */
+export declare class PlyStreamParser {
+    private _header;
+    private _headerBuffer;
+    private _headerLength;
+    private _headerParsed;
+    private _dataBuffer;
+    private _dataOffset;
+    private _processedVertices;
+    private _vertexStride;
+    private _propOffsets;
+    private _properties;
+    private _onHeaderParsed;
+    private _onSplatParsed;
+    private _batchSize;
+    private _cancelled;
+    constructor(onHeaderParsed: (header: PlyHeader) => void, onSplatParsed: (splatData: SplatData, index: number) => void, batchSize?: number);
+    /**
+     * Process incoming data chunk
+     */
+    processChunk(chunk: Uint8Array): void;
+    /**
+     * Cancel parsing
+     * Stops processing new chunks
+     */
+    cancel(): void;
+    /**
+     * Check if parsing is cancelled
+     */
+    isCancelled(): boolean;
+    /**
+     * Process header chunk
+     */
+    private _processHeaderChunk;
+    /**
+     * Parse PLY header from buffer
+     */
+    private _parseHeader;
+    /**
+     * Initialize data parsing structures
+     */
+    private _initializeDataParsing;
+    /**
+     * Process data chunk
+     */
+    private _processDataChunk;
+    /**
+     * Parse vertices from current data buffer
+     */
+    private _parseVertices;
+    /**
+     * Get current parsing progress
+     */
+    getProgress(): {
+        processed: number;
+        total: number;
+        percentage: number;
+    };
+}

package/dist/types/loader/parser/ply/index.d.ts

@@ -6,3 +6,4 @@
 export * from './PlyTypes';
 export * from './PlyUtils';
 export * from './PlyLoader';
+export * from './PlyStreamParser';

package/dist/types/materials/GSplatMaterial.d.ts

@@ -24,4 +24,5 @@ export declare class GSplatMaterial extends Material {
      * @param maxPixelCullDistance Only cull oversized splats within this distance, 0 = always cull
      */
     setPixelCulling(minPixels: number, maxPixels: number, maxPixelCullDistance?: number, batchSize?: number): void;
+    setTexParams(texParams: Float32Array): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rings-webgpu/core",
-  "version": "1.0.36",
+  "version": "1.0.37",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {