@rings-webgpu/core 1.0.47 → 1.0.49

package/dist/rings.umd.max.js

@@ -42333,7 +42333,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.46";
+  const version = "1.0.49";
 
   class Engine3D {
     /**
@@ -62167,6 +62167,13 @@ fn frag(){
     _onSplatParsed = null;
     _batchSize = 1e3;
     _cancelled = false;
+    // Async processing state
+    _parseTimeoutId = null;
+    static sVerticesPerChunk = 1e7;
+    // Number of vertices to process per chunk
+    static sMaxProcessingTime = 5;
+    // Maximum processing time per chunk (ms) to avoid blocking
+    _useIdleCallback = typeof requestIdleCallback !== "undefined";
     constructor(onHeaderParsed, onSplatParsed, batchSize = 1e3) {
       this._onHeaderParsed = onHeaderParsed;
       this._onSplatParsed = onSplatParsed;
@@ -62189,6 +62196,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
@@ -62357,21 +62372,35 @@ 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();
+      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");
@@ -62437,12 +62466,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 >= PlyStreamParser.sVerticesPerChunk) {
+          const elapsed = performance.now() - startTime;
+          if (elapsed > PlyStreamParser.sMaxProcessingTime) {
+            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);
       }
     }
     /**

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

@@ -21,6 +21,10 @@ export declare class PlyStreamParser {
     private _onSplatParsed;
     private _batchSize;
     private _cancelled;
+    private _parseTimeoutId;
+    static sVerticesPerChunk: number;
+    static sMaxProcessingTime: number;
+    private _useIdleCallback;
     constructor(onHeaderParsed: (header: PlyHeader) => void, onSplatParsed: (splatData: SplatData, index: number) => void, batchSize?: number);
     /**
      * Process incoming data chunk
@@ -53,8 +57,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/package.json

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