@rings-webgpu/core 1.0.38 → 1.0.40

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.39";
 
   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 && this._frameCount >= 60) {
+        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}`;
@@ -65762,11 +65924,11 @@ fn frag(){
         const wasVisible = tile.__wasSetVisible;
         const wasActive = tile.__wasSetActive;
         if (wasActive !== setActive) {
-          renderer.setTileActive(tile, setActive);
+          renderer.setTileDelayedActive(tile, setActive);
           tile.__wasSetActive = setActive;
         }
         if (wasVisible !== setVisible) {
-          renderer.setTileVisible(tile, setVisible);
+          renderer.setTileDelayedVisible(tile, setVisible);
           tile.__wasSetVisible = setVisible;
         }
       }
@@ -66139,6 +66301,8 @@ fn frag(){
     _activeTiles = /* @__PURE__ */ new Set();
     // Tiles that should be hidden but are delayed due to children loading
     _delayedHideTiles = /* @__PURE__ */ new Set();
+    _delayedVisibleTiles = /* @__PURE__ */ new Set();
+    _delayedActiveTiles = /* @__PURE__ */ new Set();
     // Rings-specific: Scene group
     group;
     // Rings-specific: Camera management
@@ -66257,6 +66421,8 @@ fn frag(){
       _usedSet.clear();
       this.updateCameraInfo();
       this._checkDelayedHideTiles();
+      this._checkDelayedActiveTiles();
+      this._checkDelayedVisibleTiles();
       markUsedTiles(root, this);
       markUsedSetLeaves(root, this);
       markVisibleTiles(root, this);
@@ -66690,7 +66856,6 @@ fn frag(){
       }
       if (scene) {
         tile.cached.scene = scene;
-        tile.loadingState = LOADED;
         const bytesUsed = this._estimateBytesUsed(scene);
         this._bytesUsed.set(scene, bytesUsed);
         this.lruCache.setMemoryUsage(tile, bytesUsed);
@@ -66708,10 +66873,21 @@ fn frag(){
           });
         }
         {
-          this.setTileActive(tile, true);
+          this.setTileImmediateActive(tile);
           tile.active = true;
+          tile.__wasSetActive = true;
           this.stats.active++;
         }
+        {
+          this.setTileImmediateVisible(tile);
+          tile.visible = true;
+          tile.__wasSetVisible = true;
+          this.stats.visible++;
+        }
+        tile.loadingState = LOADED;
+        tile.usedLastFrame = true;
+        markVisibleTiles(tile, this);
+        toggleTiles(tile, this);
       } else {
         tile.loadingState = FAILED;
         this.stats.failed++;
@@ -66727,33 +66903,46 @@ fn frag(){
     /**
      * Set tile active state
      */
-    setTileActive(tile, active) {
+    setTileDelayedActive(tile, active) {
       if (active) {
         this._activeTiles.add(tile);
         if (this._delayedHideTiles.has(tile)) {
           this._delayedHideTiles.delete(tile);
         }
+        if (!this._delayedActiveTiles.has(tile)) {
+          this._delayedActiveTiles.add(tile);
+        }
       } else {
         this._activeTiles.delete(tile);
+        if (!this._delayedHideTiles.has(tile)) {
+          this._delayedHideTiles.add(tile);
+        }
+        if (this._delayedActiveTiles.has(tile)) {
+          this._delayedActiveTiles.delete(tile);
+        }
       }
-      const scene = tile.cached.scene;
-      if (!scene) {
-        return;
-      }
-      if (active) {
-        if (!this.group.entityChildren.includes(scene)) {
-          if (scene.parent) {
-            scene.parent.object3D.removeChild(scene);
+    }
+    setTileImmediateActive(tile) {
+      if (tile.hasRenderableContent) {
+        const scene = tile.cached.scene;
+        if (scene) {
+          if (!this.group.entityChildren.includes(scene)) {
+            if (scene.parent) {
+              scene.parent.object3D.removeChild(scene);
+            }
+            this.group.addChild(scene);
+          }
+          if (tile.cached.worldTransform) {
+            this._applyWorldTransform(scene.transform, tile.cached.worldTransform);
           }
-          this.group.addChild(scene);
-        }
-        if (tile.cached.worldTransform) {
-          this._applyWorldTransform(scene.transform, tile.cached.worldTransform);
         }
-        scene.transform.enable = true;
-      } else {
-        if (!this._delayedHideTiles.has(tile)) {
-          this._delayedHideTiles.add(tile);
+      }
+    }
+    setTileImmediateVisible(tile) {
+      if (tile.hasRenderableContent) {
+        const scene = tile.cached.scene;
+        if (scene) {
+          scene.transform.enable = true;
         }
       }
     }
@@ -66765,35 +66954,67 @@ fn frag(){
         return;
       }
       for (const tile of this._delayedHideTiles) {
-        this._delayedHideTiles.delete(tile);
         const scene = tile.cached.scene;
         if (scene) {
           scene.transform.enable = false;
+          this._delayedHideTiles.delete(tile);
+        }
+      }
+    }
+    _checkDelayedActiveTiles() {
+      for (const tile of this._delayedActiveTiles) {
+        if (tile.hasRenderableContent) {
+          const scene = tile.cached.scene;
+          if (scene) {
+            if (!this.group.entityChildren.includes(scene)) {
+              if (scene.parent) {
+                scene.parent.object3D.removeChild(scene);
+              }
+              this.group.addChild(scene);
+            }
+            if (tile.cached.worldTransform) {
+              this._applyWorldTransform(scene.transform, tile.cached.worldTransform);
+            }
+            this._delayedActiveTiles.delete(tile);
+          }
+        } else {
+          this._delayedActiveTiles.delete(tile);
+        }
+      }
+    }
+    _checkDelayedVisibleTiles() {
+      for (const tile of this._delayedVisibleTiles) {
+        if (tile.hasRenderableContent) {
+          const scene = tile.cached.scene;
+          if (scene) {
+            scene.transform.enable = true;
+            this._delayedVisibleTiles.delete(tile);
+          }
+        } else {
+          this._delayedVisibleTiles.delete(tile);
         }
       }
     }
     /**
      * Set tile visibility
      */
-    setTileVisible(tile, visible) {
+    setTileDelayedVisible(tile, visible) {
       if (visible) {
         this._visibleTiles.add(tile);
         if (this._delayedHideTiles.has(tile)) {
           this._delayedHideTiles.delete(tile);
         }
+        if (!this._delayedVisibleTiles.has(tile)) {
+          this._delayedVisibleTiles.add(tile);
+        }
       } else {
         this._visibleTiles.delete(tile);
-      }
-      const scene = tile.cached.scene;
-      if (!scene) {
-        return;
-      }
-      if (visible) {
-        scene.transform.enable = true;
-      } else {
         if (!this._delayedHideTiles.has(tile)) {
           this._delayedHideTiles.add(tile);
         }
+        if (this._delayedVisibleTiles.has(tile)) {
+          this._delayedVisibleTiles.delete(tile);
+        }
       }
     }
     /**

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/loader/parser/tileRenderer/TilesRenderer.d.ts

@@ -124,6 +124,8 @@ export declare class TilesRenderer {
     protected _root: Tile | null;
     protected _activeTiles: Set<Tile>;
     protected _delayedHideTiles: Set<Tile>;
+    protected _delayedVisibleTiles: Set<Tile>;
+    protected _delayedActiveTiles: Set<Tile>;
     readonly group: Object3D;
     cameras: Camera3D[];
     private _cameraMap;
@@ -206,15 +208,19 @@ export declare class TilesRenderer {
     /**
      * Set tile active state
      */
-    setTileActive(tile: Tile, active: boolean): void;
+    setTileDelayedActive(tile: Tile, active: boolean): void;
+    setTileImmediateActive(tile: Tile): void;
+    setTileImmediateVisible(tile: Tile): void;
     /**
      * Check and process delayed hide tiles when a child finishes loading
      */
     private _checkDelayedHideTiles;
+    private _checkDelayedActiveTiles;
+    private _checkDelayedVisibleTiles;
     /**
      * Set tile visibility
      */
-    setTileVisible(tile: Tile, visible: boolean): void;
+    setTileDelayedVisible(tile: Tile, visible: boolean): void;
     /**
      * Add tile to download queue
      */

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.40",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {