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

package/packages/utils/StreamLoader.js

@@ -159,7 +159,7 @@ export class StreamLoader {
 
   async parseStreamImmediate(reader, list, range, abortSignal = null, streamId = null) {
     const batchMeshes = [];
-    const batchPrimitiveGroups = [];
+    const batchPrimitives = [];
     const batchSize = this.batchSize;
     let batchStart = 0;
     const streamStats = {
@@ -168,31 +168,8 @@ export class StreamLoader {
       totalPrimitives: 0,
     };
 
-    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) => {
+    const processStreamBatch = async (meshesToProcess, primitivesToProcess) => {
       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;
@@ -248,7 +225,7 @@ export class StreamLoader {
             const flushed = await this.workerRequest('streamFlush', { streamId: localStreamId });
             if (flushed?.meshes?.length) {
               batchMeshes.push(...flushed.meshes);
-              batchPrimitiveGroups.push(...flushed.primitives);
+              batchPrimitives.push(...flushed.primitives);
             }
 
             while (batchMeshes.length - batchStart >= batchSize) {
@@ -257,12 +234,9 @@ export class StreamLoader {
               const interactionPromiseInBatch = ensureNotInteracting();
               if (interactionPromiseInBatch) await interactionPromiseInBatch;
               const meshesToProcess = batchMeshes.slice(batchStart, batchStart + batchSize);
-              const primitiveGroupsToProcess = batchPrimitiveGroups.slice(
-                batchStart,
-                batchStart + batchSize
-              );
+              const primitivesToProcess = batchPrimitives.slice(batchStart, batchStart + batchSize);
               batchStart += batchSize;
-              await processStreamBatch(meshesToProcess, primitiveGroupsToProcess);
+              await processStreamBatch(meshesToProcess, primitivesToProcess);
             }
 
             if (batchMeshes.length - batchStart > 0) {
@@ -271,9 +245,9 @@ export class StreamLoader {
               const interactionPromiseInBatch = ensureNotInteracting();
               if (interactionPromiseInBatch) await interactionPromiseInBatch;
               const meshesToProcess = batchMeshes.slice(batchStart);
-              const primitiveGroupsToProcess = batchPrimitiveGroups.slice(batchStart);
+              const primitivesToProcess = batchPrimitives.slice(batchStart);
               batchStart = batchMeshes.length;
-              await processStreamBatch(meshesToProcess, primitiveGroupsToProcess);
+              await processStreamBatch(meshesToProcess, primitivesToProcess);
             }
             break;
           }
@@ -292,7 +266,7 @@ export class StreamLoader {
 
           if (parsed?.meshes?.length) {
             batchMeshes.push(...parsed.meshes);
-            batchPrimitiveGroups.push(...parsed.primitives);
+            batchPrimitives.push(...parsed.primitives);
           }
 
           while (batchMeshes.length - batchStart >= batchSize) {
@@ -301,17 +275,14 @@ export class StreamLoader {
             const interactionPromiseInBatch = ensureNotInteracting();
             if (interactionPromiseInBatch) await interactionPromiseInBatch;
             const meshesToProcess = batchMeshes.slice(batchStart, batchStart + batchSize);
-            const primitiveGroupsToProcess = batchPrimitiveGroups.slice(
-              batchStart,
-              batchStart + batchSize
-            );
+            const primitivesToProcess = batchPrimitives.slice(batchStart, batchStart + batchSize);
             batchStart += batchSize;
-            await processStreamBatch(meshesToProcess, primitiveGroupsToProcess);
+            await processStreamBatch(meshesToProcess, primitivesToProcess);
           }
 
           if (batchStart >= batchSize * 4) {
             batchMeshes.splice(0, batchStart);
-            batchPrimitiveGroups.splice(0, batchStart);
+            batchPrimitives.splice(0, batchStart);
             batchStart = 0;
           }
         }
@@ -326,127 +297,10 @@ export class StreamLoader {
     const decoder = new TextDecoder('utf-8');
     let buffer = new Uint8Array();
 
-    let expectingMesh = true;
-    let pendingMesh = null;
-    let pendingPrimitiveIds = new Set();
-    let pendingPrimitiveGroups = [];
-    let pendingMatchedPrimitiveIds = new Set();
+    const pendingPrimitives = new Map();
+    let expectingPrimitive = true;
     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();
 
@@ -465,12 +319,11 @@ 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, batchPrimitiveGroups);
+          await processStreamBatch(batchMeshes, batchPrimitives);
         }
         break;
       }
@@ -482,55 +335,103 @@ export class StreamLoader {
 
       while (buffer.length > 0) {
         await ensureNotAborted();
-        if (expectingMesh) {
-          const meshResult = tryParseMeshFromBuffer();
-          if (meshResult.status === 'incomplete') break;
-          if (meshResult.status === 'invalid') {
+        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) {
             break;
           }
-
-          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);
+          if (buffer.length < 4) break;
+
+          const length = new DataView(buffer.buffer, buffer.byteOffset).getUint32(0, false);
+
+          if (length > 10 * 1024 * 1024) {
+            expectingPrimitive = true;
             continue;
           }
 
-          if (buffer.length < 12) break;
+          const totalLen = 4 + length;
+
+          if (buffer.length < totalLen) break;
+
+          const data = buffer.slice(4, totalLen);
+          let mesh = null;
 
-          let primitiveResult = null;
           try {
-            primitiveResult = parsePrimitiveFromBuffer();
+            const jsonStr = decoder.decode(data);
+            mesh = JSON.parse(jsonStr);
           } catch (e) {
-            break;
+            expectingPrimitive = true;
+            continue;
           }
 
-          const primitiveData = primitiveResult.primitive;
+          if (mesh) {
+            isFullProps = true;
 
-          if (pendingPrimitiveIds.has(primitiveData.id)) {
-            pendingPrimitiveGroups.push(primitiveData);
-            pendingMatchedPrimitiveIds.add(primitiveData.id);
-          }
+            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);
+            }
 
-          buffer = buffer.slice(primitiveResult.consumedBytes);
+            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;
+              }
+            }
 
-          if (
-            pendingPrimitiveIds.size > 0 &&
-            pendingMatchedPrimitiveIds.size >= pendingPrimitiveIds.size
-          ) {
-            await commitPendingMesh();
-            expectingMesh = true;
+            expectingPrimitive = false;
+            buffer = buffer.slice(totalLen);
           }
         }
       }
@@ -547,18 +448,10 @@ 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');
       }
@@ -956,12 +849,7 @@ 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,
@@ -1051,20 +939,8 @@ export class StreamLoader {
     if (dataView.byteLength < offset + 12) {
       throw new Error('Insufficient data for primitive header');
     }
-    const primitiveIdTextLen = dataView.getUint32(offset, false);
+    primitive.id = dataView.getInt32(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');
@@ -1084,23 +960,8 @@ export class StreamLoader {
       primitive.documentId = '';
     }
 
-    if (dataView.byteLength < offset + 4) {
-      throw new Error('Insufficient data for Material length');
-    }
-    const materialTextLen = dataView.getUint32(offset, false);
+    primitive.material = dataView.getInt32(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');
@@ -1450,10 +1311,10 @@ export class StreamLoader {
     }
   }
 
-  async getBox({ id, projectId = this.projectId || 0, isDebug }) {
+  async getBox({ id, projectId = this.projectId || 0 }) {
     // 1. 尝试从 IndexedDB 读取
     const cached = await this._getFromDB(id, projectId);
-    if (cached && !isDebug) {
+    if (cached) {
       return cached;
     }
 
@@ -1678,11 +1539,7 @@ export class StreamLoader {
       this.sceneBox = sceneBox;
 
       // 获取BoxIndex
-      const boxIndex = await this.getBox({
-        id: item.id,
-        projectId: this.projectId,
-        isDebug: this.debug,
-      });
+      const boxIndex = await this.getBox({ id: item.id, projectId: this.projectId });
       this.boxIndex = boxIndex;
 
       // 将 mergeMaterialData 覆盖到 materialData（按 id 覆盖 color/transp）