@rings-webgpu/core 1.0.38 → 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 {
     /**
@@ -54408,6 +54542,7 @@ fn frag(){
     transformB;
     texParams;
     // [numSplats, texWidth, validCount, visBoost]
+    _texParamDirty = true;
     splatOrder;
     // Material and geometry
     gsplatMaterial;
@@ -54549,7 +54684,6 @@ fn frag(){
       if (!wasSet) {
         this._splatSetFlags[index] = true;
         this._validCount++;
-        this.texParams[2] = this._validCount;
       }
       this._pendingUpdates.add(index);
     }
@@ -54637,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();
     }
@@ -54670,13 +54822,13 @@ 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
      */
@@ -54750,8 +54902,7 @@ 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;
@@ -54957,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)
@@ -55022,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();
       }
@@ -55029,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}`;

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

@@ -35,6 +35,7 @@ export declare class GSplatStreamRenderer extends RenderNode {
     transformA: Uint32ArrayTexture;
     transformB: Float16ArrayTexture;
     texParams: Float32Array;
+    private _texParamDirty;
     splatOrder: R32UintTexture;
     gsplatMaterial: GSplatMaterial;
     private _colorData;
@@ -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.38",
+  "version": "1.0.39",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {