@rings-webgpu/core 1.0.46 → 1.0.48

package/dist/rings.es.max.js

@@ -24305,75 +24305,44 @@ class R32UintTexture extends Texture {
 }
 
 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;
-  }
-}
+new Int32Array(_floatView$1.buffer);
 class Float16ArrayTexture extends Texture {
   uint16Array;
-  floatArray;
   _dataBuffer;
   /**
-   * 使用数字数组填充纹理，格式为[红0, 绿0, 蓝0, 透明度0, 红1, 绿1, 蓝1, 透明度1...]
+   * 使用 Uint16Array 填充纹理（Float16 格式），格式为[红0, 绿0, 蓝0, 透明度0, 红1, 绿1, 蓝1, 透明度1...]
    * @param width 纹理宽度
    * @param height 纹理高度
-   * @param numbers 每个像素的颜色值数组
+   * @param data Float16 数据数组（Uint16Array），每个元素是一个 Float16 值
    * @param useMipmap 是否生成Mipmap
    * @returns 返回纹理实例
    */
-  create(width, height, numbers = null, mipmap = true) {
-    if (numbers == null) {
-      numbers = [];
-      for (let i = 0, c = width * height * 4; i < c; i++) {
-        numbers[i] = 0;
-      }
+  create(width, height, data = null, mipmap = true) {
+    if (data == null) {
+      const size = width * height * 4;
+      data = new Uint16Array(size);
+      data.fill(0);
     }
-    this.updateTexture(width, height, numbers, mipmap);
+    this.updateTexture(width, height, data, mipmap);
     return this;
   }
   /**
    * 更新纹理内容
    * @param width 纹理宽度
    * @param height 纹理高度
-   * @param numbers 像素数据数组
+   * @param data Float16 数据数组（Uint16Array），每个元素是一个 Float16 值
    * @param mipmap 是否生成Mipmap
    * @param startRow 起始行（部分更新）
    * @param rowCount 更新的行数（部分更新）
    */
-  updateTexture(width, height, numbers, mipmap = true, startRow, rowCount) {
+  updateTexture(width, height, data, mipmap = true, startRow, rowCount) {
     if (width != this.width || height != this.height) {
       this._dataBuffer && this._dataBuffer.destroy();
       this._dataBuffer = null;
       this.gpuTexture && this.gpuTexture.destroy();
       this.gpuTexture = null;
     }
-    this.floatArray = numbers;
+    this.uint16Array = data;
     let device = webGPUContext.device;
     const bytesPerRow = width * 4 * 2;
     this.format = GPUTextureFormat.rgba16float;
@@ -24383,14 +24352,7 @@ class Float16ArrayTexture extends Texture {
       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 updateData = data.subarray(updateOffset, updateOffset + updateLength);
       const neededSize2 = updateData.byteLength;
       if (!this._dataBuffer || this._dataBuffer.size < neededSize2) {
         this._dataBuffer && this._dataBuffer.destroy();
@@ -24425,11 +24387,7 @@ class Float16ArrayTexture extends Texture {
       GPUContext.endCommandEncoder(commandEncoder2);
       return;
     }
-    if (!this.uint16Array || this.uint16Array.length != numbers.length) {
-      this.uint16Array = new Uint16Array(numbers.length);
-    }
-    const uint16Array = this.uint16Array;
-    batchConvertToHalfFloat(numbers, uint16Array, 0, numbers.length);
+    const uint16Array = data;
     const neededSize = uint16Array.byteLength;
     if (!this._dataBuffer || this._dataBuffer.size < neededSize) {
       this._dataBuffer && this._dataBuffer.destroy();
@@ -24818,7 +24776,8 @@ let GSplatRenderer = class extends RenderNode {
     const h = this.size.y | 0;
     const count = asset.count;
     const tA = new Uint32Array(w * h * 4);
-    const tB = new Array(w * h * 4).fill(0);
+    const tB = new Uint16Array(w * h * 4);
+    tB.fill(0);
     const fb = new ArrayBuffer(4);
     const f32 = new Float32Array(fb);
     const u32 = new Uint32Array(fb);
@@ -24892,10 +24851,10 @@ let GSplatRenderer = class extends RenderNode {
       const cBy = r01 * r02 + r11 * r12 + r21 * r22;
       const cBz = r02 * r02 + r12 * r12 + r22 * r22;
       const bidx = idx;
-      tB[bidx + 0] = cAx;
-      tB[bidx + 1] = cAy;
-      tB[bidx + 2] = cAz;
-      tB[bidx + 3] = cBz;
+      tB[bidx + 0] = toHalfFloat(cAx) & 65535;
+      tB[bidx + 1] = toHalfFloat(cAy) & 65535;
+      tB[bidx + 2] = toHalfFloat(cAz) & 65535;
+      tB[bidx + 3] = toHalfFloat(cBz) & 65535;
       const hx = toHalfFloat(cBx) & 65535;
       const hy = toHalfFloat(cBy) & 65535;
       tA[idx + 3] = hx | hy << 16;
@@ -42367,7 +42326,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.45";
+const version = "1.0.48";
 
 class Engine3D {
   /**
@@ -54630,7 +54589,7 @@ let GSplatStreamRenderer = class extends RenderNode {
   _transformAData;
   // RGBA32U: count * 4
   _transformBData;
-  // RGBA16F: count * 4
+  // RGBA16F: count * 4 (Float16 format)
   _orderData;
   // R32U: size.x * size.y
   _positions;
@@ -54688,7 +54647,8 @@ let GSplatStreamRenderer = class extends RenderNode {
     this._colorData.fill(0);
     this._transformAData = new Uint32Array(total * 4);
     this._transformAData.fill(0);
-    this._transformBData = new Array(total * 4).fill(0);
+    this._transformBData = new Uint16Array(total * 4);
+    this._transformBData.fill(0);
     this._orderData = new Uint32Array(total);
     for (let i = 0; i < total; i++) {
       this._orderData[i] = i < totalCount ? i : totalCount > 0 ? totalCount - 1 : 0;
@@ -54838,10 +54798,10 @@ let GSplatStreamRenderer = class extends RenderNode {
     const cBy = r01 * r02 + r11 * r12 + r21 * r22;
     const cBz = r02 * r02 + r12 * r12 + r22 * r22;
     const bidx = idx;
-    this._transformBData[bidx + 0] = cAx;
-    this._transformBData[bidx + 1] = cAy;
-    this._transformBData[bidx + 2] = cAz;
-    this._transformBData[bidx + 3] = cBz;
+    this._transformBData[bidx + 0] = toHalfFloat(cAx) & 65535;
+    this._transformBData[bidx + 1] = toHalfFloat(cAy) & 65535;
+    this._transformBData[bidx + 2] = toHalfFloat(cAz) & 65535;
+    this._transformBData[bidx + 3] = toHalfFloat(cBz) & 65535;
     const hx = toHalfFloat(cBx) & 65535;
     const hy = toHalfFloat(cBy) & 65535;
     this._transformAData[idx + 3] = hx | hy << 16;
@@ -62200,6 +62160,11 @@ class PlyStreamParser {
   _onSplatParsed = null;
   _batchSize = 1e3;
   _cancelled = false;
+  // Async processing state
+  _parseTimeoutId = null;
+  _verticesPerChunk = 1e7;
+  // Number of vertices to process per chunk
+  _useIdleCallback = typeof requestIdleCallback !== "undefined";
   constructor(onHeaderParsed, onSplatParsed, batchSize = 1e3) {
     this._onHeaderParsed = onHeaderParsed;
     this._onSplatParsed = onSplatParsed;
@@ -62222,6 +62187,14 @@ class PlyStreamParser {
    */
   cancel() {
     this._cancelled = true;
+    if (this._parseTimeoutId !== null) {
+      if (this._useIdleCallback) {
+        cancelIdleCallback(this._parseTimeoutId);
+      } else {
+        clearTimeout(this._parseTimeoutId);
+      }
+      this._parseTimeoutId = null;
+    }
   }
   /**
    * Check if parsing is cancelled
@@ -62390,21 +62363,36 @@ class PlyStreamParser {
   }
   /**
    * Parse vertices from current data buffer
+   * Entry point - checks if async processing is already scheduled
    */
   _parseVertices() {
     if (!this._header || !this._dataBuffer) return;
+    if (this._parseTimeoutId !== null) {
+      return;
+    }
+    this._parseVerticesChunk();
+  }
+  /**
+   * Parse a chunk of vertices with time and count limits
+   */
+  _parseVerticesChunk() {
+    if (!this._header || !this._dataBuffer || this._cancelled) {
+      this._parseTimeoutId = null;
+      return;
+    }
     const payload = new DataView(this._dataBuffer.buffer, this._dataBuffer.byteOffset, this._dataBuffer.byteLength);
     const vertexCount = this._header.vertexCount;
     const has = (n) => this._properties.find((p) => p.name === n) != null;
     const propIndex = (n) => this._properties.findIndex((p) => p.name === n);
+    const startTime = performance.now();
+    const maxProcessingTime = 5;
+    let processedInThisChunk = 0;
     while (this._processedVertices < vertexCount && !this._cancelled) {
       const v = this._processedVertices;
       const vOffset = v * this._vertexStride;
       if (vOffset + this._vertexStride > this._dataOffset) {
-        break;
-      }
-      if (this._cancelled) {
-        break;
+        this._parseTimeoutId = null;
+        return;
       }
       const ix = propIndex("x");
       const iy = propIndex("y");
@@ -62470,12 +62458,47 @@ class PlyStreamParser {
         this._onSplatParsed(splatData, v);
       }
       this._processedVertices++;
+      processedInThisChunk++;
       if (this._processedVertices % this._batchSize === 0) {
-        setTimeout(() => {
-          this._parseVertices();
-        }, 0);
+        this._scheduleNextChunk();
         return;
       }
+      if (processedInThisChunk >= this._verticesPerChunk) {
+        const elapsed = performance.now() - startTime;
+        if (elapsed > maxProcessingTime) {
+          this._scheduleNextChunk();
+          return;
+        }
+        processedInThisChunk = 0;
+      }
+    }
+    this._parseTimeoutId = null;
+  }
+  /**
+   * Schedule next chunk of vertex processing
+   */
+  _scheduleNextChunk() {
+    if (this._cancelled) {
+      this._parseTimeoutId = null;
+      return;
+    }
+    if (this._useIdleCallback) {
+      this._parseTimeoutId = requestIdleCallback((deadline) => {
+        this._parseTimeoutId = null;
+        if (!this._cancelled && deadline.timeRemaining() > 0) {
+          this._parseVerticesChunk();
+        } else if (!this._cancelled) {
+          this._parseTimeoutId = setTimeout(() => {
+            this._parseTimeoutId = null;
+            this._parseVerticesChunk();
+          }, 0);
+        }
+      }, { timeout: 100 });
+    } else {
+      this._parseTimeoutId = setTimeout(() => {
+        this._parseTimeoutId = null;
+        this._parseVerticesChunk();
+      }, 0);
     }
   }
   /**
@@ -71929,14 +71952,19 @@ class SolidColorSky extends LDRTextureCube {
       this.color.b,
       this.color.a
     );
-    this._internalTexture.create(this._minSize, this._minSize, numbers, false);
+    const float16Data = new Uint16Array(numbers.length);
+    for (let i = 0; i < numbers.length; i++) {
+      float16Data[i] = toHalfFloat(numbers[i]) & 65535;
+    }
+    this._internalTexture.create(this._minSize, this._minSize, float16Data, false);
     this.createFromTexture(this._minSize, this._internalTexture);
     return this;
   }
   changeColor(color) {
     this._skyColor = color;
+    const numbers = [];
     Engine3D.res.fillColor(
-      this._internalTexture.floatArray,
+      numbers,
       this._minSize,
       this._minSize,
       this.color.r,
@@ -71944,10 +71972,14 @@ class SolidColorSky extends LDRTextureCube {
       this.color.b,
       this.color.a
     );
+    const float16Data = new Uint16Array(numbers.length);
+    for (let i = 0; i < numbers.length; i++) {
+      float16Data[i] = toHalfFloat(numbers[i]) & 65535;
+    }
     this._internalTexture.updateTexture(
       this._minSize,
       this._minSize,
-      this._internalTexture.floatArray,
+      float16Data,
       false
     );
     this._faceData.uploadTexture(0, this._internalTexture);