fl-web-component 2.0.18 → 2.0.19-beta.0

package/packages/utils/StreamLoader.js

@@ -159,7 +159,7 @@ export class StreamLoader {
 
   async parseStreamImmediate(reader, list, range, abortSignal = null, streamId = null) {
     const batchMeshes = [];
-    const batchPrimitives = [];
+    const batchPrimitiveGroups = [];
     const batchSize = this.batchSize;
     let batchStart = 0;
     const streamStats = {
@@ -168,8 +168,31 @@ export class StreamLoader {
       totalPrimitives: 0,
     };
 
-    const processStreamBatch = async (meshesToProcess, primitivesToProcess) => {
+    const flattenPrimitiveGroups = primitiveGroups => {
+      if (!primitiveGroups || primitiveGroups.length === 0) return [];
+      const primitivesToProcess = [];
+      const usedIds = new Set();
+
+      primitiveGroups.forEach(group => {
+        const primitives = Array.isArray(group) ? group : [group];
+        primitives.forEach(primitive => {
+          if (!primitive) return;
+          if (primitive.id == null) {
+            primitivesToProcess.push(primitive);
+            return;
+          }
+          if (usedIds.has(primitive.id)) return;
+          usedIds.add(primitive.id);
+          primitivesToProcess.push(primitive);
+        });
+      });
+
+      return primitivesToProcess;
+    };
+
+    const processStreamBatch = async (meshesToProcess, primitiveGroupsToProcess) => {
       if (!meshesToProcess || meshesToProcess.length === 0) return;
+      const primitivesToProcess = flattenPrimitiveGroups(primitiveGroupsToProcess);
       await this.processBatchData(meshesToProcess, primitivesToProcess, list, range, abortSignal);
       streamStats.totalBatches += 1;
       streamStats.totalMeshes += meshesToProcess.length;
@@ -225,7 +248,7 @@ export class StreamLoader {
             const flushed = await this.workerRequest('streamFlush', { streamId: localStreamId });
             if (flushed?.meshes?.length) {
               batchMeshes.push(...flushed.meshes);
-              batchPrimitives.push(...flushed.primitives);
+              batchPrimitiveGroups.push(...flushed.primitives);
             }
 
             while (batchMeshes.length - batchStart >= batchSize) {
@@ -234,9 +257,12 @@ export class StreamLoader {
               const interactionPromiseInBatch = ensureNotInteracting();
               if (interactionPromiseInBatch) await interactionPromiseInBatch;
               const meshesToProcess = batchMeshes.slice(batchStart, batchStart + batchSize);
-              const primitivesToProcess = batchPrimitives.slice(batchStart, batchStart + batchSize);
+              const primitiveGroupsToProcess = batchPrimitiveGroups.slice(
+                batchStart,
+                batchStart + batchSize
+              );
               batchStart += batchSize;
-              await processStreamBatch(meshesToProcess, primitivesToProcess);
+              await processStreamBatch(meshesToProcess, primitiveGroupsToProcess);
             }
 
             if (batchMeshes.length - batchStart > 0) {
@@ -245,9 +271,9 @@ export class StreamLoader {
               const interactionPromiseInBatch = ensureNotInteracting();
               if (interactionPromiseInBatch) await interactionPromiseInBatch;
               const meshesToProcess = batchMeshes.slice(batchStart);
-              const primitivesToProcess = batchPrimitives.slice(batchStart);
+              const primitiveGroupsToProcess = batchPrimitiveGroups.slice(batchStart);
               batchStart = batchMeshes.length;
-              await processStreamBatch(meshesToProcess, primitivesToProcess);
+              await processStreamBatch(meshesToProcess, primitiveGroupsToProcess);
             }
             break;
           }
@@ -266,7 +292,7 @@ export class StreamLoader {
 
           if (parsed?.meshes?.length) {
             batchMeshes.push(...parsed.meshes);
-            batchPrimitives.push(...parsed.primitives);
+            batchPrimitiveGroups.push(...parsed.primitives);
           }
 
           while (batchMeshes.length - batchStart >= batchSize) {
@@ -275,14 +301,17 @@ export class StreamLoader {
             const interactionPromiseInBatch = ensureNotInteracting();
             if (interactionPromiseInBatch) await interactionPromiseInBatch;
             const meshesToProcess = batchMeshes.slice(batchStart, batchStart + batchSize);
-            const primitivesToProcess = batchPrimitives.slice(batchStart, batchStart + batchSize);
+            const primitiveGroupsToProcess = batchPrimitiveGroups.slice(
+              batchStart,
+              batchStart + batchSize
+            );
             batchStart += batchSize;
-            await processStreamBatch(meshesToProcess, primitivesToProcess);
+            await processStreamBatch(meshesToProcess, primitiveGroupsToProcess);
           }
 
           if (batchStart >= batchSize * 4) {
             batchMeshes.splice(0, batchStart);
-            batchPrimitives.splice(0, batchStart);
+            batchPrimitiveGroups.splice(0, batchStart);
             batchStart = 0;
           }
         }
@@ -297,10 +326,127 @@ export class StreamLoader {
     const decoder = new TextDecoder('utf-8');
     let buffer = new Uint8Array();
 
-    const pendingPrimitives = new Map();
-    let expectingPrimitive = true;
+    let expectingMesh = true;
+    let pendingMesh = null;
+    let pendingPrimitiveIds = new Set();
+    let pendingPrimitiveGroups = [];
+    let pendingMatchedPrimitiveIds = new Set();
     let isFullProps = true;
 
+    const normalizeMesh = mesh => {
+      this._applyPrefixId(mesh, 'id');
+      const meshList = Array.isArray(mesh) ? mesh : [mesh];
+      meshList.forEach(item => {
+        if (!item) return;
+        if (!Array.isArray(item.primitives)) {
+          item.primitives = [];
+        }
+        this._applyPrefixId(item.primitives, 'prmid', item.documentId);
+      });
+      return mesh;
+    };
+
+    const collectMeshPrimitiveIds = mesh => {
+      const ids = [];
+      const meshList = Array.isArray(mesh) ? mesh : [mesh];
+      meshList.forEach(item => {
+        if (!item || !Array.isArray(item.primitives)) return;
+        item.primitives.forEach(primitive => {
+          if (primitive && primitive.prmid != null) {
+            ids.push(primitive.prmid);
+          }
+        });
+      });
+      return ids;
+    };
+
+    const isValidStreamMesh = mesh => {
+      const meshList = Array.isArray(mesh) ? mesh : [mesh];
+      if (meshList.length === 0) return false;
+      return meshList.every(
+        item => item && typeof item === 'object' && Array.isArray(item.primitives)
+      );
+    };
+
+    const tryParseMeshFromBuffer = () => {
+      if (buffer.length < 4) {
+        return { status: 'incomplete' };
+      }
+
+      const length = new DataView(buffer.buffer, buffer.byteOffset).getUint32(0, false);
+      if (length <= 0 || length > 10 * 1024 * 1024) {
+        return { status: 'invalid' };
+      }
+
+      const totalLen = 4 + length;
+      if (buffer.length < totalLen) {
+        return { status: 'incomplete' };
+      }
+
+      try {
+        const data = buffer.slice(4, totalLen);
+        const parsedMesh = JSON.parse(decoder.decode(data));
+        if (!isValidStreamMesh(parsedMesh)) {
+          return { status: 'invalid' };
+        }
+        const mesh = normalizeMesh(parsedMesh);
+        return { status: 'success', mesh, totalLen };
+      } catch (e) {
+        return { status: 'invalid' };
+      }
+    };
+
+    const parsePrimitiveFromBuffer = () => {
+      const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const primitiveResult = this.parsePrimitive(dataView, buffer, 0, isFullProps);
+      const primitiveData = primitiveResult.primitive;
+
+      this._applyPrefixId(primitiveData, 'id');
+      this._applyPrefixId(primitiveData, 'material');
+
+      if (isFullProps) {
+        const { position, normal, posindex, nolindex, indices } =
+          this.parsePrimitiveData(primitiveData);
+        const formatted = this.formatPrimitiveData({ position, normal, posindex, nolindex });
+
+        delete primitiveData.nolindex;
+        delete primitiveData.posindex;
+
+        primitiveData.position = formatted.position;
+        primitiveData.normal = formatted.normal;
+        primitiveData.indices = indices;
+      }
+
+      return {
+        primitive: primitiveData,
+        consumedBytes: primitiveResult.offset,
+      };
+    };
+
+    const commitPendingMesh = async () => {
+      if (!pendingMesh) return;
+
+      const meshList = Array.isArray(pendingMesh) ? pendingMesh : [pendingMesh];
+      meshList.forEach(mesh => {
+        batchMeshes.push(mesh);
+        batchPrimitiveGroups.push(pendingPrimitiveGroups);
+      });
+
+      pendingMesh = null;
+      pendingPrimitiveIds = new Set();
+      pendingPrimitiveGroups = [];
+      pendingMatchedPrimitiveIds = new Set();
+
+      if (batchMeshes.length >= this.batchSize) {
+        await ensureNotAborted();
+        await this.ensureNotInteracting(abortSignal);
+        await processStreamBatch(batchMeshes, batchPrimitiveGroups);
+
+        batchMeshes.length = 0;
+        batchPrimitiveGroups.length = 0;
+      }
+    };
+
     while (true) {
       await ensureNotAborted();
 
@@ -319,11 +465,12 @@ export class StreamLoader {
       const { done, value } = content;
       if (done) {
         await ensureNotAborted();
+        await commitPendingMesh();
 
         if (batchMeshes.length > 0) {
           await ensureNotAborted();
           await this.ensureNotInteracting(abortSignal);
-          await processStreamBatch(batchMeshes, batchPrimitives);
+          await processStreamBatch(batchMeshes, batchPrimitiveGroups);
         }
         break;
       }
@@ -335,103 +482,55 @@ export class StreamLoader {
 
       while (buffer.length > 0) {
         await ensureNotAborted();
-        if (expectingPrimitive) {
-          if (buffer.length < 12) break;
-
-          try {
-            const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-            const primitiveResult = this.parsePrimitive(dataView, buffer, 0, isFullProps);
-            let primitiveData = primitiveResult.primitive;
-
-            this._applyPrefixId(primitiveData, 'id');
-            this._applyPrefixId(primitiveData, 'material');
-            const consumedBytes = primitiveResult.offset;
-
-            if (isFullProps) {
-              const { position, normal, posindex, nolindex, indices } =
-                this.parsePrimitiveData(primitiveData);
-              const formatted = this.formatPrimitiveData({ position, normal, posindex, nolindex });
-
-              delete primitiveData.nolindex;
-              delete primitiveData.posindex;
-
-              primitiveData.position = formatted.position;
-              primitiveData.normal = formatted.normal;
-              primitiveData.indices = indices;
-            }
-            const docId = primitiveData.id;
-
-            pendingPrimitives.set(docId, primitiveData);
-
-            expectingPrimitive = false;
-            buffer = buffer.slice(consumedBytes);
-          } catch (e) {
+        if (expectingMesh) {
+          const meshResult = tryParseMeshFromBuffer();
+          if (meshResult.status === 'incomplete') break;
+          if (meshResult.status === 'invalid') {
             break;
           }
-        } else {
-          if (buffer.length < 4) break;
 
-          const length = new DataView(buffer.buffer, buffer.byteOffset).getUint32(0, false);
-
-          if (length > 10 * 1024 * 1024) {
-            expectingPrimitive = true;
+          await commitPendingMesh();
+          pendingMesh = meshResult.mesh;
+          pendingPrimitiveIds = new Set(collectMeshPrimitiveIds(pendingMesh));
+          pendingPrimitiveGroups = [];
+          pendingMatchedPrimitiveIds = new Set();
+          expectingMesh = false;
+          buffer = buffer.slice(meshResult.totalLen);
+        } else {
+          const nextMeshResult = tryParseMeshFromBuffer();
+          if (nextMeshResult.status === 'success') {
+            await commitPendingMesh();
+            pendingMesh = nextMeshResult.mesh;
+            pendingPrimitiveIds = new Set(collectMeshPrimitiveIds(pendingMesh));
+            expectingMesh = false;
+            buffer = buffer.slice(nextMeshResult.totalLen);
             continue;
           }
 
-          const totalLen = 4 + length;
-
-          if (buffer.length < totalLen) break;
-
-          const data = buffer.slice(4, totalLen);
-          let mesh = null;
+          if (buffer.length < 12) break;
 
+          let primitiveResult = null;
           try {
-            const jsonStr = decoder.decode(data);
-            mesh = JSON.parse(jsonStr);
+            primitiveResult = parsePrimitiveFromBuffer();
           } catch (e) {
-            expectingPrimitive = true;
-            continue;
+            break;
           }
 
-          if (mesh) {
-            isFullProps = true;
+          const primitiveData = primitiveResult.primitive;
 
-            this._applyPrefixId(mesh, 'id');
-            if (Array.isArray(mesh)) {
-              mesh.forEach(item => {
-                this._applyPrefixId(item.primitives, 'prmid', item.documentId);
-              });
-            } else {
-              this._applyPrefixId(mesh.primitives, 'prmid', mesh.documentId);
-            }
+          if (pendingPrimitiveIds.has(primitiveData.id)) {
+            pendingPrimitiveGroups.push(primitiveData);
+            pendingMatchedPrimitiveIds.add(primitiveData.id);
+          }
 
-            let docId = mesh.id;
-            const meshToPrimId = mesh.primitives.map(item => item.prmid);
-            const hasPendingPrimitive = meshToPrimId.some(item => pendingPrimitives.has(item));
-            const hasPendingMesh = pendingPrimitives.has(docId);
-
-            if (hasPendingMesh || hasPendingPrimitive) {
-              let primitiveData = pendingPrimitives.get(docId);
-              if (!hasPendingMesh && hasPendingPrimitive) {
-                const primId = meshToPrimId[0];
-                primitiveData = pendingPrimitives.get(primId);
-              }
-
-              batchMeshes.push(mesh);
-              batchPrimitives.push(primitiveData);
-
-              if (batchMeshes.length >= this.batchSize) {
-                await ensureNotAborted();
-                await this.ensureNotInteracting(abortSignal);
-                await processStreamBatch(batchMeshes, batchPrimitives);
-
-                batchMeshes.length = 0;
-                batchPrimitives.length = 0;
-              }
-            }
+          buffer = buffer.slice(primitiveResult.consumedBytes);
 
-            expectingPrimitive = false;
-            buffer = buffer.slice(totalLen);
+          if (
+            pendingPrimitiveIds.size > 0 &&
+            pendingMatchedPrimitiveIds.size >= pendingPrimitiveIds.size
+          ) {
+            await commitPendingMesh();
+            expectingMesh = true;
           }
         }
       }
@@ -448,10 +547,18 @@ export class StreamLoader {
       if (abortSignal && abortSignal.aborted) {
         throw new DOMException('Request was aborted', 'AbortError');
       }
-      const renderResult = await this.renderModelData(meshes, primitives, list, range, null, undefined, {
-        suppressLoadComplete: true,
-        source: 'inRangeDis2',
-      });
+      const renderResult = await this.renderModelData(
+        meshes,
+        primitives,
+        list,
+        range,
+        null,
+        undefined,
+        {
+          suppressLoadComplete: true,
+          source: 'inRangeDis2',
+        }
+      );
       if (renderResult && renderResult.canceled) {
         throw new DOMException('Batch loading was canceled', 'AbortError');
       }
@@ -849,7 +956,12 @@ export class StreamLoader {
   async fetchJsonStream(list, range, abortSignal = null, requestId = null) {
     try {
       const loadStartTime = Date.now();
-      const streamResult = await this.fetchPrimitiveBufferByStream(range, list, abortSignal, requestId);
+      const streamResult = await this.fetchPrimitiveBufferByStream(
+        range,
+        list,
+        abortSignal,
+        requestId
+      );
       return {
         ...(streamResult || {}),
         duration: Date.now() - loadStartTime,
@@ -939,8 +1051,20 @@ export class StreamLoader {
     if (dataView.byteLength < offset + 12) {
       throw new Error('Insufficient data for primitive header');
     }
-    primitive.id = dataView.getInt32(offset, false);
+    const primitiveIdTextLen = dataView.getUint32(offset, false);
     offset += 4;
+    if (primitiveIdTextLen === 0xffffffff) {
+      primitive.id = null;
+    } else if (primitiveIdTextLen > 0) {
+      if (dataView.byteLength < offset + primitiveIdTextLen) {
+        throw new Error('Insufficient data for primitive id content');
+      }
+      const textBytes = uint8Array.subarray(offset, offset + primitiveIdTextLen);
+      primitive.id = new TextDecoder('utf-8').decode(textBytes);
+      offset += primitiveIdTextLen;
+    } else {
+      primitive.id = '';
+    }
 
     if (dataView.byteLength < offset + 4) {
       throw new Error('Insufficient data for GeomText length');
@@ -960,8 +1084,23 @@ export class StreamLoader {
       primitive.documentId = '';
     }
 
-    primitive.material = dataView.getInt32(offset, false);
+    if (dataView.byteLength < offset + 4) {
+      throw new Error('Insufficient data for Material length');
+    }
+    const materialTextLen = dataView.getUint32(offset, false);
     offset += 4;
+    if (materialTextLen === 0xffffffff) {
+      primitive.material = null;
+    } else if (materialTextLen > 0) {
+      if (dataView.byteLength < offset + materialTextLen) {
+        throw new Error('Insufficient data for Material content');
+      }
+      const textBytes = uint8Array.subarray(offset, offset + materialTextLen);
+      primitive.material = new TextDecoder('utf-8').decode(textBytes);
+      offset += materialTextLen;
+    } else {
+      primitive.material = '';
+    }
 
     if (dataView.byteLength < offset + 4) {
       throw new Error('Insufficient data for GeomText length');
@@ -1311,10 +1450,10 @@ export class StreamLoader {
     }
   }
 
-  async getBox({ id, projectId = this.projectId || 0 }) {
+  async getBox({ id, projectId = this.projectId || 0, isDebug }) {
     // 1. 尝试从 IndexedDB 读取
     const cached = await this._getFromDB(id, projectId);
-    if (cached) {
+    if (cached && !isDebug) {
       return cached;
     }
 
@@ -1539,7 +1678,11 @@ export class StreamLoader {
       this.sceneBox = sceneBox;
 
       // 获取BoxIndex
-      const boxIndex = await this.getBox({ id: item.id, projectId: this.projectId });
+      const boxIndex = await this.getBox({
+        id: item.id,
+        projectId: this.projectId,
+        isDebug: this.debug,
+      });
       this.boxIndex = boxIndex;
 
       // 将 mergeMaterialData 覆盖到 materialData（按 id 覆盖 color/transp）