@rings-webgpu/core 1.0.36 → 1.0.37

package/dist/rings.umd.max.js

@@ -2120,7 +2120,7 @@
   }
 
   var __defProp$2 = Object.defineProperty;
-  var __decorateClass$o = (decorators, target, key, kind) => {
+  var __decorateClass$p = (decorators, target, key, kind) => {
     var result = void 0 ;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
@@ -2223,10 +2223,10 @@
       return struct.__size;
     }
   };
-  __decorateClass$o([
+  __decorateClass$p([
     NonSerialize
   ], _Struct.prototype, "__refection");
-  __decorateClass$o([
+  __decorateClass$p([
     NonSerialize
   ], _Struct.prototype, "__size");
   let Struct = _Struct;
@@ -21972,9 +21972,9 @@ struct InstanceData {
   }
 
   var __defProp$1 = Object.defineProperty;
-  var __getOwnPropDesc$n = Object.getOwnPropertyDescriptor;
-  var __decorateClass$n = (decorators, target, key, kind) => {
-    var result = __getOwnPropDesc$n(target, key) ;
+  var __getOwnPropDesc$o = Object.getOwnPropertyDescriptor;
+  var __decorateClass$o = (decorators, target, key, kind) => {
+    var result = __getOwnPropDesc$o(target, key) ;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(target, key, result) ) || result;
@@ -22572,13 +22572,13 @@ struct InstanceData {
       this._combineShaderRefection = void 0;
     }
   }
-  __decorateClass$n([
+  __decorateClass$o([
     EditorInspector
   ], RenderNode.prototype, "materials");
-  __decorateClass$n([
+  __decorateClass$o([
     EditorInspector
   ], RenderNode.prototype, "castShadow");
-  __decorateClass$n([
+  __decorateClass$o([
     EditorInspector
   ], RenderNode.prototype, "castGI");
 
@@ -23245,9 +23245,9 @@ struct InstanceData {
     }
   }
 
-  var __getOwnPropDesc$m = Object.getOwnPropertyDescriptor;
-  var __decorateClass$m = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$m(target, key) : target;
+  var __getOwnPropDesc$n = Object.getOwnPropertyDescriptor;
+  var __decorateClass$n = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$n(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -23279,7 +23279,7 @@ struct InstanceData {
       pass.setUniform("pixelCull", new Float32Array([2, 0, 0, 0]));
     }
   };
-  exports.GSplatShader = __decorateClass$m([
+  exports.GSplatShader = __decorateClass$n([
     RegisterShader(exports.GSplatShader, "GSplatShader")
   ], exports.GSplatShader);
 
@@ -23323,6 +23323,10 @@ struct InstanceData {
       const pass = this.shader.getDefaultColorShader();
       pass.setUniform("pixelCull", this._pixelCullArray);
     }
+    setTexParams(texParams) {
+      const pass = this.shader.getDefaultColorShader();
+      pass.setUniformArray("tex_params", texParams);
+    }
   }
 
   class VertexGPUBuffer extends GPUBufferBase {
@@ -24296,9 +24300,9 @@ struct InstanceData {
     }
   }
 
-  var __getOwnPropDesc$l = Object.getOwnPropertyDescriptor;
-  var __decorateClass$l = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$l(target, key) : target;
+  var __getOwnPropDesc$m = Object.getOwnPropertyDescriptor;
+  var __decorateClass$m = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$m(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -25097,7 +25101,7 @@ struct InstanceData {
       super.destroy(force);
     }
   };
-  exports.GSplatRenderer = __decorateClass$l([
+  exports.GSplatRenderer = __decorateClass$m([
     RegisterComponent(exports.GSplatRenderer, "GSplatRenderer")
   ], exports.GSplatRenderer);
 
@@ -25236,9 +25240,9 @@ struct InstanceData {
 `
   );
 
-  var __getOwnPropDesc$k = Object.getOwnPropertyDescriptor;
-  var __decorateClass$k = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$k(target, key) : target;
+  var __getOwnPropDesc$l = Object.getOwnPropertyDescriptor;
+  var __decorateClass$l = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$l(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -25270,7 +25274,7 @@ struct InstanceData {
       pass.setUniformArray("pointParams", new Float32Array([0, 0, 0, 128]));
     }
   };
-  exports.PointCloudShader = __decorateClass$k([
+  exports.PointCloudShader = __decorateClass$l([
     RegisterShader(exports.PointCloudShader, "PointCloudShader")
   ], exports.PointCloudShader);
 
@@ -25463,9 +25467,9 @@ struct InstanceData {
     }
   }
 
-  var __getOwnPropDesc$j = Object.getOwnPropertyDescriptor;
-  var __decorateClass$j = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$j(target, key) : target;
+  var __getOwnPropDesc$k = Object.getOwnPropertyDescriptor;
+  var __decorateClass$k = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$k(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -25776,7 +25780,7 @@ struct InstanceData {
       super.destroy(force);
     }
   };
-  exports.PointCloudRenderer = __decorateClass$j([
+  exports.PointCloudRenderer = __decorateClass$k([
     RegisterComponent(exports.PointCloudRenderer, "PointCloudRenderer")
   ], exports.PointCloudRenderer);
 
@@ -26131,9 +26135,9 @@ struct InstanceData {
     }
   }
 
-  var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
-  var __decorateClass$i = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$i(target, key) : target;
+  var __getOwnPropDesc$j = Object.getOwnPropertyDescriptor;
+  var __decorateClass$j = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$j(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -26408,7 +26412,7 @@ struct InstanceData {
       super.destroy(force);
     }
   };
-  exports.Object3D = __decorateClass$i([
+  exports.Object3D = __decorateClass$j([
     DecorateObject3D
   ], exports.Object3D);
   function DecorateObject3D(ctor, _) {
@@ -27774,9 +27778,9 @@ struct InstanceData {
   }
 
   var __defProp = Object.defineProperty;
-  var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
-  var __decorateClass$h = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
+  var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
+  var __decorateClass$i = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$i(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (kind ? decorator(target, key, result) : decorator(result)) || result;
@@ -27889,13 +27893,13 @@ struct InstanceData {
       super.destroy(force);
     }
   };
-  __decorateClass$h([
+  __decorateClass$i([
     EditorInspector
   ], exports.MeshRenderer.prototype, "geometry", 1);
-  __decorateClass$h([
+  __decorateClass$i([
     EditorInspector
   ], exports.MeshRenderer.prototype, "material", 1);
-  exports.MeshRenderer = __decorateClass$h([
+  exports.MeshRenderer = __decorateClass$i([
     RegisterComponent(exports.MeshRenderer, "MeshRenderer")
   ], exports.MeshRenderer);
 
@@ -28501,9 +28505,9 @@ struct InstanceData {
     }
   }
 
-  var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
-  var __decorateClass$g = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
+  var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
+  var __decorateClass$h = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -28527,7 +28531,7 @@ struct InstanceData {
       this.setUniformFloat(`height`, 100);
     }
   };
-  exports.QuadShader = __decorateClass$g([
+  exports.QuadShader = __decorateClass$h([
     RegisterShader(exports.QuadShader, "QuadShader")
   ], exports.QuadShader);
 
@@ -35890,9 +35894,9 @@ else if (typeof exports === 'object')
     }
   }
 
-  var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
-  var __decorateClass$f = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
+  var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
+  var __decorateClass$g = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -35934,13 +35938,13 @@ else if (typeof exports === 'object')
     debug() {
     }
   };
-  exports.DirectLight = __decorateClass$f([
+  exports.DirectLight = __decorateClass$g([
     RegisterComponent(exports.DirectLight, "DirectLight")
   ], exports.DirectLight);
 
-  var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
-  var __decorateClass$e = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
+  var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
+  var __decorateClass$f = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -35998,13 +36002,13 @@ else if (typeof exports === 'object')
     debugDraw(show) {
     }
   };
-  exports.PointLight = __decorateClass$e([
+  exports.PointLight = __decorateClass$f([
     RegisterComponent(exports.PointLight, "PointLight")
   ], exports.PointLight);
 
-  var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
-  var __decorateClass$d = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
+  var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
+  var __decorateClass$e = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -36069,7 +36073,7 @@ else if (typeof exports === 'object')
     debugDraw(show) {
     }
   };
-  exports.SpotLight = __decorateClass$d([
+  exports.SpotLight = __decorateClass$e([
     RegisterComponent(exports.SpotLight, "SpotLight")
   ], exports.SpotLight);
 
@@ -42154,7 +42158,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.35";
+  const version = "1.0.36";
 
   class Engine3D {
     /**
@@ -46667,9 +46671,9 @@ fn frag(){
     }
   }
 
-  var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
-  var __decorateClass$c = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
+  var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
+  var __decorateClass$d = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -46693,7 +46697,7 @@ fn frag(){
       shaderState.depthCompare = GPUCompareFunction.less;
     }
   };
-  exports.SkyShader = __decorateClass$c([
+  exports.SkyShader = __decorateClass$d([
     RegisterShader(exports.SkyShader, "SkyShader")
   ], exports.SkyShader);
 
@@ -47491,9 +47495,9 @@ fn frag(){
     }
   }
 
-  var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
-  var __decorateClass$b = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+  var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
+  var __decorateClass$c = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -47697,7 +47701,7 @@ fn frag(){
       this._currentClipState.weight = 1;
     }
   };
-  exports.SkeletonAnimationComponent = __decorateClass$b([
+  exports.SkeletonAnimationComponent = __decorateClass$c([
     RegisterComponent(exports.SkeletonAnimationComponent, "SkeletonAnimationComponent")
   ], exports.SkeletonAnimationComponent);
   class SkeletonAnimationCrossFadeState {
@@ -47733,9 +47737,9 @@ fn frag(){
     }
   }
 
-  var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
-  var __decorateClass$a = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+  var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+  var __decorateClass$b = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -48146,7 +48150,7 @@ fn frag(){
       return dst;
     }
   };
-  exports.AnimatorComponent = __decorateClass$a([
+  exports.AnimatorComponent = __decorateClass$b([
     RegisterComponent(exports.AnimatorComponent, "AnimatorComponent")
   ], exports.AnimatorComponent);
   class PropertyAnimationClipState {
@@ -48903,9 +48907,9 @@ fn frag(){
     }
   }
 
-  var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
-  var __decorateClass$9 = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+  var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
+  var __decorateClass$a = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -49054,7 +49058,7 @@ fn frag(){
       super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
     }
   };
-  exports.SkinnedMeshRenderer2 = __decorateClass$9([
+  exports.SkinnedMeshRenderer2 = __decorateClass$a([
     RegisterComponent(exports.SkinnedMeshRenderer2, "SkinnedMeshRenderer2")
   ], exports.SkinnedMeshRenderer2);
 
@@ -54187,9 +54191,9 @@ fn frag(){
     }
   }
 
-  var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
-  var __decorateClass$8 = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+  var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
+  var __decorateClass$9 = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -54266,13 +54270,13 @@ fn frag(){
     debugDraw(show) {
     }
   };
-  exports.Light = __decorateClass$8([
+  exports.Light = __decorateClass$9([
     RegisterComponent(exports.Light, "Light")
   ], exports.Light);
 
-  var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
-  var __decorateClass$7 = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+  var __decorateClass$8 = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(result)) || result;
@@ -54347,10 +54351,771 @@ fn frag(){
       super.destroy(force);
     }
   };
-  exports.FatLineRenderer = __decorateClass$7([
+  exports.FatLineRenderer = __decorateClass$8([
     RegisterComponent(exports.FatLineRenderer, "FatLineRenderer")
   ], exports.FatLineRenderer);
 
+  var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+  var __decorateClass$7 = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+    for (var i = decorators.length - 1, decorator; i >= 0; i--)
+      if (decorator = decorators[i])
+        result = (decorator(result)) || result;
+    return result;
+  };
+  exports.GSplatStreamRenderer = class GSplatStreamRenderer extends RenderNode {
+    // Splat count and texture dimensions
+    totalCount = 0;
+    size = new Vector2();
+    worldBoundBox = new BoundingBox();
+    // GPU textures for splat data
+    splatColor;
+    transformA;
+    transformB;
+    texParams;
+    // [numSplats, texWidth, validCount, visBoost]
+    splatOrder;
+    // Material and geometry
+    gsplatMaterial;
+    // CPU-side data buffers (pre-allocated)
+    _colorData;
+    // RGBA8: count * 4
+    _transformAData;
+    // RGBA32U: count * 4
+    _transformBData;
+    // RGBA16F: count * 4
+    _orderData;
+    // R32U: size.x * size.y
+    _positions;
+    // xyz per splat (local space)
+    _worldPositions;
+    // xyz per splat (world space, cached)
+    // Tracking which splats have been set
+    _splatSetFlags;
+    // Track which indices have data
+    _validCount = 0;
+    // Number of splats with valid data
+    // Web Worker for sorting (same as GSplatRenderer)
+    _sortWorker;
+    _lastSentTime = 0;
+    _minIntervalMs = 16;
+    _centersSent = false;
+    _lastViewMatrixHash = 0;
+    // Adaptive sorting optimization
+    _lastCameraSpeed = 0;
+    _adaptiveSorting = true;
+    _lastPixelCullParams = "";
+    _texturesInitialized = false;
+    // Pixel coverage culling
+    _minPixelCoverage = 4;
+    _maxPixelCoverage = 0;
+    _maxPixelCullDistance = 0;
+    // Batched rendering
+    _batchSize = 128;
+    instanceCount = 0;
+    // Batch update optimization
+    _pendingUpdates = /* @__PURE__ */ new Set();
+    // Indices pending GPU update
+    _autoFlushThreshold = 100;
+    // Auto-flush when this many updates pending
+    _frameCount = 0;
+    constructor() {
+      super();
+    }
+    /**
+     * 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, batchSize = 128) {
+      if (totalCount <= 0) {
+        throw new Error("Total count must be greater than 0");
+      }
+      this.totalCount = totalCount;
+      this._batchSize = batchSize;
+      this.size = this.evalTextureSize(totalCount);
+      const w = this.size.x | 0;
+      const h = this.size.y | 0;
+      const total = w * h;
+      this._colorData = new Uint8Array(total * 4);
+      this._colorData.fill(0);
+      this._transformAData = new Uint32Array(total * 4);
+      this._transformAData.fill(0);
+      this._transformBData = new Array(total * 4).fill(0);
+      this._orderData = new Uint32Array(total);
+      for (let i = 0; i < total; i++) {
+        this._orderData[i] = i < totalCount ? i : totalCount > 0 ? totalCount - 1 : 0;
+      }
+      this._positions = new Float32Array(totalCount * 3);
+      this._positions.fill(0);
+      this._worldPositions = new Float32Array(totalCount * 3);
+      this._worldPositions.fill(0);
+      this._splatSetFlags = new Array(totalCount).fill(false);
+      this._validCount = 0;
+      this.texParams = new Float32Array([this._validCount, this.size.x, 0, 1]);
+      this.splatColor = new Uint8ArrayTexture().create(w, h, this._colorData, false);
+      this.splatColor.name = "splatColor";
+      this.splatColor.minFilter = "nearest";
+      this.splatColor.magFilter = "nearest";
+      this.splatColor.mipmapFilter = "nearest";
+      this.splatColor.addressModeU = "clamp-to-edge";
+      this.splatColor.addressModeV = "clamp-to-edge";
+      this.transformA = new Uint32ArrayTexture().create(w, h, this._transformAData);
+      this.transformA.name = "transformA";
+      this.transformA.minFilter = "nearest";
+      this.transformA.magFilter = "nearest";
+      this.transformA.addressModeU = "clamp-to-edge";
+      this.transformA.addressModeV = "clamp-to-edge";
+      this.transformB = new Float16ArrayTexture().create(w, h, this._transformBData, false);
+      this.transformB.name = "transformB";
+      this.transformB.minFilter = "nearest";
+      this.transformB.magFilter = "nearest";
+      this.transformB.mipmapFilter = "nearest";
+      this.transformB.addressModeU = "clamp-to-edge";
+      this.transformB.addressModeV = "clamp-to-edge";
+      this.splatOrder = new R32UintTexture().create(w, h, this._orderData);
+      this.splatOrder.name = "splatOrder";
+      this.splatOrder.minFilter = "nearest";
+      this.splatOrder.magFilter = "nearest";
+      this.splatOrder.addressModeU = "clamp-to-edge";
+      this.splatOrder.addressModeV = "clamp-to-edge";
+      this.gsplatMaterial = new GSplatMaterial();
+      this.geometry = new GSplatGeometry(this._batchSize);
+      this.materials = [this.gsplatMaterial];
+      this.instanceCount = 0;
+    }
+    /**
+     * 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, data) {
+      if (index < 0 || index >= this.totalCount) {
+        throw new Error(`Index ${index} out of range [0, ${this.totalCount})`);
+      }
+      const wasSet = this._splatSetFlags[index];
+      this._positions[index * 3 + 0] = data.position[0];
+      this._positions[index * 3 + 1] = data.position[1];
+      this._positions[index * 3 + 2] = data.position[2];
+      const SH_C0 = 0.28209479177387814;
+      let r = 0.5, g = 0.5, b = 0.5;
+      if (data.sh && data.sh.coeffs && data.sh.coeffs.length >= 3) {
+        r = 0.5 + data.sh.coeffs[0] * SH_C0;
+        g = 0.5 + data.sh.coeffs[1] * SH_C0;
+        b = 0.5 + data.sh.coeffs[2] * SH_C0;
+      }
+      const a = data.opacity !== void 0 ? 1 / (1 + Math.exp(-data.opacity)) : 1;
+      const colorIdx = index * 4;
+      this._colorData[colorIdx + 0] = Math.max(0, Math.min(255, Math.floor(r * 255)));
+      this._colorData[colorIdx + 1] = Math.max(0, Math.min(255, Math.floor(g * 255)));
+      this._colorData[colorIdx + 2] = Math.max(0, Math.min(255, Math.floor(b * 255)));
+      this._colorData[colorIdx + 3] = Math.max(0, Math.min(255, Math.floor(a * 255)));
+      this.updateTransformData(index, data);
+      if (!wasSet) {
+        this._splatSetFlags[index] = true;
+        this._validCount++;
+        this.texParams[2] = this._validCount;
+        this._centersSent = false;
+      }
+      this._pendingUpdates.add(index);
+    }
+    /**
+     * Update transform data for a single splat
+     */
+    updateTransformData(index, data) {
+      const idx = index * 4;
+      const fb = new ArrayBuffer(4);
+      const f32 = new Float32Array(fb);
+      const u32 = new Uint32Array(fb);
+      const setFloatBits = (v) => {
+        f32[0] = v;
+        return u32[0];
+      };
+      const x = data.position[0];
+      const y = data.position[1];
+      const z = data.position[2];
+      this._transformAData[idx + 0] = setFloatBits(x);
+      this._transformAData[idx + 1] = setFloatBits(y);
+      this._transformAData[idx + 2] = setFloatBits(z);
+      let qx = 0, qy = 0, qz = 0, qw = 1;
+      if (data.rotation) {
+        qx = data.rotation[0];
+        qy = data.rotation[1];
+        qz = data.rotation[2];
+        qw = data.rotation[3];
+        const inv = 1 / Math.hypot(qx, qy, qz, qw);
+        qx *= inv;
+        qy *= inv;
+        qz *= inv;
+        qw *= inv;
+      }
+      let sx = 1, sy = 1, sz = 1;
+      if (data.scale) {
+        sx = Math.exp(data.scale[0]);
+        sy = Math.exp(data.scale[1]);
+        sz = Math.exp(data.scale[2]);
+      }
+      const x2 = qx + qx;
+      const y2 = qy + qy;
+      const z2 = qz + qz;
+      const xx = qx * x2;
+      const xy = qx * y2;
+      const xz = qx * z2;
+      const yy = qy * y2;
+      const yz = qy * z2;
+      const zz = qz * z2;
+      const wx = qw * x2;
+      const wy = qw * y2;
+      const wz = qw * z2;
+      const data0 = 1 - (yy + zz);
+      const data1 = xy + wz;
+      const data2 = xz - wy;
+      const data3 = xy - wz;
+      const data4 = 1 - (xx + zz);
+      const data5 = yz + wx;
+      const data6 = xz + wy;
+      const data7 = yz - wx;
+      const data8 = 1 - (xx + yy);
+      const r00 = data0 * sx;
+      const r01 = data1 * sx;
+      const r02 = data2 * sx;
+      const r10 = data3 * sy;
+      const r11 = data4 * sy;
+      const r12 = data5 * sy;
+      const r20 = data6 * sz;
+      const r21 = data7 * sz;
+      const r22 = data8 * sz;
+      const cAx = r00 * r00 + r10 * r10 + r20 * r20;
+      const cAy = r00 * r01 + r10 * r11 + r20 * r21;
+      const cAz = r00 * r02 + r10 * r12 + r20 * r22;
+      const cBx = r01 * r01 + r11 * r11 + r21 * r21;
+      const cBy = r01 * r02 + r11 * r12 + r21 * r22;
+      const cBz = r02 * r02 + r12 * r12 + r22 * r22;
+      const bidx = idx;
+      this._transformBData[bidx + 0] = cAx;
+      this._transformBData[bidx + 1] = cAy;
+      this._transformBData[bidx + 2] = cAz;
+      this._transformBData[bidx + 3] = cBz;
+      const hx = toHalfFloat(cBx) & 65535;
+      const hy = toHalfFloat(cBy) & 65535;
+      this._transformAData[idx + 3] = hx | hy << 16;
+    }
+    /**
+     * Flush pending updates to GPU
+     * Updates GPU textures with all pending changes
+     */
+    flushUpdates() {
+      if (this._pendingUpdates.size === 0) return;
+      const w = this.size.x | 0;
+      const h = this.size.y | 0;
+      this.splatColor.updateTexture(w, h, this._colorData);
+      this.transformA.updateTexture(w, h, this._transformAData);
+      this.transformB.updateTexture(w, h, this._transformBData, false);
+      this.updatePendingWorldPositions();
+      this._pendingUpdates.clear();
+    }
+    /**
+     * Set auto-flush threshold
+     * @param threshold Number of pending updates before auto-flush (default: 100)
+     */
+    setAutoFlushThreshold(threshold) {
+      this._autoFlushThreshold = Math.max(1, threshold);
+    }
+    /**
+     * Get current streaming statistics
+     */
+    getStreamingStats() {
+      return {
+        totalCount: this.totalCount,
+        validCount: this._validCount,
+        pendingUpdates: this._pendingUpdates.size,
+        progress: this.totalCount > 0 ? this._validCount / this.totalCount * 100 : 0
+      };
+    }
+    /**
+     * Update splat sorting before rendering
+     * Uses the same logic as GSplatRenderer for reliable sorting
+     */
+    onBeforeUpdate(view) {
+      if (this._validCount > 0 && view?.camera) {
+        if (view.camera.viewMatrix) {
+          this.scheduleOrder(view.camera.viewMatrix);
+        }
+      }
+    }
+    /**
+     * Update world space positions when transform changes
+     */
+    updateWorldPositions() {
+      if (!this._positions || this._validCount === 0) return;
+      const worldMatrix = this.object3D.transform.worldMatrix;
+      const localPos = this._positions;
+      const count = this._validCount;
+      const m = worldMatrix.rawData;
+      this.worldBoundBox.makeEmpty();
+      for (let i = 0; i < count; i++) {
+        if (!this._splatSetFlags[i]) continue;
+        const idx = i * 3;
+        const x = localPos[idx + 0];
+        const y = localPos[idx + 1];
+        const z = localPos[idx + 2];
+        this._worldPositions[idx + 0] = m[0] * x + m[4] * y + m[8] * z + m[12];
+        this._worldPositions[idx + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+        this._worldPositions[idx + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+        this.worldBoundBox.expandByPoint(new Vector3(this._worldPositions[idx + 0], this._worldPositions[idx + 1], this._worldPositions[idx + 2]));
+      }
+      this._centersSent = false;
+    }
+    updatePendingWorldPositions() {
+      if (!this._positions || this._validCount === 0) return;
+      const worldMatrix = this.object3D.transform.worldMatrix;
+      const localPos = this._positions;
+      this._validCount;
+      const m = worldMatrix.rawData;
+      const pendingUpdates = Array.from(this._pendingUpdates.values());
+      for (let i = 0; i < pendingUpdates.length; i++) {
+        const ii = pendingUpdates[i];
+        if (!this._splatSetFlags[ii]) continue;
+        const idx = ii * 3;
+        const x = localPos[idx + 0];
+        const y = localPos[idx + 1];
+        const z = localPos[idx + 2];
+        this._worldPositions[idx + 0] = m[0] * x + m[4] * y + m[8] * z + m[12];
+        this._worldPositions[idx + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+        this._worldPositions[idx + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+        this.worldBoundBox.expandByPoint(new Vector3(this._worldPositions[idx + 0], this._worldPositions[idx + 1], this._worldPositions[idx + 2]));
+      }
+      this._centersSent = false;
+    }
+    /**
+     * Schedule Web Worker-based sorting task
+     * Uses the same logic as GSplatRenderer for consistency
+     */
+    scheduleOrder(viewMatrix) {
+      if (this._validCount === 0) return;
+      const transformChanged = this.object3D.transform.localChange;
+      if (transformChanged || !this._worldPositions || this._worldPositions.length === 0) {
+        this.updateWorldPositions();
+      }
+      const r = viewMatrix.rawData;
+      const vx = r[2], vy = r[6], vz = r[10];
+      const px = -(r[0] * r[12] + r[1] * r[13] + r[2] * r[14]);
+      const py = -(r[4] * r[12] + r[5] * r[13] + r[6] * r[14]);
+      const pz = -(r[8] * r[12] + r[9] * r[13] + r[10] * r[14]);
+      const now = performance.now();
+      const deltaTime = (now - this._lastSentTime) / 1e3;
+      const posHash = Math.floor(px * 1e3) ^ Math.floor(py * 1e3) ^ Math.floor(pz * 1e3);
+      const dirHash = Math.floor(vx * 1e3) ^ Math.floor(vy * 1e3) ^ Math.floor(vz * 1e3);
+      const hash = posHash ^ dirHash;
+      if (hash === this._lastViewMatrixHash && !transformChanged && this._centersSent) {
+        return;
+      }
+      let effectiveThrottle = this._minIntervalMs;
+      if (this._adaptiveSorting && this._minIntervalMs > 0) {
+        const hashDelta = Math.abs(hash - this._lastViewMatrixHash);
+        const speed = hashDelta / Math.max(deltaTime, 1e-3);
+        if (speed < 1e3) {
+          effectiveThrottle = this._minIntervalMs;
+        } else if (speed < 1e4) {
+          effectiveThrottle = this._minIntervalMs * 0.5;
+        } else {
+          effectiveThrottle = this._minIntervalMs * 0.2;
+        }
+        this._lastCameraSpeed = speed;
+      }
+      if (now - this._lastSentTime < effectiveThrottle) {
+        return;
+      }
+      this._lastViewMatrixHash = hash;
+      this._lastSentTime = now;
+      if (!this._sortWorker) {
+        this._sortWorker = this.createSortWorker();
+        this._sortWorker.onmessage = (ev) => {
+          const newOrder = ev.data.order;
+          const oldOrder = this._orderData.buffer;
+          this._sortWorker.postMessage({
+            order: oldOrder
+          }, [oldOrder]);
+          const indices = new Uint32Array(newOrder);
+          const total = this.size.x * this.size.y;
+          const validCount = Math.min(this._validCount, indices.length);
+          if (!this._orderData || this._orderData.length !== total) {
+            this._orderData = new Uint32Array(total);
+          }
+          this._orderData.set(indices.subarray(0, validCount), 0);
+          if (validCount < total) {
+            const lastIndex = this._validCount > 0 ? this._validCount - 1 : 0;
+            this._orderData.fill(lastIndex, validCount, total);
+          }
+          this.splatOrder.updateTexture(this.size.x, this.size.y, this._orderData);
+          const valid = Math.max(0, Math.min(this._validCount, ev.data.count | 0));
+          this.texParams[2] = valid;
+          this.texParams[0] = valid;
+          this._updateTexParams();
+          const newInstanceCount = Math.ceil(valid / this._batchSize);
+          this.instanceCount = newInstanceCount;
+        };
+        const centers = new Float32Array(this._validCount * 3);
+        const worldPos = this._worldPositions || this._positions;
+        let centerIdx = 0;
+        for (let i = 0; i < this._validCount; i++) {
+          if (this._splatSetFlags[i]) {
+            const srcIdx = i * 3;
+            centers[centerIdx * 3 + 0] = worldPos[srcIdx + 0];
+            centers[centerIdx * 3 + 1] = worldPos[srcIdx + 1];
+            centers[centerIdx * 3 + 2] = worldPos[srcIdx + 2];
+            centerIdx++;
+          }
+        }
+        const orderBuffer = new Uint32Array(this.totalCount);
+        for (let i = 0; i < this.totalCount; i++) {
+          orderBuffer[i] = i < this._validCount ? i : this._validCount > 0 ? this._validCount - 1 : 0;
+        }
+        this._sortWorker.postMessage({
+          order: orderBuffer.buffer,
+          centers: centers.buffer
+        }, [orderBuffer.buffer, centers.buffer]);
+        this._centersSent = true;
+      }
+      if (!this._centersSent && this._sortWorker) {
+        const centers = new Float32Array(this._validCount * 3);
+        const worldPos = this._worldPositions || this._positions;
+        let centerIdx = 0;
+        for (let i = 0; i < this._validCount; i++) {
+          if (this._splatSetFlags[i]) {
+            const srcIdx = i * 3;
+            centers[centerIdx * 3 + 0] = worldPos[srcIdx + 0];
+            centers[centerIdx * 3 + 1] = worldPos[srcIdx + 1];
+            centers[centerIdx * 3 + 2] = worldPos[srcIdx + 2];
+            centerIdx++;
+          }
+        }
+        this._sortWorker.postMessage({
+          type: "centers",
+          centers: centers.buffer
+        }, [centers.buffer]);
+        this._centersSent = true;
+      }
+      this._sortWorker.postMessage({
+        cameraPosition: { x: px, y: py, z: pz },
+        cameraDirection: { x: -vx, y: -vy, z: -vz }
+      });
+    }
+    /**
+     * Create Web Worker for sorting
+     * Uses the exact same logic as GSplatRenderer for consistency
+     */
+    createSortWorker() {
+      function SortWorker() {
+        const compareBits = 16;
+        const bucketCount = 2 ** compareBits + 1;
+        let order;
+        let centers;
+        let cameraPosition;
+        let cameraDirection;
+        let forceUpdate = false;
+        const lastCameraPosition = { x: 0, y: 0, z: 0 };
+        const lastCameraDirection = { x: 0, y: 0, z: 0 };
+        const boundMin = { x: 0, y: 0, z: 0 };
+        const boundMax = { x: 0, y: 0, z: 0 };
+        let distances;
+        let countBuffer;
+        const binarySearch = (m, n, compare_fn) => {
+          while (m <= n) {
+            const k = n + m >> 1;
+            const cmp = compare_fn(k);
+            if (cmp > 0) {
+              m = k + 1;
+            } else if (cmp < 0) {
+              n = k - 1;
+            } else {
+              return k;
+            }
+          }
+          return ~m;
+        };
+        const update = () => {
+          if (!order || !centers || !cameraPosition || !cameraDirection) return;
+          const px = cameraPosition.x;
+          const py = cameraPosition.y;
+          const pz = cameraPosition.z;
+          const dx = cameraDirection.x;
+          const dy = cameraDirection.y;
+          const dz = cameraDirection.z;
+          const epsilon = 1e-3;
+          if (!forceUpdate && Math.abs(px - lastCameraPosition.x) < epsilon && Math.abs(py - lastCameraPosition.y) < epsilon && Math.abs(pz - lastCameraPosition.z) < epsilon && Math.abs(dx - lastCameraDirection.x) < epsilon && Math.abs(dy - lastCameraDirection.y) < epsilon && Math.abs(dz - lastCameraDirection.z) < epsilon) {
+            return;
+          }
+          forceUpdate = false;
+          lastCameraPosition.x = px;
+          lastCameraPosition.y = py;
+          lastCameraPosition.z = pz;
+          lastCameraDirection.x = dx;
+          lastCameraDirection.y = dy;
+          lastCameraDirection.z = dz;
+          const numVertices = centers.length / 3;
+          if (distances?.length !== numVertices) {
+            distances = new Uint32Array(numVertices);
+          }
+          let minDist;
+          let maxDist;
+          for (let i = 0; i < 8; ++i) {
+            const x = (i & 1 ? boundMin.x : boundMax.x) - px;
+            const y = (i & 2 ? boundMin.y : boundMax.y) - py;
+            const z = (i & 4 ? boundMin.z : boundMax.z) - pz;
+            const d = x * dx + y * dy + z * dz;
+            if (i === 0) {
+              minDist = maxDist = d;
+            } else {
+              minDist = Math.min(minDist, d);
+              maxDist = Math.max(maxDist, d);
+            }
+          }
+          if (!countBuffer) {
+            countBuffer = new Uint32Array(bucketCount);
+          } else {
+            countBuffer.fill(0);
+          }
+          const range = maxDist - minDist;
+          const divider = range < 1e-6 ? 0 : 1 / range * 2 ** compareBits;
+          for (let i = 0; i < numVertices; ++i) {
+            const istride = i * 3;
+            const x = centers[istride + 0] - px;
+            const y = centers[istride + 1] - py;
+            const z = centers[istride + 2] - pz;
+            const d = x * dx + y * dy + z * dz;
+            const sortKey = Math.floor((d - minDist) * divider);
+            distances[i] = sortKey;
+            countBuffer[sortKey]++;
+          }
+          for (let i = 1; i < bucketCount; i++) {
+            countBuffer[i] += countBuffer[i - 1];
+          }
+          for (let i = 0; i < numVertices; i++) {
+            const distance = distances[i];
+            const destIndex = --countBuffer[distance];
+            order[destIndex] = i;
+          }
+          const dist = (i) => distances[order[i]] / divider + minDist;
+          const findZero = () => {
+            const result = binarySearch(0, numVertices - 1, (i) => -dist(i));
+            return Math.min(numVertices, Math.abs(result));
+          };
+          const count = dist(numVertices - 1) >= 0 ? findZero() : numVertices;
+          self.postMessage({
+            order: order.buffer,
+            count
+          }, [order.buffer]);
+          order = null;
+        };
+        self.onmessage = (message) => {
+          if (message.data.order) {
+            order = new Uint32Array(message.data.order);
+          }
+          if (message.data.centers) {
+            centers = new Float32Array(message.data.centers);
+            boundMin.x = boundMax.x = centers[0];
+            boundMin.y = boundMax.y = centers[1];
+            boundMin.z = boundMax.z = centers[2];
+            const numVertices = centers.length / 3;
+            for (let i = 1; i < numVertices; ++i) {
+              const x = centers[i * 3 + 0];
+              const y = centers[i * 3 + 1];
+              const z = centers[i * 3 + 2];
+              boundMin.x = Math.min(boundMin.x, x);
+              boundMin.y = Math.min(boundMin.y, y);
+              boundMin.z = Math.min(boundMin.z, z);
+              boundMax.x = Math.max(boundMax.x, x);
+              boundMax.y = Math.max(boundMax.y, y);
+              boundMax.z = Math.max(boundMax.z, z);
+            }
+            forceUpdate = true;
+          }
+          if (message.data.cameraPosition) cameraPosition = message.data.cameraPosition;
+          if (message.data.cameraDirection) cameraDirection = message.data.cameraDirection;
+          update();
+        };
+      }
+      const code = `(${SortWorker.toString()})()`;
+      const blob = new Blob([code], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
+      return new Worker(url);
+    }
+    /**
+     * Set visibility boost factor
+     */
+    setVisBoost(v) {
+      this.texParams[3] = Math.max(0, v);
+    }
+    setCount(c) {
+      this.texParams[0] = Math.max(0, c);
+    }
+    _updateTexParams() {
+      this.gsplatMaterial.setTexParams(this.texParams);
+    }
+    /**
+     * Set sort throttle interval (milliseconds)
+     */
+    setSortThrottle(ms) {
+      this._minIntervalMs = Math.max(0, ms | 0);
+    }
+    /**
+     * Enable/disable adaptive sorting
+     */
+    setAdaptiveSorting(enabled) {
+      this._adaptiveSorting = enabled;
+    }
+    /**
+     * Set pixel coverage culling thresholds
+     */
+    setPixelCulling(minPixels, maxPixels = 0, maxPixelCullDistance = 0) {
+      this._minPixelCoverage = Math.max(0, minPixels);
+      this._maxPixelCoverage = Math.max(0, maxPixels);
+      this._maxPixelCullDistance = Math.max(0, maxPixelCullDistance);
+    }
+    /**
+     * Get current pixel culling settings
+     */
+    getPixelCullingStats() {
+      return {
+        minPixels: this._minPixelCoverage,
+        maxPixels: this._maxPixelCoverage,
+        maxPixelCullDistance: this._maxPixelCullDistance,
+        maxEnabled: this._maxPixelCoverage > 0,
+        distanceEnabled: this._maxPixelCullDistance > 0
+      };
+    }
+    /**
+     * Get batching statistics
+     */
+    getBatchingStats() {
+      return {
+        enabled: true,
+        batchSize: this._batchSize,
+        instanceCount: this.instanceCount,
+        splatCount: this._validCount,
+        reduction: this._validCount > 0 ? (1 - this.instanceCount / this._validCount) * 100 : 0
+      };
+    }
+    /**
+     * Calculate texture size for given splat count
+     */
+    evalTextureSize(count) {
+      let w = Math.ceil(Math.sqrt(count));
+      const align = 64;
+      w = Math.ceil(w / align) * align;
+      const h = Math.ceil(count / w);
+      return new Vector2(w, h);
+    }
+    /**
+     * Update node before rendering
+     */
+    nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+      if (this._pendingUpdates.size > 0 && this._frameCount >= 60) {
+        this.flushUpdates();
+      }
+      if (this._frameCount >= 60 && this._pendingUpdates.size === 0) {
+        this._frameCount = 0;
+      }
+      this._frameCount++;
+      const worldMatrix = this.object3D.transform.worldMatrix;
+      this.gsplatMaterial.setTransformMatrix(worldMatrix);
+      const currentParams = `${this._minPixelCoverage},${this._maxPixelCoverage},${this._maxPixelCullDistance},${this._batchSize}`;
+      if (currentParams !== this._lastPixelCullParams) {
+        this.gsplatMaterial.setPixelCulling(this._minPixelCoverage, this._maxPixelCoverage, this._maxPixelCullDistance, this._batchSize);
+        this._lastPixelCullParams = currentParams;
+      }
+      if (!this._texturesInitialized) {
+        this.gsplatMaterial.setSplatTextures(
+          this.splatColor,
+          this.transformA,
+          this.transformB,
+          this.texParams,
+          this.splatOrder
+        );
+        this._texturesInitialized = true;
+      }
+      super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
+    }
+    /**
+     * Render pass
+     */
+    renderPass(view, passType, renderContext) {
+      const encoder = renderContext.encoder;
+      for (let mat of this.materials) {
+        const passes = mat.getPass(passType);
+        if (!passes || passes.length === 0) continue;
+        for (const pass of passes) {
+          if (!pass.pipeline) continue;
+          pass.apply(this.geometry, renderContext.rendererPassState || renderContext);
+          GPUContext.bindPipeline(encoder, pass);
+          GPUContext.bindGeometryBuffer(encoder, this.geometry);
+          const subGeometry = this.geometry.subGeometries[0];
+          const lodInfo = subGeometry.lodLevels[0];
+          if (this.instanceCount > 0) {
+            GPUContext.drawIndexed(
+              encoder,
+              lodInfo.indexCount,
+              this.instanceCount,
+              lodInfo.indexStart,
+              0,
+              0
+            );
+          } else {
+            GPUContext.drawIndexed(
+              encoder,
+              lodInfo.indexCount,
+              1,
+              lodInfo.indexStart,
+              0,
+              0
+            );
+          }
+        }
+      }
+    }
+    /**
+     * Clean up resources
+     */
+    destroy(force) {
+      if (this._sortWorker) {
+        this._sortWorker.terminate();
+        this._sortWorker = null;
+      }
+      if (this.splatColor) {
+        this.splatColor.destroy(force);
+        this.splatColor = null;
+      }
+      if (this.transformA) {
+        this.transformA.destroy(force);
+        this.transformA = null;
+      }
+      if (this.transformB) {
+        this.transformB.destroy(force);
+        this.transformB = null;
+      }
+      if (this.splatOrder) {
+        this.splatOrder.destroy(force);
+        this.splatOrder = null;
+      }
+      this._positions = null;
+      this._worldPositions = null;
+      this._orderData = null;
+      this._colorData = null;
+      this._transformAData = null;
+      this._transformBData = null;
+      this.texParams = null;
+      this._splatSetFlags = null;
+      this._pendingUpdates.clear();
+      super.destroy(force);
+    }
+  };
+  exports.GSplatStreamRenderer = __decorateClass$7([
+    RegisterComponent(exports.GSplatStreamRenderer, "GSplatStreamRenderer")
+  ], exports.GSplatStreamRenderer);
+
   class Probe extends exports.Object3D {
     index = 0;
     drawCallFrame = -1;
@@ -59830,6 +60595,127 @@ fn frag(){
     }
   }
 
+  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
+     */
+    async loadStream(url, parserClass, loaderFunctions, userData) {
+      if (parserClass.format !== ParserFormat.BIN) {
+        throw new Error("StreamLoader only supports BIN format parsers");
+      }
+      return new Promise(async (succ, fail) => {
+        let aborted = false;
+        let reader = null;
+        let abortController = null;
+        const cancel = () => {
+          aborted = true;
+          if (reader) {
+            reader.cancel().catch(() => {
+            });
+            reader.releaseLock();
+          }
+          if (abortController) {
+            abortController.abort();
+          }
+          if (parser && typeof parser.cancel === "function") {
+            parser.cancel();
+          }
+        };
+        let parser = null;
+        try {
+          this.baseUrl = url.substring(0, url.lastIndexOf("/") + 1);
+          this.initUrl = url;
+          abortController = new AbortController();
+          const response = await fetch(url, {
+            headers: loaderFunctions?.headers,
+            signal: abortController.signal
+          });
+          if (!response.ok) {
+            throw new Error(`Request rejected with status ${response.status}`);
+          }
+          reader = response.body.getReader();
+          const contentLength = +response.headers.get("Content-Length") || 0;
+          parser = new parserClass();
+          parser.userData = userData;
+          parser.baseUrl = this.baseUrl;
+          parser.initUrl = url;
+          parser.loaderFunctions = loaderFunctions;
+          if (typeof parser.initStream !== "function") {
+            throw new Error(`Parser ${parserClass.name} does not support streaming. Implement initStream() method.`);
+          }
+          let parserResolved = false;
+          await parser.initStream(contentLength, () => {
+            if (!parserResolved && !aborted && parser && parser.verification()) {
+              parserResolved = true;
+              succ({ parser, cancel });
+            }
+          });
+          let receivedLength = 0;
+          while (!aborted) {
+            const { done, value } = await reader.read();
+            if (done || aborted) {
+              if (!aborted) {
+                if (typeof parser.finalizeStream === "function") {
+                  await parser.finalizeStream();
+                }
+                if (!parserResolved && parser) {
+                  if (parser.verification()) {
+                    parserResolved = true;
+                    succ({ parser, cancel });
+                  } else {
+                    throw new Error("Parser verification failed");
+                  }
+                }
+              }
+              break;
+            }
+            if (aborted) break;
+            receivedLength += value.length;
+            if (contentLength > 0 && loaderFunctions?.onProgress && !aborted) {
+              loaderFunctions.onProgress.call(
+                this,
+                receivedLength,
+                contentLength,
+                url,
+                parser
+              );
+            }
+            if (!aborted && typeof parser.processChunk === "function") {
+              await parser.processChunk(value, receivedLength, contentLength);
+            }
+            if (!parserResolved && !aborted && parser && parser.verification()) {
+              parserResolved = true;
+              succ({ parser, cancel });
+            }
+          }
+          if (!aborted && loaderFunctions?.onComplete) {
+            loaderFunctions.onComplete.call(this, url);
+          }
+        } catch (e) {
+          if (aborted) {
+            return;
+          }
+          if (loaderFunctions?.onError) {
+            loaderFunctions.onError(e);
+          }
+          fail(e);
+        } finally {
+          if (reader && !aborted) {
+            try {
+              reader.releaseLock();
+            } catch {
+            }
+          }
+        }
+      });
+    }
+  }
+
   function computeAABBFromPositions(position) {
     const min = [Infinity, Infinity, Infinity];
     const max = [-Infinity, -Infinity, -Infinity];
@@ -61048,6 +61934,314 @@ fn frag(){
     };
   }
 
+  class PlyStreamParser {
+    _header = null;
+    _headerBuffer = new Uint8Array(4096);
+    _headerLength = 0;
+    _headerParsed = false;
+    // Data parsing state
+    _dataBuffer = null;
+    _dataOffset = 0;
+    _processedVertices = 0;
+    _vertexStride = 0;
+    _propOffsets = [];
+    _properties = [];
+    // Callbacks
+    _onHeaderParsed = null;
+    _onSplatParsed = null;
+    _batchSize = 1e3;
+    _cancelled = false;
+    constructor(onHeaderParsed, onSplatParsed, batchSize = 1e3) {
+      this._onHeaderParsed = onHeaderParsed;
+      this._onSplatParsed = onSplatParsed;
+      this._batchSize = batchSize;
+    }
+    /**
+     * Process incoming data chunk
+     */
+    processChunk(chunk) {
+      if (this._cancelled) return;
+      if (!this._headerParsed) {
+        this._processHeaderChunk(chunk);
+      } else {
+        this._processDataChunk(chunk);
+      }
+    }
+    /**
+     * Cancel parsing
+     * Stops processing new chunks
+     */
+    cancel() {
+      this._cancelled = true;
+    }
+    /**
+     * Check if parsing is cancelled
+     */
+    isCancelled() {
+      return this._cancelled;
+    }
+    /**
+     * Process header chunk
+     */
+    _processHeaderChunk(chunk) {
+      const needed = this._headerLength + chunk.length;
+      if (needed > this._headerBuffer.length) {
+        const newBuffer = new Uint8Array(Math.max(needed, this._headerBuffer.length * 2));
+        newBuffer.set(this._headerBuffer.subarray(0, this._headerLength));
+        this._headerBuffer = newBuffer;
+      }
+      this._headerBuffer.set(chunk, this._headerLength);
+      this._headerLength += chunk.length;
+      const headerText = new TextDecoder("utf-8").decode(
+        this._headerBuffer.subarray(0, this._headerLength)
+      );
+      const headerEnd = headerText.indexOf("end_header\n");
+      if (headerEnd >= 0) {
+        const headerEndPos = headerEnd + "end_header\n".length;
+        const headerBuffer = this._headerBuffer.subarray(0, headerEndPos);
+        const headerArrayBuffer = headerBuffer.buffer.slice(headerBuffer.byteOffset, headerBuffer.byteOffset + headerBuffer.byteLength);
+        const header = this._parseHeader(headerArrayBuffer);
+        this._header = header;
+        this._headerParsed = true;
+        this._initializeDataParsing(header);
+        if (this._onHeaderParsed) {
+          this._onHeaderParsed(header);
+        }
+        const chunkStartInHeader = this._headerLength - chunk.length;
+        const remainingStartInChunk = headerEndPos - chunkStartInHeader;
+        if (remainingStartInChunk > 0 && remainingStartInChunk < chunk.length) {
+          const remainingChunk = chunk.subarray(remainingStartInChunk);
+          this._processDataChunk(remainingChunk);
+        } else if (remainingStartInChunk === 0) {
+          this._processDataChunk(chunk);
+        }
+      }
+    }
+    /**
+     * Parse PLY header from buffer
+     */
+    _parseHeader(buffer) {
+      const ascii = new TextDecoder("utf-8").decode(new Uint8Array(buffer));
+      const headerEnd = ascii.indexOf("end_header\n");
+      if (headerEnd < 0) {
+        throw new Error("PLY: Invalid PLY header");
+      }
+      const headerText = ascii.substring(0, headerEnd + "end_header\n".length);
+      const lines = headerText.split(/\r?\n/);
+      let format = "";
+      let vertexCount = 0;
+      let faceCount = 0;
+      const properties = [];
+      const faceProperties = [];
+      const textureFiles = [];
+      let inVertexElement = false;
+      let inFaceElement = false;
+      for (const line of lines) {
+        if (line.startsWith("format ")) {
+          format = line.split(/\s+/)[1];
+        } else if (line.startsWith("comment TextureFile ")) {
+          const texturePath = line.substring("comment TextureFile ".length).trim();
+          if (texturePath) {
+            textureFiles.push(texturePath);
+          }
+        } else if (line.startsWith("element ")) {
+          const toks = line.split(/\s+/);
+          inVertexElement = toks[1] === "vertex";
+          inFaceElement = toks[1] === "face";
+          if (inVertexElement) {
+            vertexCount = parseInt(toks[2]);
+            inFaceElement = false;
+          }
+          if (inFaceElement) {
+            faceCount = parseInt(toks[2]);
+            inVertexElement = false;
+          }
+        } else if (inVertexElement && line.startsWith("property ")) {
+          const toks = line.split(/\s+/);
+          const type = toks[1];
+          const name = toks[2];
+          properties.push({ name, type });
+        } else if (inFaceElement && line.startsWith("property ")) {
+          const toks = line.split(/\s+/);
+          if (toks[1] === "list") {
+            const countType = toks[2];
+            const itemType = toks[3];
+            const name = toks[4];
+            faceProperties.push({ name, type: `list ${countType} ${itemType}` });
+          } else {
+            const type = toks[1];
+            const name = toks[2];
+            faceProperties.push({ name, type });
+          }
+        }
+      }
+      if (format !== "binary_little_endian" && format !== "ascii") {
+        throw new Error(`PLY: Unsupported format: ${format}`);
+      }
+      let splatPropertyCount = 0;
+      let splatPropertyColorCount = 0;
+      for (const property of properties) {
+        if (splatProperties.includes(property.name)) {
+          splatPropertyCount++;
+        }
+        if (splatColorProperties.includes(property.name)) {
+          splatPropertyColorCount++;
+        }
+      }
+      let mode;
+      if (faceCount > 0) {
+        mode = PlyMode.Mesh;
+      } else if (splatPropertyCount === splatProperties.length && splatPropertyColorCount === 3) {
+        mode = PlyMode.Splat;
+      } else {
+        mode = PlyMode.PointCloud;
+      }
+      return {
+        format,
+        vertexCount,
+        faceCount,
+        properties,
+        faceProperties: faceProperties.length > 0 ? faceProperties : void 0,
+        textureFiles,
+        headerByteLength: headerText.length,
+        mode
+      };
+    }
+    /**
+     * Initialize data parsing structures
+     */
+    _initializeDataParsing(header) {
+      this._properties = header.properties;
+      this._propOffsets = [];
+      this._vertexStride = 0;
+      for (const p of this._properties) {
+        this._propOffsets.push(this._vertexStride);
+        this._vertexStride += byteSizeOfType(p.type);
+      }
+      const estimatedSize = header.vertexCount * this._vertexStride;
+      this._dataBuffer = new Uint8Array(Math.min(estimatedSize, 1024 * 1024 * 10));
+      this._dataOffset = 0;
+      this._processedVertices = 0;
+    }
+    /**
+     * Process data chunk
+     */
+    _processDataChunk(chunk) {
+      if (!this._header || !this._dataBuffer) return;
+      const needed = this._dataOffset + chunk.length;
+      if (needed > this._dataBuffer.length) {
+        const newSize = Math.max(needed, this._dataBuffer.length * 2);
+        const newBuffer = new Uint8Array(newSize);
+        newBuffer.set(this._dataBuffer);
+        this._dataBuffer = newBuffer;
+      }
+      this._dataBuffer.set(chunk, this._dataOffset);
+      this._dataOffset += chunk.length;
+      this._parseVertices();
+    }
+    /**
+     * Parse vertices from current data buffer
+     */
+    _parseVertices() {
+      if (!this._header || !this._dataBuffer) return;
+      const payload = new DataView(this._dataBuffer.buffer, this._dataBuffer.byteOffset, this._dataBuffer.byteLength);
+      const vertexCount = this._header.vertexCount;
+      const has = (n) => this._properties.find((p) => p.name === n) != null;
+      const propIndex = (n) => this._properties.findIndex((p) => p.name === n);
+      while (this._processedVertices < vertexCount && !this._cancelled) {
+        const v = this._processedVertices;
+        const vOffset = v * this._vertexStride;
+        if (vOffset + this._vertexStride > this._dataOffset) {
+          break;
+        }
+        if (this._cancelled) {
+          break;
+        }
+        const ix = propIndex("x");
+        const iy = propIndex("y");
+        const iz = propIndex("z");
+        if (ix < 0 || iy < 0 || iz < 0) {
+          throw new Error("PLY: Missing required x/y/z properties for vertex");
+        }
+        const splatData = {
+          position: [
+            readByType(payload, vOffset + this._propOffsets[ix], this._properties[ix].type),
+            readByType(payload, vOffset + this._propOffsets[iy], this._properties[iy].type),
+            readByType(payload, vOffset + this._propOffsets[iz], this._properties[iz].type)
+          ]
+        };
+        if (has("scale_0")) {
+          splatData.scale = [
+            readByType(payload, vOffset + this._propOffsets[propIndex("scale_0")], this._properties[propIndex("scale_0")].type),
+            readByType(payload, vOffset + this._propOffsets[propIndex("scale_1")], this._properties[propIndex("scale_1")].type),
+            readByType(payload, vOffset + this._propOffsets[propIndex("scale_2")], this._properties[propIndex("scale_2")].type)
+          ];
+        }
+        if (has("rot_0")) {
+          const w = readByType(payload, vOffset + this._propOffsets[propIndex("rot_0")], this._properties[propIndex("rot_0")].type);
+          const x = readByType(payload, vOffset + this._propOffsets[propIndex("rot_1")], this._properties[propIndex("rot_1")].type);
+          const y = readByType(payload, vOffset + this._propOffsets[propIndex("rot_2")], this._properties[propIndex("rot_2")].type);
+          const z = readByType(payload, vOffset + this._propOffsets[propIndex("rot_3")], this._properties[propIndex("rot_3")].type);
+          splatData.rotation = [x, y, z, w];
+        }
+        if (has("opacity")) {
+          splatData.opacity = readByType(payload, vOffset + this._propOffsets[propIndex("opacity")], this._properties[propIndex("opacity")].type);
+        }
+        const dcIdx = [propIndex("f_dc_0"), propIndex("f_dc_1"), propIndex("f_dc_2")];
+        if (dcIdx[0] >= 0 && dcIdx[1] >= 0 && dcIdx[2] >= 0) {
+          const restIndices = [];
+          for (let i = 0; i < this._properties.length; i++) {
+            if (this._properties[i].name.startsWith("f_rest_")) restIndices.push(i);
+          }
+          const coeffsPerColor = 1 + restIndices.length / 3;
+          const coeffs = new Float32Array(coeffsPerColor * 3);
+          coeffs[0] = readByType(payload, vOffset + this._propOffsets[dcIdx[0]], this._properties[dcIdx[0]].type);
+          coeffs[coeffsPerColor + 0] = readByType(payload, vOffset + this._propOffsets[dcIdx[1]], this._properties[dcIdx[1]].type);
+          coeffs[2 * coeffsPerColor + 0] = readByType(payload, vOffset + this._propOffsets[dcIdx[2]], this._properties[dcIdx[2]].type);
+          let rPtr = 1;
+          let gPtr = 1;
+          let bPtr = 1;
+          for (let i = 0; i < restIndices.length; i += 3) {
+            const ri = restIndices[i + 0];
+            const gi = restIndices[i + 1];
+            const bi = restIndices[i + 2];
+            coeffs[rPtr] = readByType(payload, vOffset + this._propOffsets[ri], this._properties[ri].type);
+            coeffs[coeffsPerColor + gPtr] = readByType(payload, vOffset + this._propOffsets[gi], this._properties[gi].type);
+            coeffs[2 * coeffsPerColor + bPtr] = readByType(payload, vOffset + this._propOffsets[bi], this._properties[bi].type);
+            rPtr++;
+            gPtr++;
+            bPtr++;
+          }
+          splatData.sh = {
+            order: Math.floor(Math.sqrt(coeffsPerColor)),
+            coeffs
+          };
+        }
+        if (this._onSplatParsed) {
+          this._onSplatParsed(splatData, v);
+        }
+        this._processedVertices++;
+        if (this._processedVertices % this._batchSize === 0) {
+          setTimeout(() => {
+            this._parseVertices();
+          }, 0);
+          return;
+        }
+      }
+    }
+    /**
+     * Get current parsing progress
+     */
+    getProgress() {
+      const total = this._header?.vertexCount || 0;
+      return {
+        processed: this._processedVertices,
+        total,
+        percentage: total > 0 ? this._processedVertices / total * 100 : 0
+      };
+    }
+  }
+
   class GaussianSplatParser extends ParserBase {
     static format = ParserFormat.BIN;
     async parseBuffer(buffer) {
@@ -61083,6 +62277,95 @@ fn frag(){
     }
   }
 
+  class StreamingGaussianSplatParser extends ParserBase {
+    static format = ParserFormat.BIN;
+    _streamParser = null;
+    _streamingRenderer = null;
+    _rendererObject = null;
+    _chunksPerBatch = 1e3;
+    // Number of splats to process per batch
+    _headerParsed = false;
+    _onHeaderParsed = null;
+    _cancelled = false;
+    /**
+     * Initialize streaming parser
+     * @param contentLength Total content length (if known)
+     * @param onHeaderParsed Optional callback when header is parsed (parser is ready)
+     */
+    async initStream(contentLength, onHeaderParsed) {
+      this._onHeaderParsed = onHeaderParsed || null;
+      this._rendererObject = new exports.Object3D();
+      this._rendererObject.name = "StreamingGaussianSplat";
+      this._streamingRenderer = this._rendererObject.addComponent(exports.GSplatStreamRenderer);
+      this._streamParser = new PlyStreamParser(
+        (header) => {
+          if (this._streamingRenderer) {
+            this._streamingRenderer.initCount(header.vertexCount);
+          }
+          if (this._rendererObject) {
+            this.data = this._rendererObject;
+          }
+          this._headerParsed = true;
+          if (this._onHeaderParsed) {
+            this._onHeaderParsed();
+          }
+        },
+        (splatData, index) => {
+          if (this._streamingRenderer) {
+            this._streamingRenderer.setSplatData(index, splatData);
+          }
+        },
+        this._chunksPerBatch
+      );
+    }
+    /**
+     * Process incoming data chunk
+     * @param chunk Data chunk
+     * @param receivedLength Total bytes received so far
+     * @param contentLength Total content length (if known)
+     */
+    async processChunk(chunk, receivedLength, contentLength) {
+      if (this._cancelled || !this._streamParser) return;
+      this._streamParser.processChunk(chunk);
+    }
+    /**
+     * Cancel streaming loading
+     * Stops processing new chunks and cleans up resources
+     */
+    cancel() {
+      this._cancelled = true;
+      if (this._streamParser) {
+        this._streamParser.cancel();
+      }
+    }
+    /**
+     * Check if loading is cancelled
+     */
+    isCancelled() {
+      return this._cancelled;
+    }
+    /**
+     * Finalize streaming parsing
+     */
+    async finalizeStream() {
+      if (this._rendererObject) {
+        this.data = this._rendererObject;
+      }
+    }
+    /**
+     * Get parsing progress
+     */
+    getProgress() {
+      if (this._streamParser) {
+        return this._streamParser.getProgress();
+      }
+      return { processed: 0, total: 0, percentage: 0 };
+    }
+    verification() {
+      return this._headerParsed && !!this.data && !!this._streamingRenderer;
+    }
+  }
+
   var GeoType = /* @__PURE__ */ ((GeoType2) => {
     GeoType2["Point"] = "Point";
     GeoType2["LineString"] = "LineString";
@@ -72110,6 +73393,7 @@ fn frag(){
   exports.PlaneGeometry = PlaneGeometry;
   exports.PlyMode = PlyMode;
   exports.PlyParser = PlyParser;
+  exports.PlyStreamParser = PlyStreamParser;
   exports.PointClassification = PointClassification;
   exports.PointCloudGeometry = PointCloudGeometry;
   exports.PointCloudMaterial = PointCloudMaterial;
@@ -72279,6 +73563,8 @@ fn frag(){
   exports.StandShader = StandShader;
   exports.StatementNode = StatementNode;
   exports.StorageGPUBuffer = StorageGPUBuffer;
+  exports.StreamLoader = StreamLoader;
+  exports.StreamingGaussianSplatParser = StreamingGaussianSplatParser;
   exports.StringUtil = StringUtil;
   exports.Struct = Struct;
   exports.StructStorageGPUBuffer = StructStorageGPUBuffer;