fl-web-component 1.4.8 → 2.0.0-beta.1

package/src/utils/instance-parser.js

@@ -3,6 +3,7 @@ import { FontLoader } from 'three/examples/jsm/loaders/FontLoader';
 import { TextGeometry } from 'three/examples/jsm/geometries/TextGeometry.js';
 import helvetikerFont from 'three/examples/fonts/helvetiker_regular.typeface.json';
 import { MeshLineGeometry, MeshLineMaterial } from 'meshline';
+import StreamLoaderParserWorker from '../../packages/utils/StreamLoaderParser.worker.js';
 
 const GEOM_TYPES = {
   geom_3d: 53248,
@@ -38,13 +39,142 @@ const TextAlign = {
   TextFit: 14,
 };
 
+// 图元加载模式
+const PRIMITIVE_TYPE = {
+  full: 2, // 全量加载
+  onlyBounding: 1, // 仅加载边界框
+};
+
 let drawObjMapInstance = {};
+// 使用Set来跟踪已处理的drawObject，避免重复创建group
+// let processedDrawObjects = new Set();
+let instanceToInstancedMeshMap = new Map();
+let instancedMappingWorker = null;
+let instancedMappingWorkerRequestId = 0;
+const instancedMappingWorkerRequests = new Map();
+
+function ensureInstancedMappingWorker() {
+  if (instancedMappingWorker) return instancedMappingWorker;
+  try {
+    instancedMappingWorker = new StreamLoaderParserWorker();
+  } catch (e) {
+    instancedMappingWorker = null;
+    return null;
+  }
+  instancedMappingWorker.addEventListener('message', e => {
+    const payload = e.data || {};
+    const pending = instancedMappingWorkerRequests.get(payload.id);
+    if (!pending) return;
+    instancedMappingWorkerRequests.delete(payload.id);
+    if (payload.type === 'success') {
+      pending.resolve(payload.result);
+    } else {
+      pending.reject(new Error(payload.error));
+    }
+  });
+  return instancedMappingWorker;
+}
+
+function requestInstancedMapping(instances, drawObjs) {
+  const worker = ensureInstancedMappingWorker();
+  if (!worker) {
+    return Promise.reject(new Error('Worker is not initialized'));
+  }
+  return new Promise((resolve, reject) => {
+    const id = instancedMappingWorkerRequestId++;
+    instancedMappingWorkerRequests.set(id, { resolve, reject });
+    worker.postMessage({
+      id,
+      type: 'buildInstancedMapping',
+      data: { instances, drawObjs },
+    });
+  });
+}
+
 /**
- * 处理 InstancedMesh 类型模型的核心方法
- * @param {Object} instance - 实例对象，包含绘制对象ID和实例ID等数据
+ * 重置处理状态，用于新的批量加载会话
+ */
+function resetProcessingState() {
+  drawObjMapInstance = {};
+  // instanceToInstancedMeshMap.clear();
+  // processedDrawObjects.clear();
+}
+
+/**
+ * 获取已构建的绘制对象实例映射（用于根据 instanceId 查找其几何数据）
+ * @param {string} drawObjectId
+ * @returns {Object|undefined} 返回包含 MapMesh/MapInstance/lodLevel 的对象
+ */
+function getDrawObjectInstance(drawObjectId) {
+  return drawObjMapInstance[drawObjectId];
+}
+
+function mergeInstancedMappingResult(result) {
+  if (!result) return;
+  const { drawObjMapInstance: incomingMap, instanceToDrawObject } = result;
+
+  if (incomingMap) {
+    const keys = Object.keys(incomingMap);
+    for (let i = 0; i < keys.length; i++) {
+      const drawObjectId = keys[i];
+      const incoming = incomingMap[drawObjectId];
+      if (!incoming) continue;
+      const existing = drawObjMapInstance[drawObjectId];
+      if (!existing) {
+        drawObjMapInstance[drawObjectId] = {
+          MapInstance: Array.isArray(incoming.MapInstance) ? [...incoming.MapInstance] : [],
+          MapMesh: incoming.MapMesh,
+        };
+      } else {
+        if (!Array.isArray(existing.MapInstance)) existing.MapInstance = [];
+        const existingIds = new Set();
+        for (let j = 0; j < existing.MapInstance.length; j++) {
+          const item = existing.MapInstance[j];
+          if (item && item.instanceId != null) existingIds.add(item.instanceId);
+        }
+        const incomingInstances = Array.isArray(incoming.MapInstance) ? incoming.MapInstance : [];
+        for (let j = 0; j < incomingInstances.length; j++) {
+          const item = incomingInstances[j];
+          if (item && !existingIds.has(item.instanceId)) {
+            existing.MapInstance.push(item);
+            existingIds.add(item.instanceId);
+          }
+        }
+        if (!existing.MapMesh && incoming.MapMesh) {
+          existing.MapMesh = incoming.MapMesh;
+        }
+      }
+    }
+  }
+
+  if (Array.isArray(instanceToDrawObject)) {
+    for (let i = 0; i < instanceToDrawObject.length; i++) {
+      const item = instanceToDrawObject[i];
+      if (!item || item.instanceId == null) continue;
+      if (!instanceToInstancedMeshMap.get(item.instanceId)) {
+        instanceToInstancedMeshMap.set(item.instanceId, {
+          instanceId: item.instanceId,
+          drawObjectId: item.drawObjectId,
+        });
+      }
+    }
+  }
+}
+
+/**
+ * 处理 InstancedMesh 类型模型的核心方法（优化版本，支持批量处理）
+ * @param {Object} modelGroup - 模型组对象
+ * @param {Array} instances - 实例数组
  * @param {Array} drawObjs - 绘制对象数组，包含几何数据
+ * @param {string} type - 类型
+ * @param {Object} scene - 场景对象
+ * @param {string} customColor - 自定义颜色
+ * @param {Object} meshNameConfig - 网格名称配置
+ * @param {string} customOpacity - 自定义透明度
+ * @param {Object} options - 选项配置
+ * @returns {Object} 模型组对象
  */
-function handleInstancedMeshModel(
+async function handleInstancedMeshModel(
   modelGroup,
   instances,
   drawObjs,
@@ -52,125 +182,398 @@ function handleInstancedMeshModel(
   scene,
   customColor,
   meshNameConfig,
-  customOpacity
-) {
-  drawObjMapInstance = {};
-  // 第一阶段：构建实例映射表
-  // let modelGroup = new THREE.Group();
-  for (let i = 0; i < instances.length; i++) {
-    formatInstancedMap(instances[i], drawObjs);
+  customOpacity,
+  options = {}
+) 
+{
+  // const getObjectByName = (name, passType = 'group') => {
+  //   if (!scene) return [];
+  //   const object = [];
+  //   const instancedMeshProps = instanceToInstancedMeshMap.get(name);
+  //   scene.traverse(item => {
+  //     const tempName = instancedMeshProps ? instancedMeshProps.drawObjectId : name;
+  //     if (item.name == tempName && item.type.toLowerCase() != passType.toLowerCase()) {
+  //       object.push(item);
+  //     }
+  //   });
+  //   return object;
+  // };
+
+  // 如果是新的加载会话，重置状态
+  if (options.resetState) {
+    resetProcessingState();
   }
-  // 第二阶段：遍历所有实例进行处理
-  for (let i = 0; i < instances.length; i++) {
-    let targetGroup, instancedMeshIndex, drawObjectName;
-    const drawObjInstance = drawObjMapInstance[instances[i].drawObject];
-    if (drawObjInstance.MapMesh?.length > 0) {
-      // 确保始终使用当前实例的 drawObject 设置分组名
-      drawObjectName = instances[i].drawObject;
-      drawObjInstance.MapInstance.forEach((instance, index) => {
-        if (instance.instanceId == instances[i].instanceId) {
-          instancedMeshIndex = index;
-        }
+
+  let mappingResult = null;
+  if (Array.isArray(instances) && instances.length) {
+    try {
+      mappingResult = await requestInstancedMapping(instances, drawObjs || []);
+    } catch (e) {
+      mappingResult = null;
+    }
+  }
+
+  if (mappingResult) {
+    mergeInstancedMappingResult(mappingResult);
+  } else {
+    const batchSize = options.batchSize || 50;
+    for (let i = 0; i < instances.length; i += batchSize) {
+      const batch = instances.slice(i, i + batchSize);
+      batch.forEach(instance => {
+        formatInstancedMap(instance, drawObjs);
       });
-      // 在 modelGroup 中查找，避免因尚未加入 scene 而重复创建
-      if (drawObjectName) {
-        targetGroup = modelGroup.getObjectByName(drawObjectName);
+    }
+
+    for (let i = 0; i < instances.length; i++) {
+      const instance = instances[i];
+      const drawObjectId = instance.drawObject;
+
+      if (!instanceToInstancedMeshMap.get(instance.instanceId)) {
+        instanceToInstancedMeshMap.set(instance.instanceId, {
+          instanceId: instance.instanceId,
+          drawObjectId,
+        });
       }
-      if (!targetGroup) {
-        const drawObj = drawObjMapInstance[instances[i].drawObject];
-        const group = new THREE.Group();
-        // let grouphName = ''
-        for (const key in meshNameConfig) {
-          group.userData[key] = meshNameConfig[key];
-          // grouphName += ':' + meshNameConfig[key]
-        }
-        // grouphName !== '' ? instances[i].drawObject + grouphName: instances[i].drawObject;
-        group.name = instances[i].drawObject;
-        group.userData.isInstancedMeshGroup = true;
-        group.userData.category = instances[i].category;
-        group.userData.instanceId = instances[i].drawObject;
-        const instanceCount = drawObj.MapInstance.length;
-        drawObj.MapMesh?.forEach(mesh => {
-          const model = drawModel(
-            mesh,
-            instances[i].drawObject,
-            instanceCount,
-            customColor,
-            customOpacity
-          );
-          if (!model) {
-            return;
+    }
+  }
+
+  // 第二阶段：遍历所有实例进行处理（增量渲染优化）
+  // const processedInThisBatch = new Set();
+
+  // 预先建立映射表，避免在循环中频繁调用 getObjectByName
+  const existingGroupsMap = new Map();
+  if (modelGroup && modelGroup.children) {
+    modelGroup.children.forEach(child => {
+      if (child.name) {
+        existingGroupsMap.set(child.name, child);
+      }
+    });
+  }
+
+  const immediateUpdate = options.immediateUpdate || false;
+
+  for (let i = 0; i < instances.length; i++) {
+    const instance = instances[i];
+    const drawObjectId = instance.drawObject;
+    const instanceId = instance.instanceId;
+
+    // 检查该drawObject是否已经在本批次或之前处理过
+    // if (processedDrawObjects.has(drawObjectId) || processedInThisBatch.has(drawObjectId)) {
+    //   continue; // 跳过已处理的drawObject
+    // }
+
+    const drawObjInstance = drawObjMapInstance[drawObjectId];
+
+    if (drawObjInstance?.MapMesh?.length > 0) {
+      // 检查modelGroup中是否已存在同名的group
+      // const existingGroup = getObjectByName(drawObjectId)[0];
+      const existingGroup = existingGroupsMap.get(drawObjectId);
+
+      if (!existingGroup) {
+        const group = createInstancedGroup(
+          drawObjInstance,
+          instance,
+          meshNameConfig,
+          customColor,
+          customOpacity,
+          options
+        );
+
+        if (group) {
+          // console.log('add(group)')
+          modelGroup.add(group);
+          if(immediateUpdate){
+            // 立即更新矩阵世界，确保位置正确
+            group.updateMatrixWorld(true);
           }
-          let meshName = '';
-          for (const key in meshNameConfig) {
-            model.userData[key] = meshNameConfig[key];
-            meshName += ':' + meshNameConfig[key];
+
+          // 更新映射表，以便后续循环能找到新添加的组
+          if (group.name) {
+            existingGroupsMap.set(group.name, group);
           }
 
-          // 初始化实例映射表
-          model.userData.instanceMaps = {}
-          // 一次性为该 drawObject 的所有实例设置矩阵与颜色
-          drawObj.MapInstance.forEach((item, index) => {
-            model.userData.instanceIndex = index;
-            model.userData.instanceId = item.instanceId;
-            model.userData.primId = mesh.prmid;
-            model.name = meshName !== '' ? item.instanceId + meshName : item.instanceId;
-
-            model.userData.instanceMaps[item.instanceId] = {};
-            model.userData.instanceMaps[item.instanceId]['instanceIndex'] = index;
-            model.userData.instanceMaps[item.instanceId]['primId'] = mesh.prmid;
-            model.userData.instanceMaps[item.instanceId]['name'] = model.name;
-
-            const matrixVal = item.matrix?.val;
-            if (matrixVal) {
-              const m4 = new THREE.Matrix4();
-              const meshMatrix = new THREE.Matrix4();
-              const geomMatrix = new THREE.Matrix4();
-              // m4.setPosition(new THREE.Vector3(9999999, 9999999, 9999999)); // TODO 临时隐藏方案
-              meshMatrix.elements = item.matrix.val;
-              geomMatrix.elements = mesh.matrix.val;
-
-              // 处理文本居中对齐
-              if (isTextType(mesh.type)) {
-                const { points, alignType } = mesh;
-                const positionMatrix = new THREE.Matrix4();
-
-                const alignMatrix = createAlignedText(alignType, model.geometry);
-
-                positionMatrix.identity().makeTranslation(points[0], points[1], points[2]);
-                geomMatrix.multiply(alignMatrix).multiply(positionMatrix);
-              }
-
-              m4.multiplyMatrices(meshMatrix, geomMatrix);
-
-              model.setMatrixAt(index, m4);
-              const copyMatrix = new THREE.Matrix4().copy(m4);
-              model.userData.copyMatrix = copyMatrix;
-
-              model.userData.instanceMaps[item.instanceId]['copyMatrix'] = copyMatrix;
-            }
-            // 需要先设置全部实例颜色，否则后续设置颜色无效
-            const { color } = mesh.prop;
-            const meshColor = customColor
-              ? new THREE.Color(customColor)
-              : new THREE.Color(`rgb(${color[0]}, ${color[1]}, ${color[2]})`);
-            model.setColorAt(index, meshColor);
-          });
-          // 标记实例属性更新
-          if (model.instanceMatrix) model.instanceMatrix.needsUpdate = true;
-          if (model.instanceColor) model.instanceColor.needsUpdate = true;
-          // model.instanceColor.needsUpdate = true;
-          group.add(model);
-        });
-        modelGroup.add(group);
+          // 标记该drawObject已处理
+          // processedDrawObjects.add(drawObjectId);
+          // processedInThisBatch.add(drawObjectId);
+        }
+      } else {
+        appendInstanceToInstancedGroup(existingGroup, drawObjInstance, instance, customColor);
       }
     }
   }
-  console.log('modelGroup', modelGroup);
-  console.log('drawObjMapInstance', drawObjMapInstance);
-  return modelGroup;
-  // timeRender();
-  // console.log('scene', scene)
+
+  // console.log(instanceToInstancedMeshMap)
+  // return modelGroup;
+}
+
+/**
+ * 创建实例化组（从handleInstancedMeshModel中提取的逻辑）
+ * @param {Object} drawObj - 绘制对象数据
+ * @param {Object} instance - 实例数据
+ * @param {Object} meshNameConfig - 网格名称配置
+ * @param {string} customColor - 自定义颜色
+ * @param {string} customOpacity - 自定义透明度
+ * @param {Object} options - 选项配置
+ * @returns {THREE.Group} 创建的组对象
+ */
+function createInstancedGroup(
+  drawObj,
+  instance,
+  meshNameConfig,
+  customColor,
+  customOpacity,
+  options
+) {
+  const group = new THREE.Group();
+
+  // 设置组的基本属性
+  for (const key in meshNameConfig) {
+    group.userData[key] = meshNameConfig[key];
+  }
+
+  // 可配置的用户数据
+  for (const key in options.userData) {
+    group.userData[key] = options.userData[key];
+  }
+
+  // group.name = options.defineGroupPreName ? `${options.defineGroupPreName}:${instance.drawObject}` : instance.drawObject;
+  group.name = instance.drawObject;
+  group.userData.isInstancedMeshGroup = true;
+  group.userData.category = instance.category;
+  group.userData.instanceId = instance.drawObject;
+
+  // const instanceCount = drawObj.MapInstance.length;
+  const instanceCount = 100; // 预分配容量，动态增加实例
+  const activeInstanceCount = Array.isArray(drawObj.MapInstance) ? drawObj.MapInstance.length : 0;
+
+  // 处理每个网格
+  drawObj.MapMesh?.forEach(mesh => {
+    // console.log(mesh)
+    // console.log(instance)
+    // if(mesh.prop.color[0] == 0 && mesh.prop.color[1] == 142 && mesh.prop.color[2] == 142){
+    //   return
+    // }
+    // customColor 是原本初始化整个模型颜色的 这里暂时放弃
+    // (mesh, instance.drawObject, instanceCount, customColor, customOpacity
+    let color = options.colorConfig.get(instance.instanceId)
+    
+    const model = drawModel(mesh, instance.drawObject, instanceCount, color, customOpacity, {
+      // lodLevel: drawObj.lodLevel || 2,
+      activeInstanceCount,
+      ...options
+    });
+
+    if (!model) {
+      return;
+    }
+
+    // 设置网格名称
+    let meshName = '';
+    for (const key in meshNameConfig) {
+      model.userData[key] = meshNameConfig[key];
+      // meshName += ':' + meshNameConfig[key];
+    }
+
+    // 批量设置实例矩阵和颜色（性能优化）
+    // setInstanceMatricesAndColors(model, drawObj, mesh, meshName, customColor, options);
+    setInstanceMatricesAndColors(model, drawObj, mesh, meshName, color, options);
+
+    group.add(model);
+  });
+
+  return group;
+}
+
+/**
+ * 批量设置实例矩阵和颜色（性能优化版本）
+ * @param {THREE.InstancedMesh} model - 实例化网格模型
+ * @param {Object} drawObj - 绘制对象数据
+ * @param {Object} mesh - 网格数据
+ * @param {string} meshName - 网格名称
+ * @param {string} customColor - 自定义颜色
+ */
+function setInstanceMatricesAndColors(model, drawObj, mesh, meshName, customColor, options) {
+  const instances = drawObj.MapInstance;
+  const { color } = mesh.prop;
+
+  // 预计算颜色
+  const meshColor = customColor
+    ? new THREE.Color(customColor)
+    : new THREE.Color(`rgb(${color[0]}, ${color[1]}, ${color[2]})`);
+
+  // 批量处理实例
+  instances.forEach((item, index) => {
+    // 设置用户数据
+    model.userData.instanceIndex = index;
+    model.userData.instanceId = item.instanceId;
+    model.userData.primId = mesh.prmid;
+    // model.userData.lodLevel = drawObj.lodLevel || 2;
+    if (index == 0) {
+      model.name = meshName !== '' ? item.instanceId + meshName : item.instanceId;
+    }
+
+    let instanceProps = {
+      instanceIndex: index, // 序号来定位到底是哪个instancedMesh
+      instancedMeshId: model.name, // 多个instancedMesh共用一个name，用于查找模型
+      instanceId: item.instanceId, // instancedMesh实际的modelId
+      primId: mesh.prmid,
+      // lodLevel: drawObj.lodLevel || 2,
+    };
+    if (!model.userData.instancesMap) {
+      model.userData.instancesMap = new Map([[item.instanceId, instanceProps]]);
+    } else {
+      model.userData.instancesMap.set(item.instanceId, instanceProps);
+    }
+
+    // const instancedMesh = instanceToInstancedMeshMap.get(item.instanceId);
+
+    // 处理矩阵变换
+    const matrixVal = item.matrix?.val;
+    if (matrixVal) {
+      const m4 = new THREE.Matrix4();
+      const meshMatrix = new THREE.Matrix4();
+      const geomMatrix = new THREE.Matrix4();
+
+      meshMatrix.fromArray(matrixVal);
+      geomMatrix.fromArray(new THREE.Matrix4().identity().elements);
+
+      // 处理文本居中对齐
+      const { points, alignType } = mesh;
+      if (isTextType(mesh.type)) {
+        const positionMatrix = new THREE.Matrix4();
+        const alignMatrix = createAlignedText(alignType, model.geometry);
+        positionMatrix.identity().makeTranslation(points[0], points[1], points[2]);
+        geomMatrix.multiply(alignMatrix).multiply(positionMatrix);
+      }
+
+      m4.multiplyMatrices(meshMatrix, geomMatrix);
+      model.setMatrixAt(index, m4);
+
+      const copyMatrix = new THREE.Matrix4().copy(m4);
+      model.userData.copyMatrix = copyMatrix;
+
+      const temp = model.userData.instancesMap.get(item.instanceId);
+      temp.copyMatrix = copyMatrix;
+    }
+
+    // 设置颜色
+    model.setColorAt(index, meshColor);
+  });
+
+  // 标记需要更新
+  if (model.instanceMatrix) {
+    model.instanceMatrix.needsUpdate = true;
+  }
+  if (model.instanceColor) {
+    model.instanceColor.needsUpdate = true;
+  }
+
+  if (Array.isArray(instances)) {
+    const capacity =
+      model.instanceMatrix && typeof model.instanceMatrix.count === 'number'
+        ? model.instanceMatrix.count
+        : model.count;
+    model.count = Math.min(instances.length, capacity);
+    model.userData.instanceCapacity = capacity;
+    model.userData.instanceCount = model.count;
+  }
+}
+
+function appendInstanceToInstancedGroup(group, drawObj, instance, customColor) {
+  if (!group || !drawObj || !instance) return;
+  const meshes = Array.isArray(drawObj.MapMesh) ? drawObj.MapMesh : [];
+  if (meshes.length === 0) return;
+  const meshByPrimId = new Map();
+  for (let i = 0; i < meshes.length; i++) {
+    const m = meshes[i];
+    if (m && m.prmid !== undefined) meshByPrimId.set(m.prmid, m);
+  }
+
+  const children = Array.isArray(group.children) ? group.children : [];
+  for (let i = 0; i < children.length; i++) {
+    const obj = children[i];
+    if (!obj || !obj.isInstancedMesh) continue;
+    const primId = obj.userData ? obj.userData.primId : undefined;
+    const mesh = meshByPrimId.get(primId);
+    if (!mesh) continue;
+    appendInstanceToInstancedMesh(obj, drawObj, mesh, instance, customColor);
+  }
+}
+
+function appendInstanceToInstancedMesh(model, drawObj, mesh, instance, customColor) {
+  if (!model || !model.isInstancedMesh) return;
+  if (!instance || !instance.instanceId) return;
+
+  const capacity =
+    model.instanceMatrix && typeof model.instanceMatrix.count === 'number'
+      ? model.instanceMatrix.count
+      : model.count;
+  const currentCount = typeof model.count === 'number' ? model.count : 0;
+  if (currentCount >= capacity) return;
+
+  if (!model.userData) model.userData = {};
+  if (!model.userData.instancesMap) model.userData.instancesMap = new Map();
+  if (model.userData.instancesMap.has(instance.instanceId)) return;
+
+  const rawColor = mesh && mesh.prop ? mesh.prop.color : undefined;
+  const colorArr = Array.isArray(rawColor)
+    ? rawColor
+    : typeof rawColor === 'string'
+    ? rawColor.split(',')
+    : [255, 255, 255];
+  const meshColor = customColor
+    ? new THREE.Color(customColor)
+    : new THREE.Color(`rgb(${colorArr[0]}, ${colorArr[1]}, ${colorArr[2]})`);
+
+  const matrixVal = instance.matrix?.val;
+  if (!matrixVal || !mesh || !mesh.matrix || !mesh.matrix.val) return;
+
+  const m4 = new THREE.Matrix4();
+  const meshMatrix = new THREE.Matrix4();
+  const geomMatrix = new THREE.Matrix4();
+
+  meshMatrix.fromArray(instance.matrix.val);
+  geomMatrix.fromArray(new THREE.Matrix4().identity().elements);
+
+  const { points, alignType } = mesh;
+  if (isTextType(mesh.type)) {
+    const positionMatrix = new THREE.Matrix4();
+    const alignMatrix = createAlignedText(alignType, model.geometry);
+    positionMatrix.identity().makeTranslation(points[0], points[1], points[2]);
+    geomMatrix.multiply(alignMatrix).multiply(positionMatrix);
+  }
+
+  m4.multiplyMatrices(meshMatrix, geomMatrix);
+  model.setMatrixAt(currentCount, m4);
+  if (model.instanceMatrix) model.instanceMatrix.needsUpdate = true;
+
+  const copyMatrix = new THREE.Matrix4().copy(m4);
+  model.userData.copyMatrix = copyMatrix;
+  const instanceProps = {
+    instanceIndex: currentCount,
+    instancedMeshId: model.name,
+    instanceId: instance.instanceId,
+    primId: mesh.prmid,
+    // lodLevel: drawObj.lodLevel || 2,
+    copyMatrix,
+  };
+  model.userData.instancesMap.set(instance.instanceId, instanceProps);
+
+  model.setColorAt(currentCount, meshColor);
+  if (model.instanceColor) model.instanceColor.needsUpdate = true;
+
+  const opacityAttr =
+    model.geometry && model.geometry.getAttribute
+      ? model.geometry.getAttribute('opacity')
+      : undefined;
+  if (opacityAttr && opacityAttr.array && currentCount < opacityAttr.array.length) {
+    opacityAttr.array[currentCount] = opacityAttr.array[0] !== undefined ? opacityAttr.array[0] : 1;
+    opacityAttr.needsUpdate = true;
+  }
+
+  model.count = currentCount + 1;
+  model.userData.instanceCapacity = capacity;
+  model.userData.instanceCount = model.count;
 }
 
 /**
@@ -200,9 +603,17 @@ function formatInstancedMap(instance, drawObjs) {
 
     // 关联绘制对象的几何数据
     drawObjs.forEach(item => {
-      if (item.drawObjId == drawObject) {
+      let hasMesh = false;
+      if (item && Array.isArray(item.geoms)) {
+        const found = item.geoms.some(g => g.prmid === drawObject);
+        if (found) {
+          hasMesh = true;
+        }
+      }
+      if (hasMesh) {
         // 将几何数据映射到对应的绘制对象
         drawObjMapInstance[drawObject].MapMesh = item.geoms;
+        // drawObjMapInstance[drawObject].lodLevel = item.lodLevel || 2;
       }
     });
   }
@@ -227,14 +638,14 @@ function formatDrawObjs(data) {
  * @param {Number} instanceCount - 实例化渲染的数量（用于InstancedMesh）
  * @returns {THREE.Object3D} 返回创建的3D模型对象
  */
-function drawModel(geom, instanceName, instanceCount, nColor, nOpacity) {
+function drawModel(geom, instanceName, instanceCount, nColor, nOpacity, options = {}) {
   let model;
   // 处理二维几何体（普通2D图形和特殊2D图形）
   if (geom.type == GEOM_TYPES.geom_2d || geom.type == GEOM_TYPES.geom_2d_others) {
-    model = draw2Dmodel(geom, instanceName, instanceCount); // TODO 该类型调试中
+    model = draw2Dmodel(geom, instanceName, instanceCount, options); // TODO 该类型调试中
     // 处理二维文本类型
   } else if (isTextType(geom.type)) {
-    model = drawText(geom, instanceName, instanceCount);
+    model = drawText(geom, instanceName, instanceCount, options);
     // 处理各种曲线类型（圆形、圆弧、椭圆、椭圆弧）
   } else if (
     geom.type == GEOM_TYPES.geom_2d_circle ||
@@ -242,10 +653,10 @@ function drawModel(geom, instanceName, instanceCount, nColor, nOpacity) {
     geom.type == GEOM_TYPES.geom_2d_ellipse ||
     geom.type == GEOM_TYPES.geom_2d_ellipseArc
   ) {
-    model = drawCurves(geom, instanceName, instanceCount); // TODO 该类型调试中
+    model = drawCurves(geom, instanceName, instanceCount, options); // TODO 该类型调试中
     // 处理三维几何体（普通3D模型和OBJ模型）
   } else if (geom.type == GEOM_TYPES.geom_3d || geom.type == GEOM_TYPES.geom_3d_obj) {
-    model = draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity);
+    model = draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity, options);
   }
   return model;
 }
@@ -271,7 +682,7 @@ function isTextType(type) {
  * @param {String} instanceName- 曲线实例的名称
  * @return {Object}- 包含曲线模型和曲线信息的对象
  */
-function drawCurves(geom, instanceName, instanceCount) {
+function drawCurves(geom, instanceName, instanceCount, options = {}) {
   let { points, normals } = geom;
   let aX = points[0];
   let aY = points[1];
@@ -311,7 +722,8 @@ function drawCurves(geom, instanceName, instanceCount) {
       normals,
     },
     instanceName,
-    instanceCount
+    instanceCount,
+    options
   );
   // model.rotation.x = -Math.PI / 2;
   // model.position.set(aX, aY, aZ);
@@ -329,7 +741,18 @@ function drawCurves(geom, instanceName, instanceCount) {
  * @param {Number} instanceCount - 需要创建的实例数量
  * @returns {THREE.InstancedMesh} - 返回创建的三维实例化网格对象
  */
-function draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity) {
+function draw3Dmodel(
+  geom,
+  instanceName,
+  instanceCount,
+  nColor,
+  nOpacity,
+  options = {},
+  targetMesh = undefined
+) {
+  // const { lodLevel } = options;
+
+
   // 解构几何数据中的自定义几何体和材质
   const {
     geometry: customGeometry,
@@ -337,87 +760,203 @@ function draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity) {
     triangles,
     points,
     normals,
-    prop,
+    prop = {},
+    max,
+    min,
+    type,
   } = geom;
-  // 使用自定义几何体或创建新的缓冲几何体
-  const geometry = customGeometry || new THREE.BufferGeometry();
 
+  // 如果传入了现有 mesh，则进行几何体切换（不重新创建 Mesh）
+  // if (targetMesh && targetMesh.isInstancedMesh) {
+  //   // 计算透明度，若现有材质已设置则沿用
+  //   let opacityFromMat = (targetMesh.material && targetMesh.material.userData && targetMesh.material.userData.nOpacity) ? targetMesh.material.userData.nOpacity : undefined;
+  //   let colors = Array.isArray(prop.color) ? prop.color : (typeof prop.color === 'string' ? prop.color.split(',') : [255, 255, 255, 1]);
+  //   let fallbackOpacity = colors[3] !== undefined ? colors[3] : 1;
+  //   const opacity = opacityFromMat !== undefined ? opacityFromMat : (nOpacity !== undefined ? nOpacity : fallbackOpacity);
+
+  //   // 根据目标 lodLevel 切换几何体
+  //   if (lodLevel === PRIMITIVE_TYPE.full) {
+  //     const bufGeo = new THREE.BufferGeometry();
+  //     // 设置索引
+  //     if (triangles && triangles.length) {
+  //       bufGeo.setIndex(triangles);
+  //     } else {
+  //       bufGeo.setIndex(null);
+  //     }
+  //     // 设置位置
+  //     if (points && points.length) {
+  //       const position = new Float32Array(points);
+  //       bufGeo.setAttribute('position', new THREE.BufferAttribute(position, 3));
+  //     }
+  //     // 设置法线或计算
+  //     if (normals && normals.length) {
+  //       const normal = new Float32Array(normals);
+  //       bufGeo.setAttribute('normal', new THREE.BufferAttribute(normal, 3));
+  //     } else {
+  //       bufGeo.computeVertexNormals();
+  //     }
+
+  //     // 绑定实例透明度属性
+  //     const opacities = new Float32Array(instanceCount);
+  //     for (let i = 0; i < instanceCount; i++) opacities[i] = opacity;
+  //     bufGeo.setAttribute('opacity', new THREE.InstancedBufferAttribute(opacities, 1));
+
+  //     // 包围体
+  //     bufGeo.computeBoundingBox();
+  //     bufGeo.computeBoundingSphere();
+
+  //     // 替换旧几何体
+  //     if (targetMesh.geometry) targetMesh.geometry.dispose();
+  //     targetMesh.geometry = bufGeo;
+  //     targetMesh.userData.lodLevel = PRIMITIVE_TYPE.full;
+  //     return; // 更新完成，无需返回新mesh
+  //   }
+
+  //   if (lodLevel === PRIMITIVE_TYPE.onlyBounding) {
+  //     // 使用 min/max 或从现有几何体计算包围盒
+  //     let bbox;
+  //     if (Array.isArray(min) && Array.isArray(max) && min.length === 3 && max.length === 3) {
+  //       bbox = { min: { x: min[0], y: min[1], z: min[2] }, max: { x: max[0], y: max[1], z: max[2] } };
+  //     } else {
+  //       // 从现有几何体计算
+  //       const geo = targetMesh.geometry;
+  //       geo.computeBoundingBox();
+  //       const bb = geo.boundingBox;
+  //       bbox = { min: bb.min, max: bb.max };
+  //     }
+  //     const width = Math.max(0.0001, bbox.max.x - bbox.min.x);
+  //     const height = Math.max(0.0001, bbox.max.y - bbox.min.y);
+  //     const depth = Math.max(0.0001, bbox.max.z - bbox.min.z);
+  //     const cx = (bbox.min.x + bbox.max.x) / 2;
+  //     const cy = (bbox.min.y + bbox.max.y) / 2;
+  //     const cz = (bbox.min.z + bbox.max.z) / 2;
+  //     const bboxGeometry = new THREE.BoxGeometry(width, height, depth);
+  //     bboxGeometry.translate(cx, cy, cz);
+
+  //     // 绑定实例透明度属性（保持现有透明度）
+  //     const opacities = new Float32Array(instanceCount);
+  //     for (let i = 0; i < instanceCount; i++) opacities[i] = opacity;
+  //     bboxGeometry.setAttribute('opacity', new THREE.InstancedBufferAttribute(opacities, 1));
+
+  //     if (targetMesh.geometry) targetMesh.geometry.dispose();
+  //     targetMesh.geometry = bboxGeometry;
+  //     targetMesh.userData.lodLevel = PRIMITIVE_TYPE.onlyBounding;
+  //     return; // 更新完成，无需返回新mesh
+  //   }
+
+  //   // 其它模式不处理
+  //   return;
+  // }
+
+  // 未传入现有 mesh：按原逻辑创建新 InstancedMesh
+  let geometry = customGeometry || new THREE.BufferGeometry();
+  // if (lodLevel == PRIMITIVE_TYPE.onlyBounding) {
+  //   if (Array.isArray(min) && Array.isArray(max) && min.length === 3 && max.length === 3) {
+  //     const width = Math.max(0.0001, max[0] - min[0]);
+  //     const height = Math.max(0.0001, max[1] - min[1]);
+  //     const depth = Math.max(0.0001, max[2] - min[2]);
+  //     const cx = (min[0] + max[0]) / 2;
+  //     const cy = (min[1] + max[1]) / 2;
+  //     const cz = (min[2] + max[2]) / 2;
+  //     const bboxGeometry = new THREE.BoxGeometry(width, height, depth);
+  //     bboxGeometry.translate(cx, cy, cz);
+  //     geometry = bboxGeometry;
+  //   }
+  // } else {
+  //   if (triangles && triangles.length) {
+  //     geometry.setIndex(triangles);
+  //   }
+  //   if (points && points.length) {
+  //     const position = new Float32Array(points);
+  //     geometry.setAttribute('position', new THREE.BufferAttribute(position, 3));
+  //   }
+  //   if (normals && normals.length) {
+  //     const normal = new Float32Array(normals);
+  //     geometry.setAttribute('normal', new THREE.BufferAttribute(normal, 3));
+  //   }
+  // }
+  
+  // triangle int16Array 索引时，需要转换为 uint16Array
   if(!customGeometry){
-    // 设置三角形索引数据
     if (triangles && triangles.length) {
-      geometry.setIndex(triangles);
+      geometry.setIndex(triangles instanceof Int16Array ? Array.from(triangles.buffer) : triangles);
     }
-
-    // 设置顶点位置数据
     if (points && points.length) {
       const position = new Float32Array(points);
       geometry.setAttribute('position', new THREE.BufferAttribute(position, 3));
     }
-
-    // 设置顶点法线数据
     if (normals && normals.length) {
       const normal = new Float32Array(normals);
       geometry.setAttribute('normal', new THREE.BufferAttribute(normal, 3));
     }
   }
-
+  
   const { color, transparent } = prop;
   let material, mesh, colors, opacity;
-  if (Array.isArray(color) && color.length) {
-    colors = color;
-    opacity = colors[3] || 1;
-  } else if (typeof color === 'string') {
-    colors = color.split(',');
-    opacity = colors[3] || 1;
-  } else {
-    colors = [255, 255, 255];
-    opacity = 1;
-  }
+    if (Array.isArray(color) && color.length) {
+      colors = color;
+      opacity = colors[3] || 1;
+    } else if (typeof color === 'string') {
+      colors = color.split(',');
+      opacity = colors[3] || 1;
+    } else {
+      colors = [255, 255, 255];
+      opacity = 1;
+    }
 
   // 处理transparent透明度
-  if (transparent) {
-    opacity = 1 - transparent;
-  }
+  opacity = 1 - transparent;
+
+  const finalOpacity = nOpacity !== '' ? nOpacity : opacity;
+
+  // 判断是否全透明
+  const isTransparent = finalOpacity < 1.0;
 
-  // 使用自定义材质或创建标准材质（默认参数配置）
   let materialOptions = {
     userData: {
       nColor: nColor
         ? new THREE.Color(nColor)
         : new THREE.Color(`rgb(${colors[0]}, ${colors[1]}, ${colors[2]})`),
-      nOpacity: nOpacity ? nOpacity : opacity,
+      nOpacity: finalOpacity,
+      // 这里记录模型原本的颜色  做颜色配置时 恢复原本的颜色用的
+      oColor: new THREE.Color(`rgb(${colors[0]}, ${colors[1]}, ${colors[2]})`)
     },
+    // side: THREE.DoubleSide,
+    // transparent: true,
+    // forceSinglePass: true,
     side: THREE.DoubleSide,
-    transparent: true, // 着色器中需要设置透明度
+    transparent: true,
+    opacity: finalOpacity,
+    depthWrite: true,
+    forceSinglePass: true,
   };
 
   customMaterial && Object.assign(customMaterial, materialOptions);
-
   material =
     customMaterial ||
     new THREE.MeshStandardMaterial({
       ...materialOptions,
       roughness: 0.6,
       metalness: 0.5,
-      envMapIntensity: 1, // 调低环境贴图的强度
-      // wireframe: true
+      envMapIntensity: 1,
     });
 
-  // 为每个实例存储透明度（opacity）
-  const opacities = new Float32Array(instanceCount);
+  const activeInstanceCount = Math.max(
+    0,
+    Math.min(
+      instanceCount,
+      typeof options.activeInstanceCount === 'number' ? options.activeInstanceCount : instanceCount
+    )
+  );
 
-  // 填充透明度数据
+  const opacities = new Float32Array(instanceCount);
   for (let i = 0; i < instanceCount; i++) {
     opacities[i] = opacity;
   }
-
-  // 创建实例属性并绑定到 InstancedMesh
   geometry.setAttribute('opacity', new THREE.InstancedBufferAttribute(opacities, 1));
 
-  // 自定义着色器逻辑
   if (!customMaterial) {
     material.onBeforeCompile = shader => {
-      // 添加顶点着色器输入
       shader.vertexShader = `
           in float opacity; // 实例透明度属性
           out float vAlpha;
@@ -429,8 +968,6 @@ function draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity) {
           vAlpha = opacity; // 传递透明度到片段着色器
           `
       );
-
-      // 修改片段着色器
       shader.fragmentShader = `
           in float vAlpha;
           ${shader.fragmentShader}
@@ -443,6 +980,7 @@ function draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity) {
       );
     };
   }
+
   // 针对 MeshLineMaterial 开启实例化支持
   if (material.type === 'MeshLineMaterial') {
     material.defines = material.defines || {};
@@ -459,13 +997,14 @@ function draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity) {
   }
 
   mesh = new THREE.InstancedMesh(geometry, material, instanceCount);
-
+  mesh.count = activeInstanceCount;
   const { visible } = prop;
-  mesh.visible = visible;
+  mesh.visible = visible !== undefined ? visible : true;
   mesh.userData.drawObjectId = instanceName;
-  mesh.userData.is3D = geom.type == GEOM_TYPES.geom_3d || geom.type == GEOM_TYPES.geom_3d_obj;
-
-  // mesh.material = material;
+  mesh.userData.is3D = type == GEOM_TYPES.geom_3d || type == GEOM_TYPES.geom_3d_obj;
+  mesh.userData.transparent = isTransparent;
+  mesh.userData.instanceCapacity = instanceCount;
+  mesh.userData.instanceCount = activeInstanceCount;
   return mesh;
 }
 
@@ -476,7 +1015,7 @@ function draw3Dmodel(geom, instanceName, instanceCount, nColor, nOpacity) {
  * @param {String} instanceName - 模型实例的名称
  * @returns {Object} - 包含所有 2D 模型的组对象
  */
-function draw2Dmodel(geom, instanceName, instanceCount) {
+function draw2Dmodel(geom, instanceName, instanceCount, options = {}) {
   const points = geom.points;
   const normals = geom.normals;
   const geometry = new THREE.BufferGeometry();
@@ -508,7 +1047,8 @@ function draw2Dmodel(geom, instanceName, instanceCount) {
       material,
     },
     instanceName,
-    instanceCount
+    instanceCount,
+    options
   );
   // mesh.raycast = raycast;
 
@@ -519,7 +1059,7 @@ function draw2Dmodel(geom, instanceName, instanceCount) {
 }
 
 // drawText 方法，用于渲染 2D 或 3D 文字
-function drawText(geom, instanceName, instanceCount) {
+function drawText(geom, instanceName, instanceCount, options = {}) {
   const { prop, text, points, normals } = geom;
   const { color, linewidth, fontsize, fontname, rotate, italic, widthscale } = prop;
 
@@ -546,7 +1086,8 @@ function drawText(geom, instanceName, instanceCount) {
       normals,
     },
     instanceName,
-    instanceCount
+    instanceCount,
+    options
   );
 
   // 创建平移矩阵并应用
@@ -648,4 +1189,11 @@ function createAlignedText(align = TextAlign.TextLeftBottom, geometry) {
   return alignMatrix;
 }
 
-export { handleInstancedMeshModel };
+export {
+  handleInstancedMeshModel,
+  resetProcessingState,
+  PRIMITIVE_TYPE,
+  draw3Dmodel,
+  getDrawObjectInstance,
+  instanceToInstancedMeshMap,
+};