@rings-webgpu/core 1.0.47 → 1.0.48

package/dist/rings.es.max.js

@@ -42326,7 +42326,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.46";
+const version = "1.0.48";
 
 class Engine3D {
   /**
@@ -62160,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;
@@ -62182,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
@@ -62350,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");
@@ -62430,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);
     }
   }
   /**