@rings-webgpu/core 1.0.37 → 1.0.39

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.38";
 
 class Engine3D {
   /**
@@ -54360,13 +54494,48 @@ let GSplatStreamRenderer = class extends RenderNode {
   // 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;
@@ -54381,8 +54550,7 @@ let GSplatStreamRenderer = class extends RenderNode {
   // 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
@@ -54442,8 +54610,7 @@ let GSplatStreamRenderer = class extends RenderNode {
     }
     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]);
@@ -54492,6 +54659,7 @@ let GSplatStreamRenderer = class extends RenderNode {
     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) {
@@ -54509,8 +54677,6 @@ let GSplatStreamRenderer = class extends RenderNode {
     if (!wasSet) {
       this._splatSetFlags[index] = true;
       this._validCount++;
-      this.texParams[2] = this._validCount;
-      this._centersSent = false;
     }
     this._pendingUpdates.add(index);
   }
@@ -54598,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();
   }
@@ -54631,55 +54815,22 @@ 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
    */
   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;
   }
   /**
@@ -54689,7 +54840,7 @@ let GSplatStreamRenderer = class extends RenderNode {
   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;
@@ -54744,21 +54895,25 @@ 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;
       };
       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++;
         }
       }
@@ -54774,14 +54929,19 @@ let GSplatStreamRenderer = class extends RenderNode {
     }
     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++;
         }
       }
@@ -54941,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)
@@ -55006,6 +55171,11 @@ let GSplatStreamRenderer = class extends RenderNode {
    * 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();
     }
@@ -55013,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}`;
@@ -55094,7 +55265,6 @@ let GSplatStreamRenderer = class extends RenderNode {
       this.splatOrder = null;
     }
     this._positions = null;
-    this._worldPositions = null;
     this._orderData = null;
     this._colorData = null;
     this._transformAData = null;