@rings-webgpu/core 1.0.38 → 1.0.40

package/dist/rings.es.max.js

@@ -24081,10 +24081,44 @@ class Uint8ArrayTexture extends Texture {
     }
     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({
@@ -24140,9 +24174,28 @@ class Uint32ArrayTexture extends Texture {
     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,
@@ -24189,30 +24242,37 @@ class R32UintTexture extends Texture {
   }
 }
 
-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;
@@ -24241,8 +24301,10 @@ class Float16ArrayTexture extends Texture {
    * @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;
@@ -24255,22 +24317,70 @@ class Float16ArrayTexture extends Texture {
     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
       },
       {
@@ -24293,6 +24403,30 @@ class Float16ArrayTexture extends Texture {
   }
 }
 
+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;
@@ -42151,7 +42285,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.36";
+const version = "1.0.39";
 
 class Engine3D {
   /**
@@ -54401,6 +54535,7 @@ let GSplatStreamRenderer = class extends RenderNode {
   transformB;
   texParams;
   // [numSplats, texWidth, validCount, visBoost]
+  _texParamDirty = true;
   splatOrder;
   // Material and geometry
   gsplatMaterial;
@@ -54542,7 +54677,6 @@ let GSplatStreamRenderer = class extends RenderNode {
     if (!wasSet) {
       this._splatSetFlags[index] = true;
       this._validCount++;
-      this.texParams[2] = this._validCount;
     }
     this._pendingUpdates.add(index);
   }
@@ -54630,14 +54764,32 @@ let GSplatStreamRenderer = class extends RenderNode {
   /**
    * 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();
   }
@@ -54663,13 +54815,13 @@ let GSplatStreamRenderer = class extends RenderNode {
    * 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
    */
@@ -54743,8 +54895,7 @@ let GSplatStreamRenderer = class extends RenderNode {
         }
         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;
@@ -54950,12 +55101,17 @@ let GSplatStreamRenderer = class extends RenderNode {
    */
   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)
@@ -55015,6 +55171,11 @@ let GSplatStreamRenderer = class extends RenderNode {
    * 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();
     }
@@ -55022,6 +55183,7 @@ let GSplatStreamRenderer = class extends RenderNode {
       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}`;
@@ -65755,11 +65917,11 @@ function toggleTiles(tile, renderer) {
       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;
       }
     }
@@ -66132,6 +66294,8 @@ class TilesRenderer {
   _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
@@ -66250,6 +66414,8 @@ class TilesRenderer {
     _usedSet.clear();
     this.updateCameraInfo();
     this._checkDelayedHideTiles();
+    this._checkDelayedActiveTiles();
+    this._checkDelayedVisibleTiles();
     markUsedTiles(root, this);
     markUsedSetLeaves(root, this);
     markVisibleTiles(root, this);
@@ -66683,7 +66849,6 @@ class TilesRenderer {
     }
     if (scene) {
       tile.cached.scene = scene;
-      tile.loadingState = LOADED;
       const bytesUsed = this._estimateBytesUsed(scene);
       this._bytesUsed.set(scene, bytesUsed);
       this.lruCache.setMemoryUsage(tile, bytesUsed);
@@ -66701,10 +66866,21 @@ class TilesRenderer {
         });
       }
       {
-        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++;
@@ -66720,33 +66896,46 @@ class TilesRenderer {
   /**
    * 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;
       }
     }
   }
@@ -66758,35 +66947,67 @@ class TilesRenderer {
       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);
+      }
     }
   }
   /**