@rings-webgpu/core 1.0.46 → 1.0.48

package/dist/rings.umd.max.js

@@ -24312,75 +24312,44 @@ struct InstanceData {
   }
 
   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;
@@ -24390,14 +24359,7 @@ struct InstanceData {
         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();
@@ -24432,11 +24394,7 @@ struct InstanceData {
         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();
@@ -24825,7 +24783,8 @@ struct InstanceData {
       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);
@@ -24899,10 +24858,10 @@ struct InstanceData {
         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;
@@ -42374,7 +42333,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.45";
+  const version = "1.0.48";
 
   class Engine3D {
     /**
@@ -54637,7 +54596,7 @@ fn frag(){
     _transformAData;
     // RGBA32U: count * 4
     _transformBData;
-    // RGBA16F: count * 4
+    // RGBA16F: count * 4 (Float16 format)
     _orderData;
     // R32U: size.x * size.y
     _positions;
@@ -54695,7 +54654,8 @@ fn frag(){
       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;
@@ -54845,10 +54805,10 @@ fn frag(){
       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;
@@ -62207,6 +62167,11 @@ fn frag(){
     _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;
@@ -62229,6 +62194,14 @@ fn frag(){
      */
     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
@@ -62397,21 +62370,36 @@ fn frag(){
     }
     /**
      * 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");
@@ -62477,12 +62465,47 @@ fn frag(){
           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);
       }
     }
     /**
@@ -71936,14 +71959,19 @@ fn frag(){
         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,
@@ -71951,10 +71979,14 @@ fn frag(){
         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);

package/dist/types/loader/parser/ply/PlyStreamParser.d.ts

@@ -21,6 +21,9 @@ export declare class PlyStreamParser {
     private _onSplatParsed;
     private _batchSize;
     private _cancelled;
+    private _parseTimeoutId;
+    private _verticesPerChunk;
+    private _useIdleCallback;
     constructor(onHeaderParsed: (header: PlyHeader) => void, onSplatParsed: (splatData: SplatData, index: number) => void, batchSize?: number);
     /**
      * Process incoming data chunk
@@ -53,8 +56,17 @@ export declare class PlyStreamParser {
     private _processDataChunk;
     /**
      * Parse vertices from current data buffer
+     * Entry point - checks if async processing is already scheduled
      */
     private _parseVertices;
+    /**
+     * Parse a chunk of vertices with time and count limits
+     */
+    private _parseVerticesChunk;
+    /**
+     * Schedule next chunk of vertex processing
+     */
+    private _scheduleNextChunk;
     /**
      * Get current parsing progress
      */

package/dist/types/textures/Float16ArrayTexture.d.ts

@@ -6,25 +6,24 @@ import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
  */
 export declare class Float16ArrayTexture extends Texture {
     uint16Array: Uint16Array;
-    floatArray: number[];
     private _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: number, height: number, numbers?: number[], mipmap?: boolean): this;
+    create(width: number, height: number, data?: Uint16Array | null, mipmap?: boolean): this;
     /**
      * 更新纹理内容
      * @param width 纹理宽度
      * @param height 纹理高度
-     * @param numbers 像素数据数组
+     * @param data Float16 数据数组（Uint16Array），每个元素是一个 Float16 值
      * @param mipmap 是否生成Mipmap
      * @param startRow 起始行（部分更新）
      * @param rowCount 更新的行数（部分更新）
      */
-    updateTexture(width: number, height: number, numbers: number[], mipmap?: boolean, startRow?: number, rowCount?: number): void;
+    updateTexture(width: number, height: number, data: Uint16Array, mipmap?: boolean, startRow?: number, rowCount?: number): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rings-webgpu/core",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {