@rings-webgpu/core 1.0.37 → 1.0.39

package/dist/rings.umd.max.js

@@ -24088,10 +24088,44 @@ struct InstanceData {
       }
       return this;
     }
-    updateTexture(width, height, data) {
+    updateTexture(width, height, data, startRow, rowCount) {
       let device = webGPUContext.device;
       const bytesPerRow = Math.ceil(width * 4 / 256) * 256;
       this.mipmapCount = Math.floor(Math.log2(width) );
+      if (startRow !== void 0 && rowCount !== void 0 && rowCount < height) {
+        const updateHeight = rowCount;
+        const updateOffset = startRow * width * 4;
+        const updateData = data.subarray(updateOffset, updateOffset + updateHeight * width * 4);
+        const neededSize = updateData.byteLength;
+        if (!this._dataBuffer || this._dataBuffer.size < neededSize) {
+          this._dataBuffer && this._dataBuffer.destroy();
+          this._dataBuffer = device.createBuffer({
+            size: neededSize,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+          });
+        }
+        device.queue.writeBuffer(this._dataBuffer, 0, updateData.buffer, updateData.byteOffset, updateData.byteLength);
+        const commandEncoder2 = GPUContext.beginCommandEncoder();
+        commandEncoder2.copyBufferToTexture(
+          {
+            buffer: this._dataBuffer,
+            bytesPerRow,
+            offset: 0
+          },
+          {
+            texture: this.getGPUTexture(),
+            origin: [0, startRow, 0]
+            // Start at row startRow
+          },
+          {
+            width,
+            height: updateHeight,
+            depthOrArrayLayers: 1
+          }
+        );
+        GPUContext.endCommandEncoder(commandEncoder2);
+        return;
+      }
       this._dataBuffer && this._dataBuffer.destroy();
       this._dataBuffer = null;
       const textureDataBuffer = this._dataBuffer = device.createBuffer({
@@ -24147,9 +24181,28 @@ struct InstanceData {
       this.gpuSampler = device.createSampler({});
       return this;
     }
-    updateTexture(width, height, data) {
+    updateTexture(width, height, data, startRow, rowCount) {
       let device = webGPUContext.device;
       const bytesPerRow = width * 4 * 4;
+      if (startRow !== void 0 && rowCount !== void 0 && rowCount < height) {
+        const updateHeight = rowCount;
+        const updateOffset = startRow * width * 4;
+        const updateData = data.subarray(updateOffset, updateOffset + updateHeight * width * 4);
+        device.queue.writeTexture(
+          {
+            texture: this.getGPUTexture(),
+            origin: [0, startRow, 0]
+            // Start at row startRow
+          },
+          updateData.buffer,
+          {
+            bytesPerRow,
+            offset: updateData.byteOffset
+          },
+          { width, height: updateHeight, depthOrArrayLayers: 1 }
+        );
+        return;
+      }
       device.queue.writeTexture(
         { texture: this.getGPUTexture() },
         data.buffer,
@@ -24196,30 +24249,37 @@ struct InstanceData {
     }
   }
 
-  const _floatView = new Float32Array(1);
-  const _int32View = new Int32Array(_floatView.buffer);
-  let toHalfFloat = function(val) {
-    _floatView[0] = val;
-    const x = _int32View[0];
-    let bits = x >> 16 & 32768;
-    let m = x >> 12 & 2047;
-    const e = x >> 23 & 255;
-    if (e < 103) return bits;
-    if (e > 142) {
-      bits |= 31744;
-      bits |= (e == 255 ? 1 : 0) && x & 8388607;
-      return bits;
-    }
-    if (e < 114) {
-      m |= 2048;
-      bits |= (m >> 114 - e) + (m >> 113 - e & 1);
-      return bits;
+  const _floatView$1 = new Float32Array(1);
+  const _int32View$1 = new Int32Array(_floatView$1.buffer);
+  function batchConvertToHalfFloat(src, dst, offset, length) {
+    for (let i = 0; i < length; i++) {
+      const val = src[offset + i];
+      _floatView$1[0] = val;
+      const x = _int32View$1[0];
+      let bits = x >> 16 & 32768;
+      let m = x >> 12 & 2047;
+      const e = x >> 23 & 255;
+      if (e < 103) {
+        dst[offset + i] = bits;
+        continue;
+      }
+      if (e > 142) {
+        bits |= 31744;
+        bits |= (e == 255 ? 1 : 0) && x & 8388607;
+        dst[offset + i] = bits;
+        continue;
+      }
+      if (e < 114) {
+        m |= 2048;
+        bits |= (m >> 114 - e) + (m >> 113 - e & 1);
+        dst[offset + i] = bits;
+        continue;
+      }
+      bits |= e - 112 << 10 | m >> 1;
+      bits += m & 1;
+      dst[offset + i] = bits;
     }
-    bits |= e - 112 << 10 | m >> 1;
-    bits += m & 1;
-    return bits;
-  };
-
+  }
   class Float16ArrayTexture extends Texture {
     uint16Array;
     floatArray;
@@ -24248,8 +24308,10 @@ struct InstanceData {
      * @param height 纹理高度
      * @param numbers 像素数据数组
      * @param mipmap 是否生成Mipmap
+     * @param startRow 起始行（部分更新）
+     * @param rowCount 更新的行数（部分更新）
      */
-    updateTexture(width, height, numbers, mipmap = true) {
+    updateTexture(width, height, numbers, mipmap = true, startRow, rowCount) {
       if (width != this.width || height != this.height) {
         this._dataBuffer && this._dataBuffer.destroy();
         this._dataBuffer = null;
@@ -24262,22 +24324,70 @@ struct InstanceData {
       this.format = GPUTextureFormat.rgba16float;
       this.mipmapCount = Math.floor(mipmap ? Math.log2(width) : 1);
       this.createTextureDescriptor(width, height, this.mipmapCount, this.format);
+      if (startRow !== void 0 && rowCount !== void 0 && rowCount < height) {
+        const updateHeight = rowCount;
+        const updateOffset = startRow * width * 4;
+        const updateLength = updateHeight * width * 4;
+        if (!this.uint16Array || this.uint16Array.length < updateOffset + updateLength) {
+          if (!this.uint16Array || this.uint16Array.length < numbers.length) {
+            this.uint16Array = new Uint16Array(numbers.length);
+          }
+        }
+        const uint16Array2 = this.uint16Array;
+        batchConvertToHalfFloat(numbers, uint16Array2, updateOffset, updateLength);
+        const updateData = uint16Array2.subarray(updateOffset, updateOffset + updateLength);
+        const neededSize2 = updateData.byteLength;
+        if (!this._dataBuffer || this._dataBuffer.size < neededSize2) {
+          this._dataBuffer && this._dataBuffer.destroy();
+          this._dataBuffer = device.createBuffer({
+            size: neededSize2,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+          });
+        }
+        device.queue.writeBuffer(this._dataBuffer, 0, updateData.buffer, updateData.byteOffset, updateData.byteLength);
+        const commandEncoder2 = GPUContext.beginCommandEncoder();
+        commandEncoder2.copyBufferToTexture(
+          {
+            buffer: this._dataBuffer,
+            bytesPerRow,
+            offset: 0
+          },
+          {
+            texture: this.getGPUTexture(),
+            origin: [0, startRow, 0]
+            // Start at row startRow
+          },
+          {
+            width,
+            height: updateHeight,
+            depthOrArrayLayers: 1
+          }
+        );
+        if (!this.useMipmap) {
+          this.samplerBindingLayout.type = `filtering`;
+          this.textureBindingLayout.sampleType = `float`;
+        }
+        GPUContext.endCommandEncoder(commandEncoder2);
+        return;
+      }
       if (!this.uint16Array || this.uint16Array.length != numbers.length) {
         this.uint16Array = new Uint16Array(numbers.length);
       }
-      let uint16Array = this.uint16Array;
-      for (let i = 0, c = uint16Array.length; i < c; i++) {
-        uint16Array[i] = toHalfFloat(numbers[i]);
+      const uint16Array = this.uint16Array;
+      batchConvertToHalfFloat(numbers, uint16Array, 0, numbers.length);
+      const neededSize = uint16Array.byteLength;
+      if (!this._dataBuffer || this._dataBuffer.size < neededSize) {
+        this._dataBuffer && this._dataBuffer.destroy();
+        this._dataBuffer = device.createBuffer({
+          size: neededSize,
+          usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+        });
       }
-      const textureDataBuffer = this._dataBuffer = device.createBuffer({
-        size: uint16Array.byteLength,
-        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-      });
-      device.queue.writeBuffer(textureDataBuffer, 0, uint16Array);
+      device.queue.writeBuffer(this._dataBuffer, 0, uint16Array.buffer, uint16Array.byteOffset, uint16Array.byteLength);
       const commandEncoder = GPUContext.beginCommandEncoder();
       commandEncoder.copyBufferToTexture(
         {
-          buffer: textureDataBuffer,
+          buffer: this._dataBuffer,
           bytesPerRow
         },
         {
@@ -24300,6 +24410,30 @@ struct InstanceData {
     }
   }
 
+  const _floatView = new Float32Array(1);
+  const _int32View = new Int32Array(_floatView.buffer);
+  let toHalfFloat = function(val) {
+    _floatView[0] = val;
+    const x = _int32View[0];
+    let bits = x >> 16 & 32768;
+    let m = x >> 12 & 2047;
+    const e = x >> 23 & 255;
+    if (e < 103) return bits;
+    if (e > 142) {
+      bits |= 31744;
+      bits |= (e == 255 ? 1 : 0) && x & 8388607;
+      return bits;
+    }
+    if (e < 114) {
+      m |= 2048;
+      bits |= (m >> 114 - e) + (m >> 113 - e & 1);
+      return bits;
+    }
+    bits |= e - 112 << 10 | m >> 1;
+    bits += m & 1;
+    return bits;
+  };
+
   var __getOwnPropDesc$m = Object.getOwnPropertyDescriptor;
   var __decorateClass$m = (decorators, target, key, kind) => {
     var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$m(target, key) : target;
@@ -42158,7 +42292,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.36";
+  const version = "1.0.38";
 
   class Engine3D {
     /**
@@ -54367,13 +54501,48 @@ fn frag(){
     // Splat count and texture dimensions
     totalCount = 0;
     size = new Vector2();
-    worldBoundBox = new BoundingBox();
+    localBoundBox = new BoundingBox();
+    // public worldBoundBox: BoundingBox = new BoundingBox();
+    get worldBoundBox() {
+      const boundBox = new BoundingBox();
+      boundBox.makeEmpty();
+      const worldMatrix = this.object3D.transform.worldMatrix;
+      const m = worldMatrix.rawData;
+      const localMin = this.localBoundBox.min;
+      const localMax = this.localBoundBox.max;
+      const corners = [
+        [localMin.x, localMin.y, localMin.z],
+        // 0: min, min, min
+        [localMax.x, localMin.y, localMin.z],
+        // 1: max, min, min
+        [localMin.x, localMax.y, localMin.z],
+        // 2: min, max, min
+        [localMax.x, localMax.y, localMin.z],
+        // 3: max, max, min
+        [localMin.x, localMin.y, localMax.z],
+        // 4: min, min, max
+        [localMax.x, localMin.y, localMax.z],
+        // 5: max, min, max
+        [localMin.x, localMax.y, localMax.z],
+        // 6: min, max, max
+        [localMax.x, localMax.y, localMax.z]
+        // 7: max, max, max
+      ];
+      for (const [x, y, z] of corners) {
+        const wx = m[0] * x + m[4] * y + m[8] * z + m[12];
+        const wy = m[1] * x + m[5] * y + m[9] * z + m[13];
+        const wz = m[2] * x + m[6] * y + m[10] * z + m[14];
+        boundBox.expandByPoint(new Vector3(wx, wy, wz));
+      }
+      return boundBox;
+    }
     // GPU textures for splat data
     splatColor;
     transformA;
     transformB;
     texParams;
     // [numSplats, texWidth, validCount, visBoost]
+    _texParamDirty = true;
     splatOrder;
     // Material and geometry
     gsplatMaterial;
@@ -54388,8 +54557,7 @@ fn frag(){
     // R32U: size.x * size.y
     _positions;
     // xyz per splat (local space)
-    _worldPositions;
-    // xyz per splat (world space, cached)
+    // private _worldPositions: Float32Array; // xyz per splat (world space, cached)
     // Tracking which splats have been set
     _splatSetFlags;
     // Track which indices have data
@@ -54449,8 +54617,7 @@ fn frag(){
       }
       this._positions = new Float32Array(totalCount * 3);
       this._positions.fill(0);
-      this._worldPositions = new Float32Array(totalCount * 3);
-      this._worldPositions.fill(0);
+      this.localBoundBox.makeEmpty();
       this._splatSetFlags = new Array(totalCount).fill(false);
       this._validCount = 0;
       this.texParams = new Float32Array([this._validCount, this.size.x, 0, 1]);
@@ -54499,6 +54666,7 @@ fn frag(){
       this._positions[index * 3 + 0] = data.position[0];
       this._positions[index * 3 + 1] = data.position[1];
       this._positions[index * 3 + 2] = data.position[2];
+      this.localBoundBox.expandByPoint(new Vector3(data.position[0], data.position[1], 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) {
@@ -54516,8 +54684,6 @@ fn frag(){
       if (!wasSet) {
         this._splatSetFlags[index] = true;
         this._validCount++;
-        this.texParams[2] = this._validCount;
-        this._centersSent = false;
       }
       this._pendingUpdates.add(index);
     }
@@ -54605,14 +54771,32 @@ fn frag(){
     /**
      * Flush pending updates to GPU
      * Updates GPU textures with all pending changes
+     * Uses partial updates when possible for better performance
      */
     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);
+      const pendingIndices = Array.from(this._pendingUpdates);
+      if (pendingIndices.length === 0) return;
+      let minRow = h;
+      let maxRow = 0;
+      for (const index of pendingIndices) {
+        const row = Math.floor(index / w);
+        if (row < minRow) minRow = row;
+        if (row > maxRow) maxRow = row;
+      }
+      const rowCount = maxRow - minRow + 1;
+      const updateRatio = rowCount / h;
+      if (updateRatio < 0.5 && rowCount < h) {
+        this.splatColor.updateTexture(w, h, this._colorData, minRow, rowCount);
+        this.transformA.updateTexture(w, h, this._transformAData, minRow, rowCount);
+        this.transformB.updateTexture(w, h, this._transformBData, false, minRow, rowCount);
+      } else {
+        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();
     }
@@ -54638,55 +54822,22 @@ fn frag(){
      * 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);
-        }
-      }
-    }
+    // public onBeforeUpdate(view?: View3D) {
+    //   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;
     }
     /**
@@ -54696,7 +54847,7 @@ fn frag(){
     scheduleOrder(viewMatrix) {
       if (this._validCount === 0) return;
       const transformChanged = this.object3D.transform.localChange;
-      if (transformChanged || !this._worldPositions || this._worldPositions.length === 0) {
+      if (transformChanged) {
         this.updateWorldPositions();
       }
       const r = viewMatrix.rawData;
@@ -54751,21 +54902,25 @@ fn frag(){
           }
           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.setCount(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;
+        const worldMatrix = this.object3D.transform.worldMatrix;
+        const localPos = this._positions;
+        const m = worldMatrix.rawData;
         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];
+            const x = localPos[srcIdx + 0];
+            const y = localPos[srcIdx + 1];
+            const z = localPos[srcIdx + 2];
+            centers[centerIdx * 3 + 0] = m[0] * x + m[4] * y + m[8] * z + m[12];
+            centers[centerIdx * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+            centers[centerIdx * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
             centerIdx++;
           }
         }
@@ -54781,14 +54936,19 @@ fn frag(){
       }
       if (!this._centersSent && this._sortWorker) {
         const centers = new Float32Array(this._validCount * 3);
-        const worldPos = this._worldPositions || this._positions;
         let centerIdx = 0;
+        const worldMatrix = this.object3D.transform.worldMatrix;
+        const localPos = this._positions;
+        const m = worldMatrix.rawData;
         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];
+            const x = localPos[srcIdx + 0];
+            const y = localPos[srcIdx + 1];
+            const z = localPos[srcIdx + 2];
+            centers[centerIdx * 3 + 0] = m[0] * x + m[4] * y + m[8] * z + m[12];
+            centers[centerIdx * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+            centers[centerIdx * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
             centerIdx++;
           }
         }
@@ -54948,12 +55108,17 @@ fn frag(){
      */
     setVisBoost(v) {
       this.texParams[3] = Math.max(0, v);
+      this._texParamDirty = true;
     }
     setCount(c) {
       this.texParams[0] = Math.max(0, c);
+      this._texParamDirty = true;
     }
     _updateTexParams() {
-      this.gsplatMaterial.setTexParams(this.texParams);
+      if (this._texParamDirty) {
+        this.gsplatMaterial.setTexParams(this.texParams);
+        this._texParamDirty = false;
+      }
     }
     /**
      * Set sort throttle interval (milliseconds)
@@ -55013,6 +55178,11 @@ fn frag(){
      * Update node before rendering
      */
     nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+      if (this._validCount > 0 && view?.camera) {
+        if (view.camera.viewMatrix) {
+          this.scheduleOrder(view.camera.viewMatrix);
+        }
+      }
       if (this._pendingUpdates.size > 0 && this._frameCount >= 60) {
         this.flushUpdates();
       }
@@ -55020,6 +55190,7 @@ fn frag(){
         this._frameCount = 0;
       }
       this._frameCount++;
+      this._updateTexParams();
       const worldMatrix = this.object3D.transform.worldMatrix;
       this.gsplatMaterial.setTransformMatrix(worldMatrix);
       const currentParams = `${this._minPixelCoverage},${this._maxPixelCoverage},${this._maxPixelCullDistance},${this._batchSize}`;
@@ -55101,7 +55272,6 @@ fn frag(){
         this.splatOrder = null;
       }
       this._positions = null;
-      this._worldPositions = null;
       this._orderData = null;
       this._colorData = null;
       this._transformAData = null;

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

@@ -29,11 +29,13 @@ export type SplatData = {
 export declare class GSplatStreamRenderer extends RenderNode {
     totalCount: number;
     size: Vector2;
-    worldBoundBox: BoundingBox;
+    localBoundBox: BoundingBox;
+    get worldBoundBox(): BoundingBox;
     splatColor: Uint8ArrayTexture;
     transformA: Uint32ArrayTexture;
     transformB: Float16ArrayTexture;
     texParams: Float32Array;
+    private _texParamDirty;
     splatOrder: R32UintTexture;
     gsplatMaterial: GSplatMaterial;
     private _colorData;
@@ -41,7 +43,6 @@ export declare class GSplatStreamRenderer extends RenderNode {
     private _transformBData;
     private _orderData;
     private _positions;
-    private _worldPositions;
     private _splatSetFlags;
     private _validCount;
     private _sortWorker;
@@ -83,6 +84,7 @@ export declare class GSplatStreamRenderer extends RenderNode {
     /**
      * Flush pending updates to GPU
      * Updates GPU textures with all pending changes
+     * Uses partial updates when possible for better performance
      */
     flushUpdates(): void;
     /**
@@ -103,7 +105,6 @@ export declare class GSplatStreamRenderer extends RenderNode {
      * 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
      */

package/dist/types/textures/Float16ArrayTexture.d.ts

@@ -23,6 +23,8 @@ export declare class Float16ArrayTexture extends Texture {
      * @param height 纹理高度
      * @param numbers 像素数据数组
      * @param mipmap 是否生成Mipmap
+     * @param startRow 起始行（部分更新）
+     * @param rowCount 更新的行数（部分更新）
      */
-    updateTexture(width: number, height: number, numbers: number[], mipmap?: boolean): void;
+    updateTexture(width: number, height: number, numbers: number[], mipmap?: boolean, startRow?: number, rowCount?: number): void;
 }

package/dist/types/textures/Uint32ArrayTexture.d.ts

@@ -7,5 +7,5 @@ import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
 export declare class Uint32ArrayTexture extends Texture {
     private _dataBuffer;
     create(width: number, height: number, data: Uint32Array): this;
-    updateTexture(width: number, height: number, data: Uint32Array): void;
+    updateTexture(width: number, height: number, data: Uint32Array, startRow?: number, rowCount?: number): void;
 }

package/dist/types/textures/Uint8ArrayTexture.d.ts

@@ -2,5 +2,5 @@ import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
 export declare class Uint8ArrayTexture extends Texture {
     private _dataBuffer;
     create(width: number, height: number, data: Uint8Array, useMipmap?: boolean): this;
-    updateTexture(width: number, height: number, data: Uint8Array): void;
+    updateTexture(width: number, height: number, data: Uint8Array, startRow?: number, rowCount?: number): void;
 }

package/package.json

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