fl-web-component 2.0.8 → 2.0.9

package/packages/utils/StreamLoader.js

@@ -19,6 +19,7 @@ export class StreamLoader {
 
     // 钩子函数
     this.renderModelData = config.renderModelData || (async () => {});
+    this.onRangeStreamComplete = config.onRangeStreamComplete;
     // 外部提供的交互状态检查函数（可选）
     this.externalEnsureNotInteracting = config.ensureNotInteracting;
     this.prefixIdKey = config.prefixIdKey || 'documentId';
@@ -161,6 +162,19 @@ export class StreamLoader {
     const batchPrimitives = [];
     const batchSize = this.batchSize;
     let batchStart = 0;
+    const streamStats = {
+      totalBatches: 0,
+      totalMeshes: 0,
+      totalPrimitives: 0,
+    };
+
+    const processStreamBatch = async (meshesToProcess, primitivesToProcess) => {
+      if (!meshesToProcess || meshesToProcess.length === 0) return;
+      await this.processBatchData(meshesToProcess, primitivesToProcess, list, range, abortSignal);
+      streamStats.totalBatches += 1;
+      streamStats.totalMeshes += meshesToProcess.length;
+      streamStats.totalPrimitives += primitivesToProcess ? primitivesToProcess.length : 0;
+    };
 
     const ensureNotAborted = () => {
       if (abortSignal && abortSignal.aborted) {
@@ -189,7 +203,6 @@ export class StreamLoader {
           if (abortPromise) await abortPromise;
           const interactionPromise = ensureNotInteracting();
           if (interactionPromise) await interactionPromise;
-
           let content;
           try {
             content = await reader.read();
@@ -223,7 +236,7 @@ export class StreamLoader {
               const meshesToProcess = batchMeshes.slice(batchStart, batchStart + batchSize);
               const primitivesToProcess = batchPrimitives.slice(batchStart, batchStart + batchSize);
               batchStart += batchSize;
-              this.processBatchData(meshesToProcess, primitivesToProcess, list, range, abortSignal);
+              await processStreamBatch(meshesToProcess, primitivesToProcess);
             }
 
             if (batchMeshes.length - batchStart > 0) {
@@ -234,7 +247,7 @@ export class StreamLoader {
               const meshesToProcess = batchMeshes.slice(batchStart);
               const primitivesToProcess = batchPrimitives.slice(batchStart);
               batchStart = batchMeshes.length;
-              this.processBatchData(meshesToProcess, primitivesToProcess, list, range, abortSignal);
+              await processStreamBatch(meshesToProcess, primitivesToProcess);
             }
             break;
           }
@@ -264,7 +277,7 @@ export class StreamLoader {
             const meshesToProcess = batchMeshes.slice(batchStart, batchStart + batchSize);
             const primitivesToProcess = batchPrimitives.slice(batchStart, batchStart + batchSize);
             batchStart += batchSize;
-            this.processBatchData(meshesToProcess, primitivesToProcess, list, range, abortSignal);
+            await processStreamBatch(meshesToProcess, primitivesToProcess);
           }
 
           if (batchStart >= batchSize * 4) {
@@ -278,7 +291,7 @@ export class StreamLoader {
           await this.workerRequest('streamDispose', { streamId: localStreamId });
         } catch (e) {}
       }
-      return;
+      return streamStats;
     }
 
     const decoder = new TextDecoder('utf-8');
@@ -310,7 +323,7 @@ export class StreamLoader {
         if (batchMeshes.length > 0) {
           await ensureNotAborted();
           await this.ensureNotInteracting(abortSignal);
-          await this.processBatchData(batchMeshes, batchPrimitives, list, range, abortSignal);
+          await processStreamBatch(batchMeshes, batchPrimitives);
         }
         break;
       }
@@ -410,7 +423,7 @@ export class StreamLoader {
               if (batchMeshes.length >= this.batchSize) {
                 await ensureNotAborted();
                 await this.ensureNotInteracting(abortSignal);
-                await this.processBatchData(batchMeshes, batchPrimitives, list, range, abortSignal);
+                await processStreamBatch(batchMeshes, batchPrimitives);
 
                 batchMeshes.length = 0;
                 batchPrimitives.length = 0;
@@ -423,20 +436,32 @@ export class StreamLoader {
         }
       }
     }
+    return streamStats;
   }
 
   // ----------------------------------------------------------------
   // 数据处理与渲染
   // ----------------------------------------------------------------
 
-  processBatchData(meshes, primitives, list, range, abortSignal = null) {
+  async processBatchData(meshes, primitives, list, range, abortSignal = null) {
     try {
       if (abortSignal && abortSignal.aborted) {
         throw new DOMException('Request was aborted', 'AbortError');
       }
-      this.renderModelData(meshes, primitives, list, range); // TODO
+      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');
+      }
+      if (abortSignal && abortSignal.aborted) {
+        throw new DOMException('Request was aborted', 'AbortError');
+      }
+      return renderResult;
     } catch (error) {
       console.error('Failed to render batch data:', error);
+      throw error;
     }
   }
 
@@ -481,10 +506,24 @@ export class StreamLoader {
       this.currentStreamReader = reader;
       this.activeStreamReaders.add(reader);
 
-      await this.parseStreamImmediate(reader, list, range, internalController.signal, requestId);
+      const streamStats = await this.parseStreamImmediate(
+        reader,
+        list,
+        range,
+        internalController.signal,
+        requestId
+      );
+
+      if (internalController.signal.aborted) {
+        throw new DOMException('Request was aborted', 'AbortError');
+      }
 
       if (res) {
-        return res;
+        return {
+          stream: res,
+          requestId,
+          ...(streamStats || {}),
+        };
       }
       return null;
     } catch (error) {
@@ -634,7 +673,7 @@ export class StreamLoader {
       // Adaptation: utils used getPrimitivesByRangeStreamWithAutoAbort which calls getPrimitivesByRangeStream
       // Here I simplify by calling getPrimitivesByRangeStream directly but managing request key
 
-      const buffer = await this.getPrimitivesByRangeStream(
+      const streamResult = await this.getPrimitivesByRangeStream(
         range,
         list,
         range,
@@ -642,8 +681,8 @@ export class StreamLoader {
       );
 
       this.cleanupRequest(request.requestId);
-      if (!buffer) return null;
-      return buffer;
+      if (!streamResult) return null;
+      return streamResult;
     } catch (error) {
       if (error.name === 'AbortError') {
         // throw error;
@@ -807,7 +846,11 @@ export class StreamLoader {
   async fetchJsonStream(list, range, abortSignal = null, requestId = null) {
     try {
       const loadStartTime = Date.now();
-      await this.fetchPrimitiveBufferByStream(range, list, abortSignal, requestId);
+      const streamResult = await this.fetchPrimitiveBufferByStream(range, list, abortSignal, requestId);
+      return {
+        ...(streamResult || {}),
+        duration: Date.now() - loadStartTime,
+      };
     } catch (err) {
       if (err.name === 'AbortError') {
         throw err;
@@ -1390,8 +1433,22 @@ export class StreamLoader {
     // }
 
     try {
-      await this.fetchJsonStream(primaryItem, range, this.currentAbortController.signal, requestId);
+      const streamResult = await this.fetchJsonStream(
+        primaryItem,
+        range,
+        this.currentAbortController.signal,
+        requestId
+      );
       if (this.currentRequestId === requestId) {
+        if (typeof this.onRangeStreamComplete === 'function') {
+          await this.onRangeStreamComplete({
+            source: 'inRangeDis2',
+            requestId,
+            item: primaryItem,
+            range,
+            ...(streamResult || {}),
+          });
+        }
         this.currentAbortController = null;
         this.currentRequestId = null;
       } else {

package/src/utils/threejs/editor/command.js

@@ -0,0 +1,36 @@
+export default class Command {
+  constructor(service) {
+    this.service = service;
+    this.type = 'Command';
+    this.name = '命令';
+    this.updatable = false;
+    this.inMemory = true;
+  }
+
+  execute() {}
+
+  undo() {}
+
+  canUpdate() {
+    return false;
+  }
+
+  update() {}
+
+  getObject() {
+    return this.object || null;
+  }
+
+  getChangedKeys() {
+    return [];
+  }
+
+  toJSON() {
+    return {
+      type: this.type,
+      name: this.name,
+    };
+  }
+
+  fromJSON() {}
+}

package/src/utils/threejs/editor/commands/add-element-command.js

@@ -0,0 +1,41 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+import { insertObjectAt, removeObjectFromParent } from '../scene-helpers';
+
+export default class AddElementCommand extends Command {
+  constructor(service, object, options = {}) {
+    super(service);
+    this.type = COMMAND_TYPE.ADD_ELEMENT;
+    this.name = '新增元素';
+    this.object = object;
+    this.parentUuid = options.parentUuid || '';
+    this.index = options.index;
+  }
+
+  execute() {
+    const parent = this.service.getObjectByUuid(this.parentUuid) || this.service.getCustomRoot();
+    this.parentUuid = parent.uuid;
+    insertObjectAt(parent, this.object, this.index);
+    this.index = parent.children.indexOf(this.object);
+    this.object.updateMatrixWorld(true);
+  }
+
+  undo() {
+    removeObjectFromParent(this.object);
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      object: this.object.toJSON(),
+      parentUuid: this.parentUuid,
+      index: this.index,
+    };
+  }
+
+  fromJSON(json) {
+    this.parentUuid = json.parentUuid;
+    this.index = json.index;
+    this.object = this.service.parseObjectJSON(json.object);
+  }
+}

package/src/utils/threejs/editor/commands/add-group-command.js

@@ -0,0 +1,10 @@
+import AddElementCommand from './add-element-command';
+import { COMMAND_TYPE } from '../constants';
+
+export default class AddGroupCommand extends AddElementCommand {
+  constructor(service, object, options = {}) {
+    super(service, object, options);
+    this.type = COMMAND_TYPE.ADD_GROUP;
+    this.name = '新增组';
+  }
+}

package/src/utils/threejs/editor/commands/clone-element-command.js

@@ -0,0 +1,100 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+import { cloneCustomObject } from '../element-factory';
+import { insertObjectAt, removeObjectFromParent } from '../scene-helpers';
+
+const DEFAULT_CLONE_OFFSET_MIN = 1;
+const DEFAULT_CLONE_OFFSET_RATIO = 0.2;
+
+function normalizeOffsetArray(offset = []) {
+  if (!Array.isArray(offset) || offset.length !== 3) return null;
+  return offset.map(value => Number(value) || 0);
+}
+
+function createWorldOffsetVector(THREE, source) {
+  const bounds = new THREE.Box3();
+  const size = new THREE.Vector3();
+  source.updateMatrixWorld(true);
+  bounds.setFromObject(source);
+  bounds.getSize(size);
+  const baseOffset = Math.max(
+    Math.max(size.x || 0, size.y || 0, size.z || 0) * DEFAULT_CLONE_OFFSET_RATIO,
+    DEFAULT_CLONE_OFFSET_MIN
+  );
+  return new THREE.Vector3(baseOffset, 0, baseOffset);
+}
+
+function convertWorldOffsetToLocal(THREE, parent, worldOffset) {
+  if (!parent) return worldOffset.clone();
+  parent.updateMatrixWorld(true);
+  const worldOrigin = parent.getWorldPosition(new THREE.Vector3());
+  const localOrigin = parent.worldToLocal(worldOrigin.clone());
+  const localTarget = parent.worldToLocal(worldOrigin.clone().add(worldOffset));
+  return localTarget.sub(localOrigin);
+}
+
+function resolveCloneOffset(THREE, source, targetParent, options = {}) {
+  const normalizedOffset = normalizeOffsetArray(options.positionOffset);
+  if (normalizedOffset) {
+    return new THREE.Vector3().fromArray(normalizedOffset);
+  }
+  if (options.disableAutoOffset === true || !THREE || !source) {
+    return new THREE.Vector3(0, 0, 0);
+  }
+  return convertWorldOffsetToLocal(THREE, targetParent, createWorldOffsetVector(THREE, source));
+}
+
+export default class CloneElementCommand extends Command {
+  constructor(service, uuid, options = {}) {
+    super(service);
+    this.type = COMMAND_TYPE.CLONE_ELEMENT;
+    this.name = '复制元素';
+    this.source = service.getObjectByUuid(uuid);
+    const targetParent =
+      service.getObjectByUuid(options.parentUuid) ||
+      (this.source && this.source.parent) ||
+      service.getCustomRoot();
+    this.parentUuid = targetParent.uuid;
+    this.index = options.index;
+    this.object = this.source ? cloneCustomObject(service.THREE, this.source, targetParent) : null;
+    this.positionOffset = resolveCloneOffset(service.THREE, this.source, targetParent, options);
+    if (this.object) {
+      // 复制后默认沿平面做一次可见偏移，避免与原对象完全重合。
+      this.object.position.add(this.positionOffset);
+      this.object.updateMatrixWorld(true);
+    }
+  }
+
+  execute() {
+    if (!this.object) return;
+    const parent = this.service.getObjectByUuid(this.parentUuid) || this.service.getCustomRoot();
+    insertObjectAt(parent, this.object, this.index);
+    this.index = parent.children.indexOf(this.object);
+    this.object.updateMatrixWorld(true);
+  }
+
+  undo() {
+    if (!this.object) return;
+    removeObjectFromParent(this.object);
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      sourceUuid: this.source ? this.source.uuid : '',
+      parentUuid: this.parentUuid,
+      index: this.index,
+      positionOffset: this.positionOffset ? this.positionOffset.toArray() : [0, 0, 0],
+      object: this.object ? this.object.toJSON() : null,
+    };
+  }
+
+  fromJSON(json) {
+    this.parentUuid = json.parentUuid;
+    this.index = json.index;
+    this.positionOffset = Array.isArray(json.positionOffset)
+      ? new this.service.THREE.Vector3().fromArray(json.positionOffset)
+      : new this.service.THREE.Vector3(0, 0, 0);
+    this.object = json.object ? this.service.parseObjectJSON(json.object) : null;
+  }
+}

package/src/utils/threejs/editor/commands/move-element-command.js

@@ -0,0 +1,57 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+import { getObjectIndex, insertObjectAt } from '../scene-helpers';
+
+export default class MoveElementCommand extends Command {
+  constructor(service, uuid, options = {}) {
+    super(service);
+    this.type = COMMAND_TYPE.MOVE_ELEMENT;
+    this.name = '移动元素';
+    this.object = service.getObjectByUuid(uuid);
+    this.oldParentUuid = this.object && this.object.parent ? this.object.parent.uuid : '';
+    this.oldIndex = getObjectIndex(this.object);
+    this.newParentUuid = options.targetParentUuid || '';
+    this.newIndex = options.index;
+  }
+
+  execute() {
+    if (!this.object) return;
+    const targetParent =
+      this.service.getObjectByUuid(this.newParentUuid) || this.service.getCustomRoot();
+    insertObjectAt(targetParent, this.object, this.newIndex);
+    this.newParentUuid = targetParent.uuid;
+    this.newIndex = targetParent.children.indexOf(this.object);
+    this.object.updateMatrixWorld(true);
+  }
+
+  undo() {
+    if (!this.object) return;
+    const oldParent =
+      this.service.getObjectByUuid(this.oldParentUuid) || this.service.getCustomRoot();
+    insertObjectAt(oldParent, this.object, this.oldIndex);
+    this.object.updateMatrixWorld(true);
+  }
+
+  getChangedKeys() {
+    return ['parentUuid'];
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      uuid: this.object ? this.object.uuid : '',
+      oldParentUuid: this.oldParentUuid,
+      oldIndex: this.oldIndex,
+      newParentUuid: this.newParentUuid,
+      newIndex: this.newIndex,
+    };
+  }
+
+  fromJSON(json) {
+    this.object = this.service.getObjectByUuid(json.uuid);
+    this.oldParentUuid = json.oldParentUuid;
+    this.oldIndex = json.oldIndex;
+    this.newParentUuid = json.newParentUuid;
+    this.newIndex = json.newIndex;
+  }
+}

package/src/utils/threejs/editor/commands/multi-command.js

@@ -0,0 +1,29 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+
+export default class MultiCommand extends Command {
+  constructor(service, commands = [], options = {}) {
+    super(service);
+    this.type = COMMAND_TYPE.MULTI;
+    this.name = options.name || '批量修改';
+    this.commands = commands;
+  }
+
+  execute() {
+    this.commands.forEach(command => {
+      command.execute();
+    });
+  }
+
+  undo() {
+    for (let index = this.commands.length - 1; index >= 0; index -= 1) {
+      this.commands[index].undo();
+    }
+  }
+
+  getChangedKeys() {
+    return this.commands.reduce((result, command) => {
+      return result.concat(command.getChangedKeys());
+    }, []);
+  }
+}

package/src/utils/threejs/editor/commands/remove-element-command.js

@@ -0,0 +1,46 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+import { getObjectIndex, insertObjectAt, removeObjectFromParent } from '../scene-helpers';
+
+export default class RemoveElementCommand extends Command {
+  constructor(service, uuid) {
+    super(service);
+    this.type = COMMAND_TYPE.REMOVE_ELEMENT;
+    this.name = '删除元素';
+    this.object = service.getObjectByUuid(uuid);
+    this.parentUuid = this.object && this.object.parent ? this.object.parent.uuid : '';
+    this.index = getObjectIndex(this.object);
+  }
+
+  execute() {
+    if (!this.object) return;
+    if (this.object.parent) {
+      this.parentUuid = this.object.parent.uuid;
+      this.index = getObjectIndex(this.object);
+    }
+    removeObjectFromParent(this.object);
+  }
+
+  undo() {
+    if (!this.object) return;
+    const parent = this.service.getObjectByUuid(this.parentUuid) || this.service.getCustomRoot();
+    insertObjectAt(parent, this.object, this.index);
+    this.object.updateMatrixWorld(true);
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      uuid: this.object ? this.object.uuid : '',
+      parentUuid: this.parentUuid,
+      index: this.index,
+      object: this.object ? this.object.toJSON() : null,
+    };
+  }
+
+  fromJSON(json) {
+    this.parentUuid = json.parentUuid;
+    this.index = json.index;
+    this.object = json.object ? this.service.parseObjectJSON(json.object) : null;
+  }
+}

package/src/utils/threejs/editor/commands/reset-original-model-style-command.js

@@ -0,0 +1,30 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+
+export default class ResetOriginalModelStyleCommand extends Command {
+  constructor(service, uuid) {
+    super(service);
+    this.type = COMMAND_TYPE.RESET_ORIGINAL_MODEL_STYLE;
+    this.name = '还原原始模型样式';
+    this.object = service.getObjectByUuid(uuid);
+    this.uuid = uuid;
+    this.oldStyle = service.getOriginalModelStyleValue(uuid);
+    this.resetStyle = service.ensureOriginalModelBaseline(uuid);
+  }
+
+  execute() {
+    if (!this.object) return;
+    this.service.applyOriginalModelStyle(this.uuid, this.resetStyle);
+    this.service.syncOriginalModelStyleRecord(this.uuid);
+  }
+
+  undo() {
+    if (!this.object) return;
+    this.service.applyOriginalModelStyle(this.uuid, this.oldStyle);
+    this.service.syncOriginalModelStyleRecord(this.uuid);
+  }
+
+  getChangedKeys() {
+    return ['color', 'opacity', 'visible'];
+  }
+}

package/src/utils/threejs/editor/commands/set-geometry-params-command.js

@@ -0,0 +1,41 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+import { createGeometry, normalizeGeometryParams } from '../element-factory';
+
+export default class SetGeometryParamsCommand extends Command {
+  constructor(service, uuid, geometryParams) {
+    super(service);
+    this.type = COMMAND_TYPE.SET_GEOMETRY_PARAMS;
+    this.name = '修改几何参数';
+    this.object = service.getObjectByUuid(uuid);
+    this.elementType = this.object && this.object.userData ? this.object.userData.elementType : '';
+    this.oldParams =
+      this.object && this.object.userData && this.object.userData.geometryParams
+        ? normalizeGeometryParams(this.elementType, this.object.userData.geometryParams)
+        : {};
+    this.newParams = normalizeGeometryParams(this.elementType, geometryParams);
+    this.oldGeometry = this.object ? this.object.geometry : null;
+    this.newGeometry = null;
+  }
+
+  execute() {
+    if (!this.object) return;
+    if (!this.newGeometry) {
+      this.newGeometry = createGeometry(this.service.THREE, this.elementType, this.newParams);
+    }
+    this.object.geometry = this.newGeometry;
+    this.object.userData.geometryParams = { ...this.newParams };
+    this.object.updateMatrixWorld(true);
+  }
+
+  undo() {
+    if (!this.object) return;
+    this.object.geometry = this.oldGeometry;
+    this.object.userData.geometryParams = { ...this.oldParams };
+    this.object.updateMatrixWorld(true);
+  }
+
+  getChangedKeys() {
+    return ['geometryParams'];
+  }
+}

package/src/utils/threejs/editor/commands/set-original-model-style-command.js

@@ -0,0 +1,56 @@
+import Command from '../command';
+import { COMMAND_TYPE } from '../constants';
+
+function cloneStyle(style = {}) {
+  return JSON.parse(JSON.stringify(style || {}));
+}
+
+export default class SetOriginalModelStyleCommand extends Command {
+  constructor(service, uuid, style = {}) {
+    super(service);
+    this.type = COMMAND_TYPE.SET_ORIGINAL_MODEL_STYLE;
+    this.name = '修改原始模型样式';
+    this.updatable = true;
+    this.object = service.getObjectByUuid(uuid);
+    this.uuid = uuid;
+    // 首次修改前必须先固化原始样式基线，否则“还原”会回到已修改后的状态。
+    service.ensureOriginalModelBaseline(uuid);
+    this.oldStyle = service.getOriginalModelStyleValue(uuid);
+    this.newStyle = service.mergeOriginalModelStyle(this.oldStyle, style);
+  }
+
+  execute() {
+    if (!this.object) return;
+    this.service.applyOriginalModelStyle(this.uuid, this.newStyle);
+    this.service.syncOriginalModelStyleRecord(this.uuid);
+  }
+
+  undo() {
+    if (!this.object) return;
+    this.service.applyOriginalModelStyle(this.uuid, this.oldStyle);
+    this.service.syncOriginalModelStyleRecord(this.uuid);
+  }
+
+  canUpdate(command, deltaTime, mergeWindow) {
+    return (
+      command &&
+      command.type === this.type &&
+      command.uuid === this.uuid &&
+      deltaTime <= mergeWindow
+    );
+  }
+
+  update(command) {
+    this.newStyle = cloneStyle(command.newStyle);
+  }
+
+  getChangedKeys() {
+    const changedKeys = [];
+    ['color', 'opacity', 'visible'].forEach(key => {
+      if (this.oldStyle[key] !== this.newStyle[key]) {
+        changedKeys.push(key);
+      }
+    });
+    return changedKeys;
+  }
+}