@fengyizhi/scene-lib 1.0.3 → 1.0.4

package/fesm2022/fengyizhi-scene-lib.mjs

@@ -168,6 +168,7 @@ class SceneStore {
         this.doc.environment = doc.environment;
         this.doc.flyPaths = doc.flyPaths;
         this.doc.dashboard = doc.dashboard;
+        this.doc.instanceGroups = doc.instanceGroups;
         this._selection = [];
         // 加载文档时清空撤销/重做历史
         this.history.clear();
@@ -204,6 +205,44 @@ class AddNodeCommand {
         }
     }
 }
+/** 批量添加节点（用于复制操作，一次撤销全部） */
+class BatchAddCommand {
+    label;
+    nodes;
+    parentIds;
+    constructor(items) {
+        this.nodes = items.map(i => i.node);
+        this.parentIds = items.map(i => i.parentId);
+        this.label = `批量添加 (${items.length} 个)`;
+    }
+    do(store) {
+        for (let i = 0; i < this.nodes.length; i++) {
+            const node = this.nodes[i];
+            const parentId = this.parentIds[i];
+            if (!store.node(node.id)) {
+                store.doc.nodes.push(clone(node));
+            }
+            if (parentId) {
+                const p = store.node(parentId);
+                if (p && !p.children.includes(node.id))
+                    p.children.push(node.id);
+            }
+        }
+    }
+    undo(store) {
+        const ids = new Set(this.nodes.map(n => n.id));
+        store.doc.nodes = store.doc.nodes.filter(n => !ids.has(n.id));
+        for (let i = 0; i < this.parentIds.length; i++) {
+            const parentId = this.parentIds[i];
+            const node = this.nodes[i];
+            if (parentId) {
+                const p = store.node(parentId);
+                if (p)
+                    p.children = p.children.filter(c => c !== node.id);
+            }
+        }
+    }
+}
 class RemoveNodeCommand {
     id;
     label = '删除节点';
@@ -265,6 +304,7 @@ class GroupCommand {
     originalParents = new Map();
     originalPositions = new Map();
     removedEmptyGroups = [];
+    commonParentId = null;
     constructor(selectedIds) {
         this.selectedIds = selectedIds;
         this.groupId = nextId('grp');
@@ -330,9 +370,27 @@ class GroupCommand {
                 ];
             }
         }
+        // 找到共同父节点：如果所有选中节点都在同一个父节点下，组也应该在该父节点下
+        const parentIds = [...this.originalParents.values()];
+        const allSameParent = parentIds.length > 0 && parentIds.every(p => p === parentIds[0]);
+        this.commonParentId = allSameParent ? parentIds[0] : null;
+        if (this.commonParentId) {
+            // 添加到共同父节点下
+            const parentNode = store.node(this.commonParentId);
+            if (parentNode) {
+                parentNode.children.push(group.id);
+            }
+        }
         store.doc.nodes.push(clone(group));
     }
     undo(store) {
+        // 从共同父节点中移除 group（如果有的话）
+        if (this.commonParentId) {
+            const parentNode = store.node(this.commonParentId);
+            if (parentNode) {
+                parentNode.children = parentNode.children.filter(c => c !== this.groupId);
+            }
+        }
         // 删除新创建的 group
         store.doc.nodes = store.doc.nodes.filter(n => n.id !== this.groupId);
         // 恢复被删除的空组
@@ -355,6 +413,23 @@ class GroupCommand {
         }
     }
 }
+/** 计算节点的世界位置（只考虑平移，忽略旋转缩放） */
+function computeWorldPosition(store, nodeId) {
+    const node = store.node(nodeId);
+    if (!node)
+        return [0, 0, 0];
+    const parent = store.parentOf(nodeId);
+    if (!parent) {
+        // 根节点，局部坐标就是世界坐标
+        return [...node.position];
+    }
+    const parentWorld = computeWorldPosition(store, parent.id);
+    return [
+        parentWorld[0] + node.position[0],
+        parentWorld[1] + node.position[1],
+        parentWorld[2] + node.position[2],
+    ];
+}
 /** 解除合并：将 group 的子节点提升到 group 的父节点下，删除 group */
 class UngroupCommand {
     label = '解除合并';
@@ -362,6 +437,10 @@ class UngroupCommand {
     children = [];
     groupParentId = null;
     groupName = '';
+    /** 记录 group 的变换（用于 undo 恢复） */
+    groupTransform = null;
+    /** 记录子节点在 group 内的原始位置（用于 undo 恢复） */
+    originalChildPositions = new Map();
     constructor(groupId) {
         this.groupId = groupId;
     }
@@ -372,6 +451,39 @@ class UngroupCommand {
         this.groupParentId = store.parentOf(this.groupId)?.id ?? null;
         this.children = [...group.children];
         this.groupName = group.name;
+        this.originalChildPositions.clear();
+        // 记录 group 的变换状态
+        this.groupTransform = {
+            position: [...group.position],
+            rotation: [...group.rotation],
+            scale: [...group.scale],
+        };
+        // 计算 group 的世界位置
+        const groupWorldPos = computeWorldPosition(store, this.groupId);
+        // 计算目标父节点的世界位置
+        const parentWorldPos = this.groupParentId
+            ? computeWorldPosition(store, this.groupParentId)
+            : [0, 0, 0];
+        // 记录原始位置，并转换子节点坐标
+        for (const childId of this.children) {
+            const child = store.node(childId);
+            if (!child)
+                continue;
+            // 记录原始位置（group 的局部坐标）
+            this.originalChildPositions.set(childId, [...child.position]);
+            // 计算子节点的世界位置
+            const childWorldPos = [
+                groupWorldPos[0] + child.position[0],
+                groupWorldPos[1] + child.position[1],
+                groupWorldPos[2] + child.position[2],
+            ];
+            // 转换为父节点的局部坐标
+            child.position = [
+                childWorldPos[0] - parentWorldPos[0],
+                childWorldPos[1] - parentWorldPos[1],
+                childWorldPos[2] - parentWorldPos[2],
+            ];
+        }
         // 将子节点移到 group 的父节点下
         if (this.groupParentId) {
             const parent = store.node(this.groupParentId);
@@ -393,6 +505,12 @@ class UngroupCommand {
         const group = createNode('group', this.groupName || '组');
         group.id = this.groupId;
         group.children = [...this.children];
+        // 恢复 group 的变换状态
+        if (this.groupTransform) {
+            group.position = [...this.groupTransform.position];
+            group.rotation = [...this.groupTransform.rotation];
+            group.scale = [...this.groupTransform.scale];
+        }
         store.doc.nodes.push(clone(group));
         // 从当前父节点移除子节点
         for (const id of this.children) {
@@ -411,6 +529,13 @@ class UngroupCommand {
                 }
             }
         }
+        // 恢复子节点的原始位置（group 的局部坐标）
+        for (const [id, pos] of this.originalChildPositions) {
+            const child = store.node(id);
+            if (child) {
+                child.position = [...pos];
+            }
+        }
     }
 }
 /** 材质覆盖命令：记录 before/after，支持 undo/redo */
@@ -535,13 +660,17 @@ class SetAlarmCommand {
         }
     }
 }
-/** 拖动节点改变父节点 */
+/** 拖动节点改变父节点（保持世界坐标不变） */
 class ReparentCommand {
     nodeId;
     newParentId;
     label = '移动节点';
     oldParentId = null;
     oldIndex = 0;
+    /** 记录旧位置（用于 undo 恢复） */
+    oldPosition = null;
+    oldRotation = null;
+    oldScale = null;
     constructor(nodeId, newParentId) {
         this.nodeId = nodeId;
         this.newParentId = newParentId;
@@ -558,6 +687,12 @@ class ReparentCommand {
                 this.oldIndex = oldParent.children.indexOf(this.nodeId);
             }
         }
+        // 记录原始变换（用于 undo 恢复）
+        this.oldPosition = [...node.position];
+        this.oldRotation = [...node.rotation];
+        this.oldScale = [...node.scale];
+        // 计算世界坐标（只考虑平移）
+        const worldPos = computeWorldPosition(store, this.nodeId);
         // 从旧父节点移除
         if (this.oldParentId) {
             const oldParent = store.node(this.oldParentId);
@@ -572,8 +707,22 @@ class ReparentCommand {
                 newParent.children.push(this.nodeId);
             }
         }
+        // 转换坐标：世界坐标 → 新父节点的局部坐标
+        if (this.newParentId) {
+            const newParentWorld = computeWorldPosition(store, this.newParentId);
+            node.position = [
+                worldPos[0] - newParentWorld[0],
+                worldPos[1] - newParentWorld[1],
+                worldPos[2] - newParentWorld[2],
+            ];
+        }
+        else {
+            // 移动到根级，直接使用世界坐标
+            node.position = worldPos;
+        }
     }
     undo(store) {
+        const node = store.node(this.nodeId);
         // 从当前父节点移除
         const currentParent = store.parentOf(this.nodeId);
         if (currentParent) {
@@ -586,6 +735,14 @@ class ReparentCommand {
                 oldParent.children.splice(this.oldIndex, 0, this.nodeId);
             }
         }
+        // 恢复原始变换
+        if (node && this.oldPosition) {
+            node.position = [...this.oldPosition];
+            if (this.oldRotation)
+                node.rotation = [...this.oldRotation];
+            if (this.oldScale)
+                node.scale = [...this.oldScale];
+        }
     }
 }
 /** 环境配置命令：背景色、半球光、平行光、HDRI、场景空间 */
@@ -598,15 +755,9 @@ class SetEnvironmentCommand {
         this.after = after;
     }
     do(store) {
-        const floorColor = this.after.room?.floorColor || 'none';
-        const floorTexture = this.after.room?.floorTexture?.substring(0, 30) || 'no texture';
-        console.log('[SetEnvironmentCommand.do] applying - floorColor:', floorColor, 'floorTexture:', floorTexture);
         store.doc.environment = clone(this.after);
     }
     undo(store) {
-        const floorColor = this.before?.room?.floorColor || 'none';
-        const floorTexture = this.before?.room?.floorTexture?.substring(0, 30) || 'no texture';
-        console.log('[SetEnvironmentCommand.undo] restoring - floorColor:', floorColor, 'floorTexture:', floorTexture);
         if (this.before) {
             store.doc.environment = clone(this.before);
         }
@@ -1239,6 +1390,142 @@ class MovePathPointToEndCommand {
         }
     }
 }
+/** 对齐命令：将多个节点对齐到指定轴向的指定位置 */
+class AlignCommand {
+    nodeIds;
+    axis;
+    position;
+    targetPositions;
+    label;
+    beforePositions = new Map();
+    constructor(nodeIds, axis, position, targetPositions) {
+        this.nodeIds = nodeIds;
+        this.axis = axis;
+        this.position = position;
+        this.targetPositions = targetPositions;
+        const axisNames = { x: '红轴(X)', y: '绿轴(Y)', z: '蓝轴(Z)' };
+        const positionNames = { min: '负方向', center: '居中', max: '正方向' };
+        this.label = `对齐 ${axisNames[axis]} ${positionNames[position]}`;
+    }
+    do(store) {
+        // 记录原始位置（用于 undo）
+        this.beforePositions.clear();
+        for (const id of this.nodeIds) {
+            const node = store.node(id);
+            if (node) {
+                this.beforePositions.set(id, [...node.position]);
+            }
+        }
+        // 应用新位置
+        for (const [id, pos] of this.targetPositions) {
+            const node = store.node(id);
+            if (node) {
+                node.position = clone(pos);
+            }
+        }
+    }
+    undo(store) {
+        for (const [id, pos] of this.beforePositions) {
+            const node = store.node(id);
+            if (node) {
+                node.position = clone(pos);
+            }
+        }
+    }
+}
+/** 启用实例化渲染 */
+class EnableInstancingCommand {
+    nodeIds;
+    label = '启用实例化渲染';
+    groupId;
+    constructor(nodeIds) {
+        this.nodeIds = nodeIds;
+        this.groupId = nextId('inst');
+    }
+    do(store) {
+        if (!store.doc.instanceGroups)
+            store.doc.instanceGroups = [];
+        // 获取 assetId（从第一个节点）
+        const firstNode = store.node(this.nodeIds[0]);
+        if (!firstNode?.assetId)
+            return;
+        // 检查是否已存在同 assetId 的实例组
+        const existing = store.doc.instanceGroups.find(g => g.assetId === firstNode.assetId);
+        if (existing) {
+            // 添加到现有组
+            for (const id of this.nodeIds) {
+                if (!existing.nodeIds.includes(id))
+                    existing.nodeIds.push(id);
+            }
+            this.groupId = existing.id;
+        }
+        else {
+            // 创建新组
+            store.doc.instanceGroups.push({
+                id: this.groupId,
+                assetId: firstNode.assetId,
+                nodeIds: [...this.nodeIds],
+            });
+        }
+    }
+    undo(store) {
+        if (!store.doc.instanceGroups)
+            return;
+        const group = store.doc.instanceGroups.find(g => g.id === this.groupId);
+        if (group) {
+            // 移除添加的节点
+            group.nodeIds = group.nodeIds.filter(id => !this.nodeIds.includes(id));
+            // 如果组为空，删除组
+            if (group.nodeIds.length === 0) {
+                store.doc.instanceGroups = store.doc.instanceGroups.filter(g => g.id !== this.groupId);
+            }
+        }
+    }
+}
+/** 禁用实例化渲染 */
+class DisableInstancingCommand {
+    nodeIds;
+    label = '禁用实例化渲染';
+    removedGroup = null;
+    constructor(nodeIds) {
+        this.nodeIds = nodeIds;
+    }
+    do(store) {
+        if (!store.doc.instanceGroups)
+            return;
+        // 找到包含这些节点的实例组
+        const group = store.doc.instanceGroups.find(g => this.nodeIds.some(id => g.nodeIds.includes(id)));
+        if (group) {
+            // 保存用于 undo
+            this.removedGroup = { id: group.id, assetId: group.assetId, nodeIds: [...group.nodeIds] };
+            // 移除这些节点
+            group.nodeIds = group.nodeIds.filter(id => !this.nodeIds.includes(id));
+            // 如果组为空，删除组
+            if (group.nodeIds.length === 0) {
+                store.doc.instanceGroups = store.doc.instanceGroups.filter(g => g.id !== group.id);
+            }
+        }
+    }
+    undo(store) {
+        if (!this.removedGroup)
+            return;
+        if (!store.doc.instanceGroups)
+            store.doc.instanceGroups = [];
+        // 恢复组
+        const existing = store.doc.instanceGroups.find(g => g.id === this.removedGroup.id);
+        if (existing) {
+            // 恢复节点
+            for (const id of this.removedGroup.nodeIds) {
+                if (!existing.nodeIds.includes(id))
+                    existing.nodeIds.push(id);
+            }
+        }
+        else {
+            // 恢复整个组
+            store.doc.instanceGroups.push({ ...this.removedGroup });
+        }
+    }
+}
 
 /**
  * 粒子系统运行时
@@ -2964,6 +3251,12 @@ class SceneViewer {
     pendingAssetNodes = new Map();
     /** 动画基础变换（nodeId → 数据模型原始变换） */
     animBases = new Map();
+    /** FPS 统计 */
+    fpsFrames = 0;
+    fpsTime = 0;
+    fpsCurrent = 0;
+    /** 场景统计缓存 */
+    statsCache = { vertices: 0, faces: 0, drawCalls: 0, dirty: true };
     /** 缩略图渲染器（离屏） */
     thumbRenderer;
     thumbScene = new THREE.Scene();
@@ -2974,6 +3267,10 @@ class SceneViewer {
     lastFrameTime = 0;
     /** 拖拽中冻结动画 */
     animationFrozen = false;
+    /** 性能模式：true 时使用 renderer（无后处理），false 时使用 composer（有后处理） */
+    performanceMode = false;
+    /** 顶层节点集合（没有父节点的节点，用于视锥剔除优化） */
+    topLevelNodes = new Set();
     /** 相机是否已从文档恢复（只在首次 sync 时恢复一次） */
     cameraRestored = false;
     /** 保存原始材质参数（覆盖前），用于撤销覆盖时恢复 */
@@ -2984,6 +3281,8 @@ class SceneViewer {
     textureCache = new Map();
     /** 标签对象缓存（nodeId → label mesh） */
     labelObjects = new Map();
+    /** 实例化网格缓存（groupId → InstancedMesh 数组） */
+    instanceMeshes = new Map();
     textureLoader = new TextureLoader();
     /** HDRI 环境贴图缓存 */
     hdriTexture = null;
@@ -3061,6 +3360,8 @@ class SceneViewer {
     pathEditor;
     /** 是否为编辑器模式（编辑器模式下动画默认播放，不依赖数据） */
     isEditorMode;
+    /** 相机视角变化回调 */
+    onCameraChange;
     constructor(host, store, cb, dashboardOverlayEl, isEditorMode = false) {
         this.host = host;
         this.store = store;
@@ -3081,6 +3382,22 @@ class SceneViewer {
         this.scene.add(this.gridHelper);
         this.orbit = new OrbitControls(this.camera, this.renderer.domElement);
         this.orbit.enableDamping = true;
+        // 相机视角变化时，保存相机并触发草稿缓存
+        let cameraSaveTimer = null;
+        /** 恢复相机时置 true，阻止触发 cameraChange */
+        let restoringCamera = false;
+        this.orbit.addEventListener('change', () => {
+            if (restoringCamera)
+                return;
+            if (cameraSaveTimer)
+                clearTimeout(cameraSaveTimer);
+            cameraSaveTimer = setTimeout(() => {
+                this.saveCamera();
+                this.onCameraChange?.();
+            }, 500);
+        });
+        // 暴露给 restoreCamera 使用
+        this._setRestoringCamera = (v) => { restoringCamera = v; };
         this.gizmo = new TransformControls(this.camera, this.renderer.domElement);
         this.gizmo.setSize(0.9);
         this.gizmo.addEventListener('dragging-changed', (e) => {
@@ -3165,6 +3482,12 @@ class SceneViewer {
                         obj.traverse(c => { if (c instanceof THREE.Mesh)
                             allMeshes.push(c); });
                 }
+                // 添加 InstancedMesh 到拾取列表
+                for (const meshes of this.instanceMeshes.values()) {
+                    for (const im of meshes) {
+                        allMeshes.push(im);
+                    }
+                }
                 const rect = this.renderer.domElement.getBoundingClientRect();
                 const ndc = new THREE.Vector2(((e.clientX - rect.left) / rect.width) * 2 - 1, -((e.clientY - rect.top) / rect.height) * 2 + 1);
                 this.raycaster.setFromCamera(ndc, this.camera);
@@ -3250,6 +3573,9 @@ class SceneViewer {
                 }
                 return;
             }
+            // 按住了 Ctrl/Meta 时不记录 WASD 移动键，避免 Ctrl+S 等快捷键触发后退
+            if (e.ctrlKey || e.metaKey)
+                return;
             this.keysPressed.add(e.key.toLowerCase());
         };
         this.onKeyUp = (e) => this.keysPressed.delete(e.key.toLowerCase());
@@ -3260,38 +3586,10 @@ class SceneViewer {
         // 初始化后处理
         this.initPostProcessing();
         this.renderer.setAnimationLoop(() => {
-            for (const h of this.helpers.values()) {
-                h.update();
-                // 组的包围盒已预计算，跳过逐帧放大
-                if (h.userData['isGroupHelper'])
-                    continue;
-                // 给包围盒加 3% 空隙，让框与模型之间有视觉间距
-                const pos = h.geometry.attributes['position'].array;
-                let minX = Infinity, minY = Infinity, minZ = Infinity;
-                let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-                for (let i = 0; i < pos.length; i += 3) {
-                    if (pos[i] < minX)
-                        minX = pos[i];
-                    if (pos[i + 1] < minY)
-                        minY = pos[i + 1];
-                    if (pos[i + 2] < minZ)
-                        minZ = pos[i + 2];
-                    if (pos[i] > maxX)
-                        maxX = pos[i];
-                    if (pos[i + 1] > maxY)
-                        maxY = pos[i + 1];
-                    if (pos[i + 2] > maxZ)
-                        maxZ = pos[i + 2];
-                }
-                const cx = (minX + maxX) / 2, cy = (minY + maxY) / 2, cz = (minZ + maxZ) / 2;
-                const pad = 0.03;
-                for (let i = 0; i < pos.length; i += 3) {
-                    pos[i] = cx + (pos[i] - cx) + (pos[i] - cx >= 0 ? pad : -pad);
-                    pos[i + 1] = cy + (pos[i + 1] - cy) + (pos[i + 1] - cy >= 0 ? pad : -pad);
-                    pos[i + 2] = cz + (pos[i + 2] - cz) + (pos[i + 2] - cz >= 0 ? pad : -pad);
-                }
-                h.geometry.attributes['position'].needsUpdate = true;
-            }
+            // TODO: 包围盒按需更新，暂时注释测试性能
+            // for (const h of this.helpers.values()) {
+            //   h.update();
+            // }
             // 更新灯光助手
             for (const h of this.lightHelpers.values()) {
                 if (h instanceof THREE.DirectionalLightHelper || h instanceof THREE.SpotLightHelper) {
@@ -3309,6 +3607,14 @@ class SceneViewer {
             const now = performance.now();
             const dt = this.lastFrameTime ? (now - this.lastFrameTime) / 1000 : 0;
             this.lastFrameTime = now;
+            // FPS 统计
+            this.fpsFrames++;
+            this.fpsTime += dt;
+            if (this.fpsTime >= 0.5) {
+                this.fpsCurrent = Math.round(this.fpsFrames / this.fpsTime);
+                this.fpsFrames = 0;
+                this.fpsTime = 0;
+            }
             // 更新动画
             this.updateAnimations(dt);
             // 更新视觉效果（UV 动画、粒子系统）
@@ -3325,7 +3631,15 @@ class SceneViewer {
             this.constrainCameraToRoom();
             // 更新看板 world 模式
             this.updateDashboard();
-            this.composer.render();
+            // 视锥剔除：隐藏不在相机视锥内的顶层节点
+            this.updateFrustumCulling();
+            // 根据性能模式选择渲染方式
+            if (this.performanceMode) {
+                this.renderer.render(this.scene, this.camera);
+            }
+            else {
+                this.composer.render();
+            }
         });
         // 初始化路径编辑器
         const pathEditorCallbacks = {
@@ -3398,7 +3712,7 @@ class SceneViewer {
     setPathHandleSize(size) {
         this.pathEditor.setHandleSize(size);
     }
-    /** 将当前相机状态写入 SceneDoc（保存前调用） */
+    /** 将当前相机状态写入 SceneDoc（保存前调用，不触发 notifyChanged） */
     saveCamera() {
         this.store.doc.camera = {
             position: [
@@ -3418,6 +3732,8 @@ class SceneViewer {
         const cam = this.store.doc.camera;
         if (!cam)
             return;
+        // 设置标志，阻止 change 事件触发 cameraChange → saveDraft
+        this._setRestoringCamera?.(true);
         this.camera.position.set(...cam.position);
         this.orbit.target.set(...cam.target);
         // 重置 damping 状态，防止残留速度导致位置漂移
@@ -3426,6 +3742,7 @@ class SceneViewer {
         this.orbit.enableDamping = true;
         // 强制相机朝向 target
         this.camera.lookAt(this.orbit.target);
+        this._setRestoringCamera?.(false);
     }
     /** 导出场景为 GLB 文件 */
     exportScene() {
@@ -3472,6 +3789,10 @@ class SceneViewer {
                 this.cameraRestored = false;
                 // 新文档加载：清空资产加载状态，确保资产重新加载
                 this.loadingAssetUrls.clear();
+                // 清空原始材质缓存，避免旧场景的材质状态污染新场景
+                this.originalMaterials.clear();
+                // 重置房间配置缓存，确保 applyRoom 重新应用
+                this.lastRoomKey = '';
             }
         }
         const seen = new Set();
@@ -3600,6 +3921,7 @@ class SceneViewer {
         for (const [id, obj] of [...this.objects]) {
             if (!seen.has(id)) {
                 this.objects.delete(id);
+                this.markStatsDirty();
                 obj.parent?.remove(obj);
                 if (obj instanceof THREE.Mesh) {
                     obj.geometry.dispose();
@@ -3641,6 +3963,31 @@ class SceneViewer {
                 }
             }
         }
+        // 清理不再存在的实例组对应的 InstancedMesh
+        const validGroupIds = new Set((this.store.doc.instanceGroups || []).map(g => g.id));
+        for (const [groupId, meshes] of [...this.instanceMeshes]) {
+            if (!validGroupIds.has(groupId)) {
+                // 恢复原始节点的 visible 状态
+                if (meshes.length > 0) {
+                    const nodeIds = meshes[0].userData['instanceNodeIds'];
+                    if (nodeIds) {
+                        for (const nodeId of nodeIds) {
+                            const obj = this.objects.get(nodeId);
+                            if (obj) {
+                                obj.visible = true;
+                            }
+                        }
+                    }
+                }
+                // 清理 InstancedMesh
+                for (const mesh of meshes) {
+                    mesh.parent?.remove(mesh);
+                    mesh.geometry.dispose();
+                    mesh.material.dispose();
+                }
+                this.instanceMeshes.delete(groupId);
+            }
+        }
         // 层级关系
         for (const n of this.store.doc.nodes) {
             const obj = this.objects.get(n.id);
@@ -3676,6 +4023,10 @@ class SceneViewer {
         this.syncEffects();
         // 同步路径编辑器
         this.pathEditor.sync();
+        // 同步实例化组
+        this.syncInstanceGroups();
+        // 更新顶层节点集合（用于视锥剔除优化）
+        this.updateTopLevelNodes();
         // 应用环境配置
         this.applyEnvironment();
         // 只在首次加载时恢复相机（后续 doc 变更不重置视角）
@@ -3691,6 +4042,203 @@ class SceneViewer {
         this.restoreCamera();
         this.cameraRestored = true;
     }
+    /** 同步实例化组：创建/更新 InstancedMesh */
+    syncInstanceGroups() {
+        const groups = this.store.doc.instanceGroups;
+        if (!groups || groups.length === 0) {
+            // 恢复所有被隐藏的原始节点
+            for (const [groupId, meshes] of this.instanceMeshes) {
+                if (meshes.length > 0) {
+                    const nodeIds = meshes[0].userData['instanceNodeIds'];
+                    if (nodeIds) {
+                        for (const nodeId of nodeIds) {
+                            const obj = this.objects.get(nodeId);
+                            if (obj) {
+                                obj.visible = true;
+                                obj.traverse(child => {
+                                    if (child !== obj)
+                                        child.visible = true;
+                                });
+                            }
+                        }
+                    }
+                }
+                // 清理 InstancedMesh
+                for (const mesh of meshes) {
+                    mesh.parent?.remove(mesh);
+                    mesh.geometry.dispose();
+                    mesh.material.dispose();
+                }
+            }
+            this.instanceMeshes.clear();
+            this.markStatsDirty();
+            return;
+        }
+        const seenGroups = new Set();
+        for (const group of groups) {
+            seenGroups.add(group.id);
+            const nodeIds = group.nodeIds;
+            if (nodeIds.length === 0)
+                continue;
+            // 获取第一个节点作为模板
+            const templateNodeId = nodeIds[0];
+            const templateObj = this.objects.get(templateNodeId);
+            if (!templateObj)
+                continue;
+            // 收集模板对象中的所有 Mesh
+            const templateMeshes = [];
+            templateObj.traverse(child => {
+                if (child instanceof THREE.Mesh) {
+                    templateMeshes.push(child);
+                }
+            });
+            if (templateMeshes.length === 0)
+                continue;
+            // 获取或创建 InstancedMesh 数组
+            let instancedMeshes = this.instanceMeshes.get(group.id);
+            const needsRecreate = !instancedMeshes || instancedMeshes.length !== templateMeshes.length;
+            if (needsRecreate) {
+                // 清理旧的 InstancedMesh
+                if (instancedMeshes) {
+                    for (const mesh of instancedMeshes) {
+                        mesh.parent?.remove(mesh);
+                        mesh.geometry.dispose();
+                        mesh.material.dispose();
+                    }
+                }
+                // 为每个模板 Mesh 创建 InstancedMesh
+                instancedMeshes = [];
+                for (let i = 0; i < templateMeshes.length; i++) {
+                    const templateMesh = templateMeshes[i];
+                    const geometry = templateMesh.geometry;
+                    const material = templateMesh.material.clone();
+                    const instancedMesh = new THREE.InstancedMesh(geometry, material, nodeIds.length);
+                    instancedMesh.userData['instanceGroupId'] = group.id;
+                    instancedMesh.userData['instanceNodeIds'] = nodeIds;
+                    instancedMesh.userData['meshIndex'] = i;
+                    this.scene.add(instancedMesh);
+                    instancedMeshes.push(instancedMesh);
+                }
+                this.instanceMeshes.set(group.id, instancedMeshes);
+                // 隐藏参与实例化的节点及其子 Mesh
+                for (const nodeId of nodeIds) {
+                    const obj = this.objects.get(nodeId);
+                    if (obj) {
+                        obj.visible = false;
+                        obj.traverse(child => {
+                            if (child !== obj)
+                                child.visible = false;
+                        });
+                    }
+                }
+                this.markStatsDirty();
+            }
+            // 此时 instancedMeshes 必定存在
+            if (!instancedMeshes)
+                continue;
+            // 更新每个 InstancedMesh 的实例矩阵
+            for (let meshIdx = 0; meshIdx < instancedMeshes.length; meshIdx++) {
+                const instancedMesh = instancedMeshes[meshIdx];
+                const matrix = new THREE.Matrix4();
+                for (let i = 0; i < nodeIds.length; i++) {
+                    const nodeId = nodeIds[i];
+                    const node = this.store.node(nodeId);
+                    const obj = this.objects.get(nodeId);
+                    if (!node || !obj)
+                        continue;
+                    // 找到对应的 mesh
+                    const meshes = [];
+                    obj.traverse(child => {
+                        if (child instanceof THREE.Mesh) {
+                            meshes.push(child);
+                        }
+                    });
+                    if (meshIdx >= meshes.length)
+                        continue;
+                    const mesh = meshes[meshIdx];
+                    // 计算世界矩阵（确保父链更新）
+                    mesh.updateWorldMatrix(true, true);
+                    matrix.copy(mesh.matrixWorld);
+                    instancedMesh.setMatrixAt(i, matrix);
+                }
+                instancedMesh.instanceMatrix.needsUpdate = true;
+            }
+        }
+        // 清理不再存在的实例组
+        for (const [groupId, meshes] of this.instanceMeshes) {
+            if (!seenGroups.has(groupId)) {
+                for (const mesh of meshes) {
+                    mesh.parent?.remove(mesh);
+                    mesh.geometry.dispose();
+                    mesh.material.dispose();
+                }
+                this.instanceMeshes.delete(groupId);
+                // 恢复原始 mesh 的可见性
+                const nodeIds = meshes[0]?.userData['instanceNodeIds'];
+                if (nodeIds) {
+                    for (const nodeId of nodeIds) {
+                        const obj = this.objects.get(nodeId);
+                        if (obj) {
+                            obj.visible = true;
+                            obj.traverse(child => {
+                                if (child !== obj)
+                                    child.visible = true;
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /** 设置性能模式 */
+    setPerformanceMode(enabled) {
+        if (this.performanceMode === enabled)
+            return;
+        this.performanceMode = enabled;
+        // 性能模式下关闭阴影，否则保持原设置
+        // 注意：shadowMap.enabled 需要在 renderer 创建后设置，不能动态切换
+        // 所以这里只影响渲染通道，阴影由初始化时的环境设置决定
+    }
+    /** 更新顶层节点集合（没有父节点的节点） */
+    updateTopLevelNodes() {
+        this.topLevelNodes.clear();
+        for (const obj of this.objects.values()) {
+            if (obj.parent === this.scene || obj.parent === null) {
+                this.topLevelNodes.add(obj);
+            }
+        }
+    }
+    /** 视锥剔除：隐藏不在相机视锥内的顶层节点，大幅减少 CPU 遍历开销 */
+    updateFrustumCulling() {
+        if (this.topLevelNodes.size === 0)
+            return;
+        // 创建相机视锥
+        const frustum = new THREE.Frustum();
+        const projScreenMatrix = new THREE.Matrix4();
+        projScreenMatrix.multiplyMatrices(this.camera.projectionMatrix, this.camera.matrixWorldInverse);
+        frustum.setFromProjectionMatrix(projScreenMatrix);
+        let hiddenCount = 0;
+        let visibleCount = 0;
+        for (const obj of this.topLevelNodes) {
+            // 计算包围盒（世界空间）
+            obj.updateWorldMatrix(false, false);
+            const bbox = new THREE.Box3().setFromObject(obj);
+            // 判断是否与视锥相交
+            const inFrustum = frustum.intersectsBox(bbox);
+            // 只在可见性变化时才设置，避免不必要的状态更新
+            if (obj.visible !== inFrustum) {
+                obj.visible = inFrustum;
+            }
+            if (inFrustum)
+                visibleCount++;
+            else
+                hiddenCount++;
+        }
+        // 每 60 帧输出一次调试信息
+        if (this.fpsFrames % 60 === 0) {
+            console.log(`[视锥剔除] 顶层节点：${this.topLevelNodes.size}，可见：${visibleCount}，隐藏：${hiddenCount}`);
+        }
+    }
     /** 创建标签 mesh */
     createLabel(text) {
         const canvas = document.createElement('canvas');
@@ -3896,7 +4444,7 @@ class SceneViewer {
         const d = room.depth ?? 30;
         const floorColor = (room.floorUseBaseColor ?? true) ? (room.floorColor ?? '#808080') : '#ffffff';
         const wallColor = (room.wallUseBaseColor ?? true) ? (room.wallColor ?? '#c8c0b0') : '#ffffff';
-        const ceilingColor = (room.ceilingUseBaseColor ?? true) ? (room.ceilingColor ?? '#a0a0a0') : '#ffffff';
+        const ceilingColor = (room.ceilingUseBaseColor ?? true) ? (room.ceilingColor ?? '#c8c0b0') : '#ffffff';
         this.disposeRoom();
         this.scene.background = null;
         // 构建 6 面材质：[+X墙, -X墙, +Y天花板, -Y地板, +Z墙, -Z墙]
@@ -4051,13 +4599,14 @@ class SceneViewer {
             move.sub(right);
         if (keys.has('d'))
             move.add(right);
-        if (keys.has('q') || keys.has('shift'))
+        if (keys.has('q'))
             move.y -= 1;
         if (keys.has('e') || keys.has(' '))
             move.y += 1;
         if (move.lengthSq() === 0)
             return;
-        move.normalize().multiplyScalar(this.moveSpeed * 0.016); // 假设 60fps，约 16ms/帧
+        const speed = keys.has('shift') ? this.moveSpeed * 3 : this.moveSpeed; // Shift 加速 3 倍
+        move.normalize().multiplyScalar(speed * 0.016); // 假设 60fps，约 16ms/帧
         // 同时移动 orbit target 和 camera
         this.orbit.target.add(move);
         this.camera.position.add(move);
@@ -4128,15 +4677,13 @@ class SceneViewer {
         this.composer.addPass(renderPass);
         // 2. SSAO（屏幕空间环境光遮蔽）—— 增强角落/缝隙的阴影深度
         const ssaoPass = new SSAOPass(this.scene, this.camera, w, h);
-        ssaoPass.kernelRadius = 16; // 采样半径
-        ssaoPass.minDistance = 0.005; // 最小距离阈值
-        ssaoPass.maxDistance = 0.1; // 最大距离阈值
+        ssaoPass.kernelRadius = 16;
+        ssaoPass.minDistance = 0.005;
+        ssaoPass.maxDistance = 0.1;
         ssaoPass.output = SSAOPass.OUTPUT.Default;
         this.composer.addPass(ssaoPass);
         // 3. Bloom（泛光）—— 高亮区域发光效果
-        const bloomPass = new UnrealBloomPass(new THREE.Vector2(w, h), 0.3, // strength：泛光强度（低值，避免过曝）
-        0.4, // radius：泛光扩散范围
-        0.85);
+        const bloomPass = new UnrealBloomPass(new THREE.Vector2(w, h), 0.3, 0.4, 0.85);
         this.composer.addPass(bloomPass);
         // 4. 输出通道（色调映射 + 色彩空间转换）
         const outputPass = new OutputPass();
@@ -4719,21 +5266,21 @@ class SceneViewer {
                     const rows = widget.dataPoints.map((dp, i) => {
                         const dpValue = this.dashboardValues.get(`${widget.id}_dp${i}`);
                         const dpDisplay = this.formatValue(dpValue, { decimals: widget.decimals });
-                        return `
-              <div style="display: flex; justify-content: space-between; align-items: center; padding: 4px 0; border-bottom: 1px solid rgba(255,255,255,0.05);">
-                <span style="font-size: 12px; opacity: 0.7;">${dp.label}</span>
-                <span style="font-size: 16px; font-weight: 500;">${dpDisplay}${dp.unit ? `<small style="font-size: 11px; opacity: 0.6; margin-left: 2px;">${dp.unit}</small>` : ''}</span>
-              </div>
+                        return `
+              <div style="display: flex; justify-content: space-between; align-items: center; padding: 4px 0; border-bottom: 1px solid rgba(255,255,255,0.05);">
+                <span style="font-size: 12px; opacity: 0.7;">${dp.label}</span>
+                <span style="font-size: 16px; font-weight: 500;">${dpDisplay}${dp.unit ? `<small style="font-size: 11px; opacity: 0.6; margin-left: 2px;">${dp.unit}</small>` : ''}</span>
+              </div>
             `;
                     }).join('');
                     el.innerHTML = rows;
                 }
                 else {
                     // 兼容旧的单值模式
-                    el.innerHTML = `
-            <div style="font-size: 12px; opacity: 0.7; margin-bottom: 4px;">${widget.label || ''}</div>
-            <div style="font-size: 28px; font-weight: 600;">${displayValue}</div>
-            ${widget.unit ? `<div style="font-size: 12px; opacity: 0.6; margin-top: 2px;">${widget.unit}</div>` : ''}
+                    el.innerHTML = `
+            <div style="font-size: 12px; opacity: 0.7; margin-bottom: 4px;">${widget.label || ''}</div>
+            <div style="font-size: 28px; font-weight: 600;">${displayValue}</div>
+            ${widget.unit ? `<div style="font-size: 12px; opacity: 0.6; margin-top: 2px;">${widget.unit}</div>` : ''}
           `;
                 }
                 break;
@@ -4742,39 +5289,39 @@ class SceneViewer {
                 break;
             case 'status':
                 const statusColor = this.getStatusColor(value, widget);
-                el.innerHTML = `
-          <div style="display: flex; align-items: center; gap: 8px;">
-            <div style="width: 12px; height: 12px; border-radius: 50%; background: ${statusColor};"></div>
-            <div style="font-size: 14px;">${widget.label || ''}</div>
-          </div>
+                el.innerHTML = `
+          <div style="display: flex; align-items: center; gap: 8px;">
+            <div style="width: 12px; height: 12px; border-radius: 50%; background: ${statusColor};"></div>
+            <div style="font-size: 14px;">${widget.label || ''}</div>
+          </div>
         `;
                 break;
             case 'progress':
                 const progress = this.calcProgress(value, widget);
-                el.innerHTML = `
-          <div style="font-size: 12px; opacity: 0.7; margin-bottom: 8px;">${widget.label || ''}</div>
-          <div style="height: 8px; background: rgba(255,255,255,0.1); border-radius: 4px; overflow: hidden;">
-            <div style="height: 100%; width: ${progress}%; background: #4f83cc; transition: width 0.3s;"></div>
-          </div>
-          <div style="font-size: 12px; text-align: right; margin-top: 4px;">${displayValue}</div>
+                el.innerHTML = `
+          <div style="font-size: 12px; opacity: 0.7; margin-bottom: 8px;">${widget.label || ''}</div>
+          <div style="height: 8px; background: rgba(255,255,255,0.1); border-radius: 4px; overflow: hidden;">
+            <div style="height: 100%; width: ${progress}%; background: #4f83cc; transition: width 0.3s;"></div>
+          </div>
+          <div style="font-size: 12px; text-align: right; margin-top: 4px;">${displayValue}</div>
         `;
                 break;
             case 'gauge':
                 // 简化版仪表：只显示数值
                 const gaugeProgress = this.calcProgress(value, widget);
-                el.innerHTML = `
-          <div style="font-size: 12px; opacity: 0.7; margin-bottom: 4px;">${widget.label || ''}</div>
-          <div style="font-size: 24px; font-weight: 600; text-align: center;">${displayValue}</div>
-          <div style="height: 4px; background: rgba(255,255,255,0.1); border-radius: 2px; margin-top: 8px; overflow: hidden;">
-            <div style="height: 100%; width: ${gaugeProgress}%; background: #4f83cc;"></div>
-          </div>
+                el.innerHTML = `
+          <div style="font-size: 12px; opacity: 0.7; margin-bottom: 4px;">${widget.label || ''}</div>
+          <div style="font-size: 24px; font-weight: 600; text-align: center;">${displayValue}</div>
+          <div style="height: 4px; background: rgba(255,255,255,0.1); border-radius: 2px; margin-top: 8px; overflow: hidden;">
+            <div style="height: 100%; width: ${gaugeProgress}%; background: #4f83cc;"></div>
+          </div>
         `;
                 break;
             case 'chart':
                 // 简化版：显示当前值
-                el.innerHTML = `
-          <div style="font-size: 12px; opacity: 0.7; margin-bottom: 4px;">${widget.label || ''}</div>
-          <div style="font-size: 20px; font-weight: 500;">${displayValue}</div>
+                el.innerHTML = `
+          <div style="font-size: 12px; opacity: 0.7; margin-bottom: 4px;">${widget.label || ''}</div>
+          <div style="font-size: 20px; font-weight: 500;">${displayValue}</div>
         `;
                 break;
         }
@@ -5433,6 +5980,59 @@ class SceneViewer {
         }
         this.lightHelpers.clear();
         this.lightTargets.clear();
+        // 清理贴图缓存
+        for (const tex of this.textureCache.values())
+            tex.dispose();
+        this.textureCache.clear();
+        // 清理资产缓存（GLB 模型的几何体/材质/纹理）
+        for (const group of this.assetCache.values()) {
+            group.traverse(child => {
+                if (child instanceof THREE.Mesh) {
+                    child.geometry.dispose();
+                    const mats = Array.isArray(child.material) ? child.material : [child.material];
+                    for (const m of mats) {
+                        if (m instanceof THREE.MeshStandardMaterial) {
+                            m.map?.dispose();
+                            m.normalMap?.dispose();
+                            m.roughnessMap?.dispose();
+                            m.metalnessMap?.dispose();
+                            m.emissiveMap?.dispose();
+                        }
+                        m.dispose();
+                    }
+                }
+            });
+        }
+        this.assetCache.clear();
+        this.originalMaterials.clear();
+        // 清理标签
+        for (const label of this.labelObjects.values()) {
+            label.geometry.dispose();
+            label.material.map?.dispose();
+            label.material.dispose();
+        }
+        this.labelObjects.clear();
+        // 清理告警弹窗
+        for (const popup of this.alarmPopups.values()) {
+            popup.geometry.dispose();
+            popup.material.map?.dispose();
+            popup.material.dispose();
+        }
+        this.alarmPopups.clear();
+        this.alarmCreationTime.clear();
+        // 清理屏幕内容定时器
+        for (const state of this.screenContentStates.values()) {
+            clearInterval(state.intervalId);
+        }
+        this.screenContentStates.clear();
+        // 清理灯光选择器
+        for (const picker of this.lightPickers.values()) {
+            picker.geometry.dispose();
+            picker.material.dispose();
+        }
+        this.lightPickers.clear();
+        // 清理缩略图渲染器
+        this.thumbRenderer?.dispose();
         // 清理看板 DOM 和定时器
         for (const el of this.dashboardElements.values()) {
             el.remove();
@@ -5466,6 +6066,41 @@ class SceneViewer {
         mesh.receiveShadow = true;
         return mesh;
     }
+    /**
+     * 参考 JCISceneParser 的 GdeepCloneMaterials
+     * 几何体共享（不 clone），材质独立克隆
+     * - Object3D/Group：clone(false) 不递归，手动处理 children
+     * - Mesh：共享 geometry，克隆 material
+     * - Light：完整克隆
+     */
+    gdeepCloneMaterials(obj, nodeId) {
+        let clone;
+        if (obj instanceof THREE.Mesh) {
+            // Mesh：几何体共享，材质克隆（关键：保留 geometry 引用）
+            const material = obj.material ? obj.material.clone() : undefined;
+            clone = new THREE.Mesh(obj.geometry, material);
+            clone.castShadow = true;
+            clone.receiveShadow = true;
+            // 启用视锥剔除：不在相机视锥体内的 Mesh 不参与渲染
+            clone.frustumCulled = true;
+        }
+        else if (obj instanceof THREE.Light) {
+            // 灯光：完整克隆
+            clone = obj.clone();
+        }
+        else {
+            // Group 或其他 Object3D：clone(false) 不递归克隆 children
+            clone = obj.clone(false);
+        }
+        // 复制通用属性
+        clone.name = obj.name;
+        clone.userData = { ...obj.userData, 'id': nodeId };
+        // 递归处理 children
+        for (const child of obj.children) {
+            clone.add(this.gdeepCloneMaterials(child, nodeId));
+        }
+        return clone;
+    }
     /** 判断对象是否为灯光 */
     isLight(obj) {
         return obj instanceof THREE.Light;
@@ -5767,21 +6402,8 @@ class SceneViewer {
         const node = this.store.node(nodeId);
         if (!node)
             return;
-        const clone = assetScene.clone(true);
-        clone.userData['id'] = nodeId;
-        // 彻底断开材质共享：clone(true) 不会 clone 材质（只是引用复制），
-        // 需要给每个 mesh 都分配独立材质副本，避免跨节点/跨 mesh 共享
-        clone.traverse(child => {
-            if (child instanceof THREE.Mesh) {
-                child.userData['id'] = nodeId;
-                child.castShadow = true;
-                child.receiveShadow = true;
-                const mat = child.material;
-                if (mat) {
-                    child.material = mat.clone();
-                }
-            }
-        });
+        // 几何体共享，材质独立克隆（参考 JCISceneParser 的 GdeepCloneMaterials）
+        const clone = this.gdeepCloneMaterials(assetScene, nodeId);
         // 将 pivot 校正到几何中心：把子对象整体反向偏移 -center
         // 这样外层 clone 的 pivot 就落在几何中心，旋转/缩放/吸附都以此为基准
         const box = new THREE.Box3().setFromObject(clone);
@@ -5834,6 +6456,7 @@ class SceneViewer {
         clone.scale.set(...node.scale);
         clone.visible = node.visible;
         clone.userData['assetLoaded'] = true;
+        this.markStatsDirty();
         // 层级关系
         const parent = this.store.parentOf(nodeId);
         const target = (parent && this.objects.get(parent.id)) || this.scene;
@@ -6088,13 +6711,11 @@ class SceneViewer {
         obj.traverse(child => {
             if (!(child instanceof THREE.Mesh))
                 return;
-            // 给没有 name 的 mesh 设置默认名称（与 getMeshNames 保持一致）
             if (!child.name)
                 child.name = `mesh_${unnamedIndex++}`;
             let mat = child.material;
             if (!mat)
                 return;
-            // OBJ 加载的可能是其他材质类型，转换为 MeshStandardMaterial
             if (!(mat instanceof THREE.MeshStandardMaterial)) {
                 const oldMat = mat;
                 const newMat = new THREE.MeshStandardMaterial();
@@ -6111,7 +6732,6 @@ class SceneViewer {
                 child.material = newMat;
                 mat = newMat;
             }
-            // 如果材质被多个 mesh 共享，给当前 mesh 分配独立副本
             if (seenMaterials.has(mat)) {
                 const independentMat = mat.clone();
                 child.material = independentMat;
@@ -6127,14 +6747,13 @@ class SceneViewer {
     resetMaterialToOriginal(nodeId, meshName, mat) {
         const orig = this.originalMaterials.get(nodeId)?.[meshName];
         if (!orig)
-            return; // 没有保存的原始材质，说明从未被覆盖过
+            return;
         mat.color.set(orig.color);
         mat.opacity = orig.opacity;
         mat.transparent = orig.transparent;
         mat.roughness = orig.roughness;
         mat.metalness = orig.metalness;
         mat.emissive.set(orig.emissive);
-        // 恢复原始贴图
         mat.map = orig.map ?? null;
         mat.normalMap = orig.normalMap ?? null;
         mat.roughnessMap = orig.roughnessMap ?? null;
@@ -6245,9 +6864,31 @@ class SceneViewer {
                 if (obj && !this.helpers.has(id)) {
                     if (node.primitive === 'asset' && !obj.userData['assetLoaded'])
                         continue;
-                    const h = new THREE.BoxHelper(obj, 0xfadb14);
+                    // 计算 obj 的局部空间包围盒（忽略自身 transform，只看子节点）
+                    obj.updateWorldMatrix(true, false);
+                    const invObjMatrix = obj.matrixWorld.clone().invert();
+                    const localBox = new THREE.Box3();
+                    obj.traverse((child) => {
+                        const mesh = child;
+                        if (!mesh.isMesh || !mesh.geometry?.attributes['position'])
+                            return;
+                        mesh.updateWorldMatrix(true, false);
+                        const pos = mesh.geometry.attributes['position'];
+                        const tempVec = new THREE.Vector3();
+                        // mesh 相对于 obj 的变换
+                        const relMatrix = mesh.matrixWorld.clone().premultiply(invObjMatrix);
+                        for (let i = 0; i < pos.count; i++) {
+                            tempVec.fromBufferAttribute(pos, i);
+                            tempVec.applyMatrix4(relMatrix);
+                            localBox.expandByPoint(tempVec);
+                        }
+                    });
+                    localBox.expandByScalar(0.03);
+                    const h = new THREE.BoxHelper(new THREE.Object3D(), 0xfadb14);
+                    h.geometry.dispose();
+                    h.geometry = this.createBoxGeometryFromMinMax(localBox.min, localBox.max);
                     this.helpers.set(id, h);
-                    this.scene.add(h);
+                    obj.add(h);
                 }
             }
         }
@@ -6294,6 +6935,20 @@ class SceneViewer {
         geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
         return geometry;
     }
+    /** 用局部坐标 min/max 创建包围盒几何体 */
+    createBoxGeometryFromMinMax(min, max) {
+        const positions = new Float32Array([
+            min.x, min.y, max.z, max.x, min.y, max.z, max.x, min.y, max.z, max.x, max.y, max.z, max.x, max.y, max.z,
+            min.x, max.y, max.z, min.x, max.y, max.z, min.x, min.y, max.z,
+            min.x, min.y, min.z, max.x, min.y, min.z, max.x, min.y, min.z, max.x, max.y, min.z, max.x, max.y, min.z,
+            min.x, max.y, min.z, min.x, max.y, min.z, min.x, min.y, min.z,
+            min.x, min.y, min.z, min.x, min.y, max.z, max.x, min.y, min.z, max.x, min.y, max.z, max.x, max.y, min.z,
+            max.x, max.y, max.z, min.x, max.y, min.z, min.x, max.y, max.z,
+        ]);
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        return geometry;
+    }
     /** 计算 group 的所有后代的包围盒（本地空间，相对于组的 Object3D） */
     computeGroupLocalBounds(groupId) {
         const box = new THREE.Box3();
@@ -6371,8 +7026,30 @@ class SceneViewer {
                 });
             }
         }
+        // 添加 InstancedMesh 到拾取列表
+        for (const meshes of this.instanceMeshes.values()) {
+            for (const im of meshes) {
+                allMeshes.push(im);
+            }
+        }
         const hits = this.raycaster.intersectObjects(allMeshes, false);
-        const id = hits[0]?.object.userData['id'] ?? null;
+        if (hits.length === 0) {
+            this.cb.onSelect({ id: null, additive: e.ctrlKey || e.metaKey });
+            return;
+        }
+        const hit = hits[0];
+        const obj = hit.object;
+        // 检查是否是 InstancedMesh
+        if (obj instanceof THREE.InstancedMesh && hit.instanceId !== undefined) {
+            const nodeIds = obj.userData['instanceNodeIds'];
+            if (nodeIds && hit.instanceId < nodeIds.length) {
+                const id = nodeIds[hit.instanceId];
+                this.cb.onSelect({ id, additive: e.ctrlKey || e.metaKey });
+                return;
+            }
+        }
+        // 普通 Mesh
+        const id = obj.userData['id'] ?? null;
         this.cb.onSelect({ id, additive: e.ctrlKey || e.metaKey });
     }
     // ── 框选方法 ──
@@ -6428,6 +7105,9 @@ class SceneViewer {
             const node = this.store.node(id);
             if (!node)
                 continue;
+            // 跳过子节点（只选顶层对象）
+            if (this.store.parentOf(id))
+                continue;
             const center = new THREE.Vector3();
             if (obj instanceof THREE.Mesh) {
                 obj.getWorldPosition(center);
@@ -6561,6 +7241,192 @@ class SceneViewer {
             Math.round(hit.z * 100) / 100,
         ];
     }
+    /** 获取当前 FPS */
+    getFps() {
+        return this.fpsCurrent;
+    }
+    /** 标记场景统计过期（模型加载/删除后调用） */
+    markStatsDirty() {
+        this.statsCache.dirty = true;
+    }
+    /** 获取场景顶点数和三角面数（带缓存，只统计根节点避免重复） */
+    getSceneStats() {
+        if (!this.statsCache.dirty)
+            return { vertices: this.statsCache.vertices, faces: this.statsCache.faces, drawCalls: this.statsCache.drawCalls };
+        console.log('[getSceneStats] 开始统计场景数据');
+        let vertices = 0;
+        let faces = 0;
+        let drawCalls = 0;
+        // 收集所有被实例化的节点 ID
+        const instancedNodeIds = new Set();
+        for (const group of this.store.doc.instanceGroups || []) {
+            for (const nodeId of group.nodeIds) {
+                instancedNodeIds.add(nodeId);
+            }
+        }
+        console.log('[getSceneStats] 被实例化的节点数:', instancedNodeIds.size);
+        // 只遍历逻辑根节点（无父节点的），traverse 自然覆盖所有后代，避免子节点被重复计数
+        for (const [id, obj] of this.objects) {
+            if (this.store.parentOf(id))
+                continue; // 有父节点，跳过（会被父 traverse 覆盖）
+            // 如果这个节点被实例化了，跳过（由 InstancedMesh 统计）
+            if (instancedNodeIds.has(id)) {
+                console.log('[getSceneStats] 跳过被实例化的节点:', id);
+                continue;
+            }
+            obj.traverse(child => {
+                // 跳过不可见的对象（包括被实例化隐藏的）
+                // 需要检查对象本身及其所有祖先的 visible 状态
+                let current = child;
+                const visibleChain = [];
+                while (current) {
+                    visibleChain.push(`${current.name || 'unnamed'}(visible=${current.visible})`);
+                    if (!current.visible) {
+                        console.log('[getSceneStats] 跳过不可见对象:', child.name || 'unnamed', '祖先链:', visibleChain.reverse().join(' -> '));
+                        return;
+                    }
+                    current = current.parent;
+                }
+                if (!child.isMesh)
+                    return;
+                const mesh = child;
+                // 跳过 InstancedMesh（后面统一统计 instanceMeshes）
+                if (mesh instanceof THREE.InstancedMesh) {
+                    console.log('[getSceneStats] 跳过 InstancedMesh（在 traverse 中）:', mesh.name || 'unnamed');
+                    return;
+                }
+                console.log('[getSceneStats] 统计 mesh（在 traverse 中）:', mesh.name || 'unnamed', '几何体顶点数:', mesh.geometry.attributes['position']?.count || 0, '祖先链:', visibleChain.reverse().join(' -> '));
+                drawCalls += 1;
+                const geo = mesh.geometry;
+                if (!geo.index) {
+                    const pos = geo.attributes['position'];
+                    if (pos) {
+                        vertices += pos.count;
+                        faces += pos.count / 3;
+                    }
+                }
+                else {
+                    const pos = geo.attributes['position'];
+                    if (pos)
+                        vertices += pos.count;
+                    faces += geo.index.count / 3;
+                }
+            });
+        }
+        // 统计 InstancedMesh
+        console.log('[getSceneStats] 统计独立的 InstancedMesh，组数:', this.instanceMeshes.size);
+        for (const [groupId, instancedMeshArray] of this.instanceMeshes) {
+            for (const instancedMesh of instancedMeshArray) {
+                drawCalls += 1;
+                const geo = instancedMesh.geometry;
+                if (!geo.index) {
+                    const pos = geo.attributes['position'];
+                    if (pos) {
+                        vertices += pos.count;
+                        faces += pos.count / 3;
+                    }
+                }
+                else {
+                    const pos = geo.attributes['position'];
+                    if (pos)
+                        vertices += pos.count;
+                    faces += geo.index.count / 3;
+                }
+            }
+        }
+        console.log('[getSceneStats] 最终统计结果 - 顶点:', vertices, '面:', faces, 'DrawCalls:', drawCalls);
+        this.statsCache.vertices = vertices;
+        this.statsCache.faces = faces;
+        this.statsCache.drawCalls = drawCalls;
+        this.statsCache.dirty = false;
+        return { vertices, faces, drawCalls };
+    }
+    /** 获取指定节点的顶点数、面数、DrawCalls */
+    getNodeStats(nodeIds) {
+        let vertices = 0;
+        let faces = 0;
+        let drawCalls = 0;
+        // 收集所有被实例化的节点 ID
+        const instancedNodeIds = new Set();
+        for (const group of this.store.doc.instanceGroups || []) {
+            for (const nodeId of group.nodeIds) {
+                instancedNodeIds.add(nodeId);
+            }
+        }
+        // 统计被选中的节点中有多少被实例化了
+        const selectedInstancedCount = nodeIds.filter(id => instancedNodeIds.has(id)).length;
+        // 如果有被实例化的节点，统计 InstancedMesh
+        if (selectedInstancedCount > 0) {
+            // 找到对应的实例组
+            for (const group of this.store.doc.instanceGroups || []) {
+                // 检查这个组是否包含选中的节点
+                const hasSelectedNode = group.nodeIds.some(id => nodeIds.includes(id));
+                if (!hasSelectedNode)
+                    continue;
+                // 统计这个组的 InstancedMesh
+                const instancedMeshArray = this.instanceMeshes.get(group.id);
+                if (instancedMeshArray) {
+                    for (const instancedMesh of instancedMeshArray) {
+                        drawCalls += 1;
+                        const geo = instancedMesh.geometry;
+                        if (!geo.index) {
+                            const pos = geo.attributes['position'];
+                            if (pos) {
+                                vertices += pos.count;
+                                faces += pos.count / 3;
+                            }
+                        }
+                        else {
+                            const pos = geo.attributes['position'];
+                            if (pos)
+                                vertices += pos.count;
+                            faces += geo.index.count / 3;
+                        }
+                    }
+                }
+            }
+        }
+        // 统计未被实例化的选中节点
+        for (const id of nodeIds) {
+            if (instancedNodeIds.has(id))
+                continue; // 跳过被实例化的节点
+            const obj = this.objects.get(id);
+            if (!obj)
+                continue;
+            obj.traverse(child => {
+                if (!child.isMesh)
+                    return;
+                drawCalls++;
+                const mesh = child;
+                const geo = mesh.geometry;
+                if (!geo.index) {
+                    const pos = geo.attributes['position'];
+                    if (pos) {
+                        vertices += pos.count;
+                        faces += pos.count / 3;
+                    }
+                }
+                else {
+                    const pos = geo.attributes['position'];
+                    if (pos)
+                        vertices += pos.count;
+                    faces += geo.index.count / 3;
+                }
+            });
+        }
+        return { vertices, faces, drawCalls };
+    }
+    /** 获取节点的世界空间包围盒 */
+    getObjectBoundingBox(nodeId) {
+        const obj = this.objects.get(nodeId);
+        if (!obj)
+            return null;
+        const box = new THREE.Box3().setFromObject(obj);
+        return {
+            min: [box.min.x, box.min.y, box.min.z],
+            max: [box.max.x, box.max.y, box.max.z],
+        };
+    }
 }
 
 /**
@@ -6578,6 +7444,7 @@ class SceneViewComponent {
     transformEnd = new EventEmitter();
     dropAsset = new EventEmitter();
     thumbnailGenerated = new EventEmitter();
+    cameraChange = new EventEmitter();
     pathPointMoved = new EventEmitter();
     addPathPoint = new EventEmitter();
     deletePathPoint = new EventEmitter();
@@ -6604,7 +7471,11 @@ class SceneViewComponent {
                 onSegmentRightClick: (nodeId, effectIndex, segmentIndex, position, event) => this.zone.run(() => this.segmentRightClick.emit({ nodeId, effectIndex, segmentIndex, position, event })),
                 onModelSurfaceClick: (nodeId, effectIndex, position, event) => this.zone.run(() => this.modelSurfaceClick.emit({ nodeId, effectIndex, position, event })),
                 onMovePathPointToEnd: (nodeId, effectIndex, pointIndex, toStart) => this.zone.run(() => this.movePathPointToEnd.emit({ nodeId, effectIndex, pointIndex, toStart })),
-            }, this.dashboardOverlay.nativeElement, this.isEditorMode);
+            });
+            // 相机视角变化回调
+            this.viewer.onCameraChange = () => {
+                this.zone.run(() => this.cameraChange.emit());
+            };
             this.viewer.setMode(this.mode);
         });
     }
@@ -6747,6 +7618,10 @@ class SceneViewComponent {
     hideAlarm(nodeId) {
         this.viewer?.hideAlarm(nodeId);
     }
+    /** 设置性能模式 */
+    setPerformanceMode(enabled) {
+        this.viewer?.setPerformanceMode(enabled);
+    }
     /** 拖拽悬停：允许放置 */
     onDragOver(e) {
         e.preventDefault();
@@ -6773,17 +7648,29 @@ class SceneViewComponent {
     getViewer() {
         return this.viewer;
     }
+    getFps() {
+        return this.viewer?.getFps() ?? 0;
+    }
+    getSceneStats() {
+        return this.viewer?.getSceneStats() ?? { vertices: 0, faces: 0, drawCalls: 0 };
+    }
+    getNodeStats(nodeIds) {
+        return this.viewer?.getNodeStats(nodeIds) ?? { vertices: 0, faces: 0, drawCalls: 0 };
+    }
+    getObjectBoundingBox(nodeId) {
+        return this.viewer?.getObjectBoundingBox(nodeId) ?? null;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.34", ngImport: i0, type: SceneViewComponent, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.34", type: SceneViewComponent, isStandalone: true, selector: "twin-scene-view", inputs: { store: "store", mode: "mode", isEditorMode: "isEditorMode" }, outputs: { select: "select", transformEnd: "transformEnd", dropAsset: "dropAsset", thumbnailGenerated: "thumbnailGenerated", pathPointMoved: "pathPointMoved", addPathPoint: "addPathPoint", deletePathPoint: "deletePathPoint", pathEditingChanged: "pathEditingChanged", pathPointRightClick: "pathPointRightClick", segmentRightClick: "segmentRightClick", modelSurfaceClick: "modelSurfaceClick", movePathPointToEnd: "movePathPointToEnd" }, viewQueries: [{ propertyName: "host", first: true, predicate: ["host"], descendants: true, static: true }, { propertyName: "dashboardOverlay", first: true, predicate: ["dashboardOverlay"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: `
-    <div #host class="scene-host" (dragover)="onDragOver($event)" (drop)="onDrop($event)"></div>
-    <div #dashboardOverlay class="dashboard-overlay"></div>
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.34", type: SceneViewComponent, isStandalone: true, selector: "twin-scene-view", inputs: { store: "store", mode: "mode", isEditorMode: "isEditorMode" }, outputs: { select: "select", transformEnd: "transformEnd", dropAsset: "dropAsset", thumbnailGenerated: "thumbnailGenerated", cameraChange: "cameraChange", pathPointMoved: "pathPointMoved", addPathPoint: "addPathPoint", deletePathPoint: "deletePathPoint", pathEditingChanged: "pathEditingChanged", pathPointRightClick: "pathPointRightClick", segmentRightClick: "segmentRightClick", modelSurfaceClick: "modelSurfaceClick", movePathPointToEnd: "movePathPointToEnd" }, viewQueries: [{ propertyName: "host", first: true, predicate: ["host"], descendants: true, static: true }, { propertyName: "dashboardOverlay", first: true, predicate: ["dashboardOverlay"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div #host class="scene-host" (dragover)="onDragOver($event)" (drop)="onDrop($event)"></div>
+    <div #dashboardOverlay class="dashboard-overlay"></div>
   `, isInline: true, styles: [":host{display:block;width:100%;height:100%;position:relative}.scene-host{width:100%;height:100%;overflow:hidden}.scene-host canvas{display:block}.dashboard-overlay{position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;overflow:hidden}.dashboard-overlay .dashboard-widget{pointer-events:auto}\n"] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.34", ngImport: i0, type: SceneViewComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'twin-scene-view', standalone: true, template: `
-    <div #host class="scene-host" (dragover)="onDragOver($event)" (drop)="onDrop($event)"></div>
-    <div #dashboardOverlay class="dashboard-overlay"></div>
+            args: [{ selector: 'twin-scene-view', standalone: true, template: `
+    <div #host class="scene-host" (dragover)="onDragOver($event)" (drop)="onDrop($event)"></div>
+    <div #dashboardOverlay class="dashboard-overlay"></div>
   `, styles: [":host{display:block;width:100%;height:100%;position:relative}.scene-host{width:100%;height:100%;overflow:hidden}.scene-host canvas{display:block}.dashboard-overlay{position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;overflow:hidden}.dashboard-overlay .dashboard-widget{pointer-events:auto}\n"] }]
         }], ctorParameters: () => [{ type: i0.NgZone }], propDecorators: { host: [{
                 type: ViewChild,
@@ -6805,6 +7692,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.34", ngImpo
                 type: Output
             }], thumbnailGenerated: [{
                 type: Output
+            }], cameraChange: [{
+                type: Output
             }], pathPointMoved: [{
                 type: Output
             }], addPathPoint: [{
@@ -6834,5 +7723,5 @@ const DRACO_ENCODER_PATH = 'assets/draco/encoder/';
  * Generated bundle index. Do not edit.
  */
 
-export { AddAnimationCommand, AddEffectCommand, AddNodeCommand, BatchRemoveCommand, DRACO_DECODER_PATH, DRACO_ENCODER_PATH, FlyPathCommand, GroupCommand, History, InsertPathPointCommand, KeyframeCommand, MaterialOverrideCommand, MovePathPointToEndCommand, ParticleRuntime, PathEditor, PathParticleRuntime, RemoveAnimationCommand, RemoveEffectCommand, RemoveNodeCommand, RemovePathPointCommand, ReparentCommand, SceneStore, SceneViewComponent, SceneViewer, SegmentedPath, SetAlarmCommand, SetDashboardCommand, SetEnvironmentCommand, SetLightPropertyCommand, SetNodeNameCommand, SetNodeTextCommand, SyncMaterialCommand, ToggleSegmentTypeCommand, TransformCommand, UngroupCommand, UpdateAnimationCommand, UpdateEffectCommand, UpdatePathPointsCommand, clone, createNode, createSceneDoc, nextId };
+export { AddAnimationCommand, AddEffectCommand, AddNodeCommand, AlignCommand, BatchAddCommand, BatchRemoveCommand, DRACO_DECODER_PATH, DRACO_ENCODER_PATH, DisableInstancingCommand, EnableInstancingCommand, FlyPathCommand, GroupCommand, History, InsertPathPointCommand, KeyframeCommand, MaterialOverrideCommand, MovePathPointToEndCommand, ParticleRuntime, PathEditor, PathParticleRuntime, RemoveAnimationCommand, RemoveEffectCommand, RemoveNodeCommand, RemovePathPointCommand, ReparentCommand, SceneStore, SceneViewComponent, SceneViewer, SegmentedPath, SetAlarmCommand, SetDashboardCommand, SetEnvironmentCommand, SetLightPropertyCommand, SetNodeNameCommand, SetNodeTextCommand, SyncMaterialCommand, ToggleSegmentTypeCommand, TransformCommand, UngroupCommand, UpdateAnimationCommand, UpdateEffectCommand, UpdatePathPointsCommand, clone, createNode, createSceneDoc, nextId };
 //# sourceMappingURL=fengyizhi-scene-lib.mjs.map