@kimap/indoor-positioning-sdk-vue2 5.8.0 → 5.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimap/indoor-positioning-sdk-vue2",
-  "version": "5.8.0",
+  "version": "5.8.2",
   "description": "Vue2自包含室内定位SDK - 完全兼容Webpack3+Babel6 | Vue2 Self-Contained Indoor Positioning SDK",
   "main": "index.js",
   "files": [

package/src/core/KimapSDK.js

@@ -30,6 +30,7 @@ function KimapSDK(config) {
   this.customDOMs = {};
   this.dataUrl = config.dataUrl || '';
   this.furnitureGroup = null;
+  this.floorFurnitureGroups = []; // 每个楼层独立的家具组
   this.projectLayers = null;
   this.floors = [];
   this.currentFloorId = null;
@@ -82,10 +83,9 @@ KimapSDK.prototype.init = function() {
       self.startRenderLoop();
       self._extractWallsFromModel();
 
-      // 多楼层默认显示第一个楼层（单层模式），同时记录ALL模式间隙
+      // 多楼层默认显示第一个楼层
       if (self.isMultiFloor && self.floorGroups && self.floorGroups.length > 0) {
         self.showSingleFloor(0);
-        self.showAllFloors(); // 立即恢复到ALL模式（含间隙），初始化后保持ALL状态
       }
 
       // 渲染内置楼层选择器 UI
@@ -608,17 +608,16 @@ KimapSDK.prototype.showSingleFloor = function(floorIndex) {
   var self = this;
   this.floorGroups.forEach(function(group, index) {
     if (index === floorIndex) {
-      // 贴地 + 清除ALL模式的XZ中心对齐
+      // 单层模式：将该楼层移动到贴地位置（y = 0）
       group.visible = true;
-      group.position.set(0, 0, 0);
+      group.position.y = 0;
     } else {
+      // 隐藏其他楼层，同时移到下方避免干扰
       group.visible = false;
       var originalY = self.core.floorOriginalY[index] || 0;
-      group.position.y = -originalY - 1;
-      // XZ 保持中心对齐（向下移动后不再占用视觉空间）
+      group.position.y = -originalY - 1; // 移到地面以下
     }
   });
-  this.currentFloorIndex = floorIndex;
 };
 
 /**
@@ -630,10 +629,10 @@ KimapSDK.prototype.showAllFloors = function() {
   var self = this;
   this.floorGroups.forEach(function(group, index) {
     group.visible = true;
+    // 恢复原始世界 Y 偏移（含间隙）
     var originalY = self.core.floorOriginalY[index] || 0;
     group.position.y = originalY;
   });
-  this.currentFloorIndex = 0;
 };
 
 /**
@@ -901,33 +900,35 @@ KimapSDK.prototype.loadKMData = function() {
     return Promise.resolve({ success: false, message: '未配置objUrl' });
   }
 
-  var objUrl = this.config.objUrl;
-  var isArray = Array.isArray(objUrl);
-
-  // 多楼层模式：等 floorGroups 就绪后再加载各层 kidata
-  if (isArray) {
-    var self2 = this;
-    if (self2.floorGroups && self2.floorGroups.length > 0) {
-      // 模型已就绪，直接加载
-      return self2._loadAllFloorKidatas(objUrl);
-    }
-    // 模型未就绪，等回调
-    return new Promise(function(resolve) {
-      var original = self2.core.onFloorModelsLoaded;
-      self2.core.onFloorModelsLoaded = function() {
-        if (typeof original === 'function') original();
-        resolve();
-      };
-    }).then(function() {
-      return self2._loadAllFloorKidatas(objUrl);
+  var objUrls = this.config.objUrl;
+  var isMulti = Array.isArray(objUrls);
+
+  // 多楼层：每个楼层独立加载自己的 kidata → 家具 → 对应的 floorGroup
+  if (isMulti) {
+    var floorIndex = 0;
+    var totalLoaded = 0;
+    var totalFailed = 0;
+
+    return objUrls.reduce(function(promise, url) {
+      return promise.then(function() {
+        return self._loadSingleFloorKidata(url, floorIndex++);
+      }).then(function(result) {
+        totalLoaded += result.loaded;
+        totalFailed += result.failed;
+      });
+    }, Promise.resolve()).then(function() {
+      console.log('✅ 多楼层家具加载完成：成功 ' + totalLoaded + ' 个，失败 ' + totalFailed + ' 个');
+      return { success: true, loaded: totalLoaded, failed: totalFailed };
+    }).catch(function(error) {
+      console.error('❌ 多楼层家具加载失败：', error.message);
+      return { success: false, error: error.message };
     });
   }
 
-  // 单楼层模式：沿用原有逻辑
-  var firstUrl = objUrl;
-  var lastSlashIndex = firstUrl.lastIndexOf('/');
-  var directory = lastSlashIndex >= 0 ? firstUrl.substring(0, lastSlashIndex) : '';
-  var fileName = firstUrl.split('/').pop().replace(/\.(obj|kimap)$/i, '');
+  // 单楼层：原逻辑
+  var lastSlashIndex = objUrls.lastIndexOf('/');
+  var directory = lastSlashIndex >= 0 ? objUrls.substring(0, lastSlashIndex) : '';
+  var fileName = objUrls.split('/').pop().replace(/\.(obj|kimap)$/i, '');
   var kidataUrl = directory + '/' + fileName + '.kidata';
 
   return fetch(kidataUrl)
@@ -939,10 +940,14 @@ KimapSDK.prototype.loadKMData = function() {
       var decrypted = self._decryptKidata(encryptedData);
       var kidataObj = JSON.parse(decrypted);
       self.kidataContent = kidataObj;
-      if (kidataObj.floors && Array.isArray(kidataObj.floors) && kidataObj.floors.length > 0) {
-        self.projectLayers = kidataObj.floors[0].layers;
+
+      if (kidataObj.floors && Array.isArray(kidataObj.floors)) {
+        if (!self.projectLayers && kidataObj.floors.length > 0) {
+          self.projectLayers = kidataObj.floors[0].layers;
+        }
       }
-      return self._loadFurnitureModels(kidataObj);
+
+      return self._loadFurnitureModels(kidataObj, -1); // -1 = 使用全局 furnitureGroup
     })
     .then(function(result) {
       console.log('✅ 家具加载完成：成功 ' + result.loaded + ' 个，失败 ' + result.failed + ' 个');
@@ -955,15 +960,18 @@ KimapSDK.prototype.loadKMData = function() {
 };
 
 /**
- * 多楼层：为指定楼层加载 kidata（含家具 + 文字）
+ * 多楼层专用：加载单个楼层的 kidata → 家具到对应 floorGroup
+ * @param {string} floorUrl - 该楼层的模型 URL
+ * @param {number} floorIndex - 楼层索引
+ * @returns {Promise}
  * @private
  */
-KimapSDK.prototype._loadKidataForFloor = function(url, floorIndex) {
+KimapSDK.prototype._loadSingleFloorKidata = function(floorUrl, floorIndex) {
   var self = this;
 
-  var lastSlashIndex = url.lastIndexOf('/');
-  var directory = lastSlashIndex >= 0 ? url.substring(0, lastSlashIndex) : '';
-  var fileName = url.split('/').pop().replace(/\.(obj|kimap)$/i, '');
+  var lastSlashIndex = floorUrl.lastIndexOf('/');
+  var directory = lastSlashIndex >= 0 ? floorUrl.substring(0, lastSlashIndex) : '';
+  var fileName = floorUrl.split('/').pop().replace(/\.(obj|kimap)$/i, '');
   var kidataUrl = directory + '/' + fileName + '.kidata';
 
   return fetch(kidataUrl)
@@ -975,108 +983,16 @@ KimapSDK.prototype._loadKidataForFloor = function(url, floorIndex) {
       var decrypted = self._decryptKidata(encryptedData);
       var kidataObj = JSON.parse(decrypted);
 
-      // 创建该楼层的家具组（作为 floorGroup 的子级，随楼层移动）
-      var floorFurnitureGroup = new THREE.Group();
-      floorFurnitureGroup.name = 'furniture_floor_' + floorIndex;
-      self.floorGroups[floorIndex].add(floorFurnitureGroup);
-
-      // 加载家具（传入楼层家具组）
-      return self._loadFurnitureModels(kidataObj, floorFurnitureGroup)
-        .then(function(furnitureResult) {
-          // 提取并渲染文字（每层独立）
-          self._loadTextForFloor(kidataObj, floorIndex);
-          return furnitureResult;
-        });
-    })
-    .then(function(result) {
-      return result;
-    })
-    .catch(function(error) {
-      console.error('❌ 楼层' + floorIndex + '加载失败：', error.message);
-      return { loaded: 0, failed: 0 };
-    });
-};
-
-/**
- * 多楼层：加载所有楼层的 kidata（家具+文字）
- * @private
- */
-KimapSDK.prototype._loadAllFloorKidatas = function(objUrlArray) {
-  var self = this;
-  var loadPromises = objUrlArray.map(function(url, index) {
-    return self._loadKidataForFloor(url, index);
-  });
-  return Promise.all(loadPromises)
-    .then(function(results) {
-      var totalLoaded = results.reduce(function(s, r) { return s + (r.loaded || 0); }, 0);
-      var totalFailed = results.reduce(function(s, r) { return s + (r.failed || 0); }, 0);
-      console.log('✅ 全部楼层家具加载完成：成功 ' + totalLoaded + ' 个，失败 ' + totalFailed + ' 个');
-      return { success: true, loaded: totalLoaded, failed: totalFailed };
-    })
-    .catch(function(error) {
-      console.error('❌ 楼层家具加载失败：', error.message);
-      return { success: false, error: error.message };
-    });
-};
-
-/**
- * 多楼层：为指定楼层渲染文字
- * @private
- */
-KimapSDK.prototype._loadTextForFloor = function(kidataObj, floorIndex) {
-  var self = this;
-  var floorTextGroup = this.core.floorTextGroups[floorIndex];
-  if (!floorTextGroup) return;
-
-  var textElements = [];
-  if (kidataObj.floors && Array.isArray(kidataObj.floors)) {
-    kidataObj.floors.forEach(function(floor) {
-      if (floor.layers) {
-        floor.layers.forEach(function(layer) {
-          if (layer.elements) {
-            layer.elements.forEach(function(element) {
-              if (element.type === 'text') {
-                textElements.push(element);
-              }
-            });
-          }
-        });
+      // 保存第一层 kidata 供路径规划使用
+      if (floorIndex === 0) {
+        self.kidataContent = kidataObj;
+        if (kidataObj.floors && Array.isArray(kidataObj.floors) && !self.projectLayers) {
+          self.projectLayers = kidataObj.floors[0].layers;
+        }
       }
-    });
-  }
 
-  if (textElements.length === 0) return;
-
-  textElements.forEach(function(textEl) {
-    if (!textEl.points || textEl.points.length === 0) return;
-    var point = textEl.points[0];
-    var x = point.x / 100;
-    var z = point.y / 100;
-    var LOGICAL_WALL_HEIGHT = 3000;
-    var RENDER_WALL_HEIGHT = 0.375;
-    var elevationMm = textEl.elevation || 8500;
-    var y = (elevationMm / LOGICAL_WALL_HEIGHT) * RENDER_WALL_HEIGHT;
-    var TEXT_SCALE_FACTOR = 2.52;
-
-    var sprite = self.core.createTextSprite({
-      content: textEl.content || '',
-      fontSize: (textEl.fontSize || 16) * TEXT_SCALE_FACTOR,
-      color: textEl.color || '#000000',
-      fontFamily: textEl.fontFamily || 'Arial, sans-serif',
-      bold: textEl.bold || false,
-      italic: textEl.italic || false,
-      borderColor: textEl.borderColor || '#ADD8E6',
-      backgroundColor: textEl.backgroundColor || '#FFFFFF',
-      backgroundOpacity: textEl.backgroundOpacity !== undefined ? textEl.backgroundOpacity : 0.8,
-      padding: textEl.padding || 8
+      return self._loadFurnitureModels(kidataObj, floorIndex);
     });
-
-    sprite.position.set(x, y, z);
-    sprite.userData = { type: 'text', elementId: textEl.id };
-    floorTextGroup.add(sprite);
-  });
-
-  console.log('✅ 楼层' + floorIndex + '文字加载完成: ' + textElements.length + ' 个');
 };
 
 KimapSDK.prototype._decryptKidata = function(encrypted) {
@@ -1098,29 +1014,53 @@ KimapSDK.prototype._decryptKidata = function(encrypted) {
   }
 };
 
-KimapSDK.prototype._loadFurnitureModels = function(kidataObj, targetGroup) {
+KimapSDK.prototype._loadFurnitureModels = function(kidataObj, floorIndex) {
   var self = this;
+  var isMultiFloorMode = floorIndex !== undefined && floorIndex >= 0;
 
   if (!kidataObj.furnitures || kidataObj.furnitures.length === 0) {
     return Promise.resolve({ loaded: 0, failed: 0 });
   }
 
-  // 创建家具组（如果不存在）
-  if (!this.furnitureGroup) {
-    this.furnitureGroup = new THREE.Group();
-    this.furnitureGroup.name = 'furnitures';
-    this.core.scene.add(this.furnitureGroup);
-  }
+  var furnitureGroup;
 
-  // 多楼层模式：家具加载到指定楼层的子Group（随楼层移动）
-  // 单楼层模式：家具加载到场景家具组（独立存在）
-  var target = targetGroup || this.furnitureGroup;
+  if (isMultiFloorMode) {
+    // 多楼层模式：家具放进对应楼层的 furnitureGroup（作为 floorGroup 子级）
+    if (!this.floorFurnitureGroups[floorIndex]) {
+      furnitureGroup = new THREE.Group();
+      furnitureGroup.name = 'furnitures';
+      this.floorFurnitureGroups[floorIndex] = furnitureGroup;
+      var floorGroup = this.core.floorGroups[floorIndex];
+      if (floorGroup) floorGroup.add(furnitureGroup);
+    } else {
+      furnitureGroup = this.floorFurnitureGroups[floorIndex];
+      // 清空现有家具
+      while (furnitureGroup.children.length > 0) {
+        var child = furnitureGroup.children[0];
+        furnitureGroup.remove(child);
+        if (child.geometry) child.geometry.dispose();
+        if (child.material) {
+          if (Array.isArray(child.material)) {
+            child.material.forEach(function(m) { m.dispose(); });
+          } else {
+            child.material.dispose();
+          }
+        }
+      }
+    }
+  } else {
+    // 单楼层模式：家具放进全局 furnitureGroup（直接加到 scene）
+    if (!this.furnitureGroup) {
+      this.furnitureGroup = new THREE.Group();
+      this.furnitureGroup.name = 'furnitures';
+      this.core.scene.add(this.furnitureGroup);
+    }
+    furnitureGroup = this.furnitureGroup;
 
-  // 单楼层模式：清空场景家具组
-  if (!targetGroup) {
-    while (this.furnitureGroup.children.length > 0) {
-      var child = this.furnitureGroup.children[0];
-      this.furnitureGroup.remove(child);
+    // 清空现有家具
+    while (furnitureGroup.children.length > 0) {
+      var child = furnitureGroup.children[0];
+      furnitureGroup.remove(child);
       if (child.geometry) child.geometry.dispose();
       if (child.material) {
         if (Array.isArray(child.material)) {
@@ -1138,11 +1078,13 @@ KimapSDK.prototype._loadFurnitureModels = function(kidataObj, targetGroup) {
   var loadedCount = 0;
   var failedCount = 0;
 
+  // 加载每个家具模型
+  var self2 = this;
   kidataObj.furnitures.forEach(function(furniture) {
-    var promise = self._loadSingleFurniture(furniture, serverUrl)
+    var promise = self2._loadSingleFurniture(furniture, serverUrl)
       .then(function(mesh) {
         if (mesh) {
-          target.add(mesh);
+          furnitureGroup.add(mesh);
           loadedCount++;
         } else {
           failedCount++;

package/src/core/SceneCore.js

@@ -62,12 +62,11 @@ function SceneCore(config) {
 
   // 多楼层支持（不影响单楼层原有渲染路径）
   this.floorGroups = [];
-  this.floorFurnitureGroups = []; // 每层独立的家具Group
-  this.floorTextGroups = [];      // 每层独立的文字Group
+  this.floorTextGroups = []; // 每个楼层的文字组
+  this.floorTextElements = []; // 每个楼层的文字数据
   this.floorHeight = 3; // 米
   this.isMultiFloor = Array.isArray(config.objUrl);
   this.floorOriginalY = []; // 每个楼层的原始世界Y偏移（含间隙）
-  this.onFloorModelsLoaded = null; // 回调：所有楼层模型加载完毕后触发
 }
 
 /**
@@ -100,12 +99,6 @@ SceneCore.prototype.init = function() {
       var OBJLoader = loaders[0];
       var MTLLoader = loaders[1];
       return self.loadMap(OBJLoader, MTLLoader);
-    })
-    .then(function() {
-      // 通知 onFloorModelsLoaded（如果已注册）
-      if (typeof self.onFloorModelsLoaded === 'function') {
-        self.onFloorModelsLoaded();
-      }
     });
 };
 
@@ -277,11 +270,10 @@ SceneCore.prototype.loadMap = function(OBJLoader, MTLLoader) {
 };
 
 /**
- * 多楼层：依次加载多个模型（两阶段：先加载添加，再统一算中心对齐）
+ * 多楼层：依次加载多个模型（新增能力，不改变单楼层逻辑）
  * @private
- * @param {Function} onAllLoaded - 所有楼层模型加载完毕后的回调（此时 floorGroups 已就绪）
  */
-SceneCore.prototype._loadMultiFloorMaps = function(OBJLoader, MTLLoader, objUrls, onAllLoaded) {
+SceneCore.prototype._loadMultiFloorMaps = function(OBJLoader, MTLLoader, objUrls) {
   var self = this;
   var floorIndex = 0;
 
@@ -290,16 +282,8 @@ SceneCore.prototype._loadMultiFloorMaps = function(OBJLoader, MTLLoader, objUrls
       return self._loadSingleMapWithFloorIndex(OBJLoader, MTLLoader, url, floorIndex++);
     });
   }, Promise.resolve()).then(function() {
-    // 阶段二：所有楼层加载完毕后，按联合包围盒中心对齐 XZ
     if (self.floorGroups.length > 1) {
-      self._alignAllFloorsToCenter();
-    }
-    // 通知 SDK 层：楼层模型已就绪，可以加载各层 kidata 了
-    if (typeof onAllLoaded === 'function') {
-      onAllLoaded();
-    }
-    if (typeof self.onFloorModelsLoaded === 'function') {
-      self.onFloorModelsLoaded();
+      self._adjustCameraToAllFloors();
     }
   });
 };
@@ -391,6 +375,13 @@ SceneCore.prototype._loadKimapFileToGroup = function(kimapUrl, themeUrl, objLoad
           var object = objLoader.parse(objContent);
           self._processLoadedModelToGroup(object, materials, colorMap, floorGroup, floorIndex);
 
+          // 每个楼层从自己的 .kimap 文件中提取并渲染文字
+          var textElements = extractTextElementsFromOBJ(objContent);
+          if (textElements && textElements.length > 0) {
+            self.floorTextElements[floorIndex] = textElements;
+            self.renderTextElementsToFloor(floorIndex, textElements);
+          }
+
           resolve();
         } catch (error) {
           reject(error);
@@ -427,38 +418,34 @@ SceneCore.prototype._processLoadedModelToGroup = function(object, materials, col
   var self = this;
   floorGroup.add(object);
 
-  // 为该层创建文字组（作为 floorGroup 子级，随楼层移动）
-  if (!self.floorTextGroups) self.floorTextGroups = [];
-  var floorTextGroup = new THREE.Group();
-  floorTextGroup.name = 'texts_floor_' + floorIndex;
-  floorGroup.add(floorTextGroup);
-  self.floorTextGroups[floorIndex] = floorTextGroup;
-
   var box = new THREE.Box3().setFromObject(object);
   var boxHeight = box.max.y - box.min.y;
 
-  // 记录每层的包围盒（供两阶段定位使用）
-  if (!self._floorBoxes) self._floorBoxes = [];
-  self._floorBoxes[floorIndex] = box;
-
   // 逐层累积高度：计算该楼层在 ALL 模式下的世界 Y 偏移
   var floorY = 0;
   for (var i = 0; i < floorIndex; i++) {
-    var prevBox = self._floorBoxes[i];
-    if (prevBox) floorY += (prevBox.max.y - prevBox.min.y);
+    var prevGroup = self.floorGroups[i];
+    if (prevGroup) {
+      var prevBox = new THREE.Box3().setFromObject(prevGroup);
+      floorY += (prevBox.max.y - prevBox.min.y);
+    }
   }
 
-  // object.position.y = -box.min.y：对象底部（box.min.y）对齐到本地 Y=0
-  // 单层模式 floorGroup.position.y=0 → 对象底部世界 Y=0（贴地）
-  // ALL 模式 floorGroup.position.y=floorY → 对象底部世界 Y=floorY（堆叠）
+  // 所有楼层的 object 底部（box.min.y）对齐到本地 Y=0，统一基准
   object.position.set(-box.min.x, -box.min.y, -box.min.z);
 
-  // 初始 Y 偏移（XZ 后续由 _alignAllFloorsToCenter 统一调整）
-  floorGroup.position.set(0, floorY, 0);
+  // ALL 模式时 floorGroup.position.y 持有累积偏移（含间隙）
+  floorGroup.position.y = floorY;
 
-  // 记录原始 Y 偏移（showSingleFloor/showAllFloors 使用）
+  // 记录每个楼层的原始世界 Y 偏移（单层模式时用于将选中层拽回 Y=0）
   self.floorOriginalY[floorIndex] = floorY;
 
+  // 为该楼层创建独立的文字组
+  var textGroup = new THREE.Group();
+  textGroup.name = 'texts';
+  floorGroup.add(textGroup);
+  self.floorTextGroups[floorIndex] = textGroup;
+
   // 复用 backup 的材质处理策略，不改渲染风格
   object.traverse(function(child) {
     if (child.name === 'HiddenGroundPlane' || child.name.includes('InteractionLayer')) {
@@ -471,34 +458,6 @@ SceneCore.prototype._processLoadedModelToGroup = function(object, materials, col
   });
 };
 
-/**
- * 多楼层：ALL 模式按每个楼层的几何中心对齐 XZ（Y 堆叠不变）
- * object.position = (-box.min.x, -box.min.y, -box.min.z)
- * 所以对象在 group 空间里范围是 [0~width, minY~maxY, 0~depth]
- * 中心 = (width/2, (minY+maxY)/2, depth/2)
- * 令 group.position.x/z = -center，即把中心对齐到世界原点
- * @private
- */
-SceneCore.prototype._alignAllFloorsToCenter = function() {
-  var self = this;
-  if (!self._floorBoxes || self._floorBoxes.length === 0) return;
-
-  self.floorGroups.forEach(function(group, index) {
-    var box = self._floorBoxes[index];
-    if (!box) return;
-
-    var boxW = box.max.x - box.min.x;
-    var boxD = box.max.z - box.min.z;
-    var centerX = boxW / 2;
-    var centerZ = boxD / 2;
-
-    group.position.x = -centerX;
-    group.position.z = -centerZ;
-  });
-
-  console.log('[SceneCore] 多楼层按中心对齐 XZ 完成');
-};
-
 /**
  * 多楼层：相机看全楼层
  * @private
@@ -1052,6 +1011,57 @@ SceneCore.prototype.createTextSprite = function(options) {
   return sprite;
 };
 
+/**
+ * 多楼层专用：渲染文字到指定楼层的 textGroup
+ */
+SceneCore.prototype.renderTextElementsToFloor = function(floorIndex, textElements) {
+  var self = this;
+
+  if (!textElements || textElements.length === 0) return;
+
+  var floorGroup = this.floorGroups[floorIndex];
+  var textGroup = this.floorTextGroups[floorIndex];
+  if (!floorGroup || !textGroup) return;
+
+  // 清空该楼层现有文字
+  while (textGroup.children.length > 0) {
+    var child = textGroup.children[0];
+    textGroup.remove(child);
+    if (child.material && child.material.map) child.material.map.dispose();
+    if (child.material) child.material.dispose();
+  }
+
+  textElements.forEach(function(textEl) {
+    if (!textEl.points || textEl.points.length === 0) return;
+
+    var point = textEl.points[0];
+    var x = point.x / 100;
+    var z = point.y / 100;
+    var LOGICAL_WALL_HEIGHT = 3000;
+    var RENDER_WALL_HEIGHT = 0.375;
+    var elevationMm = textEl.elevation || 8500;
+    var y = (elevationMm / LOGICAL_WALL_HEIGHT) * RENDER_WALL_HEIGHT;
+    var TEXT_SCALE_FACTOR = 2.52;
+
+    var sprite = self.createTextSprite({
+      content: textEl.content || '',
+      fontSize: (textEl.fontSize || 16) * TEXT_SCALE_FACTOR,
+      color: textEl.color || '#000000',
+      fontFamily: textEl.fontFamily || 'Arial, sans-serif',
+      bold: textEl.bold || false,
+      italic: textEl.italic || false,
+      borderColor: textEl.borderColor || '#ADD8E6',
+      backgroundColor: textEl.backgroundColor || '#FFFFFF',
+      backgroundOpacity: textEl.backgroundOpacity !== undefined ? textEl.backgroundOpacity : 0.8,
+      padding: textEl.padding || 8
+    });
+
+    sprite.position.set(x, y, z);
+    sprite.userData = { type: 'text', elementId: textEl.id };
+    textGroup.add(sprite);
+  });
+};
+
 /**
  * 渲染文本元素到场景
  */