@kimap/indoor-positioning-sdk-vue2 5.7.7 → 5.7.8

package/package.json

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

package/src/core/KimapSDK.js

@@ -82,9 +82,10 @@ 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
@@ -607,16 +608,17 @@ KimapSDK.prototype.showSingleFloor = function(floorIndex) {
   var self = this;
   this.floorGroups.forEach(function(group, index) {
     if (index === floorIndex) {
-      // 单层模式：将该楼层移动到贴地位置（y = 0）
+      // 贴地 + 清除ALL模式的XZ中心对齐
       group.visible = true;
-      group.position.y = 0;
+      group.position.set(0, 0, 0);
     } else {
-      // 隐藏其他楼层，同时移到下方避免干扰
       group.visible = false;
       var originalY = self.core.floorOriginalY[index] || 0;
-      group.position.y = -originalY - 1; // 移到地面以下
+      group.position.y = -originalY - 1;
+      // XZ 保持中心对齐（向下移动后不再占用视觉空间）
     }
   });
+  this.currentFloorIndex = floorIndex;
 };
 
 /**
@@ -628,10 +630,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;
 };
 
 /**
@@ -888,55 +890,62 @@ KimapSDK.prototype.getConfig = function() {
 
 KimapSDK.prototype.loadKMData = function() {
   var self = this;
-  
+
   if (!this.dataUrl) {
     console.warn('⚠️ 未配置dataUrl，无法加载3D家具模型');
     return Promise.resolve({ success: false, message: '未配置dataUrl' });
   }
-  
+
   if (!this.config.objUrl) {
     console.warn('⚠️ 未配置objUrl，无法确定kidata文件名');
     return Promise.resolve({ success: false, message: '未配置objUrl' });
   }
-  
-  // 从objUrl提取文件名和目录（支持数组或字符串）
+
   var objUrl = this.config.objUrl;
   var isArray = Array.isArray(objUrl);
-  var firstUrl = isArray ? objUrl[0] : 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 firstUrl = objUrl;
   var lastSlashIndex = firstUrl.lastIndexOf('/');
   var directory = lastSlashIndex >= 0 ? firstUrl.substring(0, lastSlashIndex) : '';
   var fileName = firstUrl.split('/').pop().replace(/\.(obj|kimap)$/i, '');
   var kidataUrl = directory + '/' + fileName + '.kidata';
-  
+
   return fetch(kidataUrl)
     .then(function(response) {
-      if (!response.ok) {
-        throw new Error('Kidata文件加载失败: ' + response.status);
-      }
+      if (!response.ok) throw new Error('Kidata文件加载失败: ' + response.status);
       return response.text();
     })
     .then(function(encryptedData) {
-      // 解密kidata文件
       var decrypted = self._decryptKidata(encryptedData);
       var kidataObj = JSON.parse(decrypted);
-      
-      // 保存kidata数据供路径规划使用
       self.kidataContent = kidataObj;
-      
-      // 如果kidata包含楼层数据，设置为projectLayers
-      if (kidataObj.floors && Array.isArray(kidataObj.floors)) {
-        // 设置第一个楼层为当前楼层（如果没有其他楼层数据）
-        if (!self.projectLayers && kidataObj.floors.length > 0) {
-          self.projectLayers = kidataObj.floors[0].layers;
-        }
+      if (kidataObj.floors && Array.isArray(kidataObj.floors) && kidataObj.floors.length > 0) {
+        self.projectLayers = kidataObj.floors[0].layers;
       }
-      
-      // 加载3D家具模型
       return self._loadFurnitureModels(kidataObj);
     })
     .then(function(result) {
       console.log('✅ 家具加载完成：成功 ' + result.loaded + ' 个，失败 ' + result.failed + ' 个');
-      
       return { success: true, loaded: result.loaded, failed: result.failed };
     })
     .catch(function(error) {
@@ -945,6 +954,131 @@ KimapSDK.prototype.loadKMData = function() {
     });
 };
 
+/**
+ * 多楼层：为指定楼层加载 kidata（含家具 + 文字）
+ * @private
+ */
+KimapSDK.prototype._loadKidataForFloor = function(url, 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 kidataUrl = directory + '/' + fileName + '.kidata';
+
+  return fetch(kidataUrl)
+    .then(function(response) {
+      if (!response.ok) throw new Error('Kidata文件加载失败: ' + response.status);
+      return response.text();
+    })
+    .then(function(encryptedData) {
+      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);
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+
+  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
+    });
+
+    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) {
   try {
     // 1. Base64解码
@@ -964,48 +1098,51 @@ KimapSDK.prototype._decryptKidata = function(encrypted) {
   }
 };
 
-KimapSDK.prototype._loadFurnitureModels = function(kidataObj) {
+KimapSDK.prototype._loadFurnitureModels = function(kidataObj, targetGroup) {
   var self = this;
-  
+
   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);
   }
-  
-  // 清空现有家具
-  while (this.furnitureGroup.children.length > 0) {
-    var child = this.furnitureGroup.children[0];
-    this.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();
+
+  // 多楼层模式：家具加载到指定楼层的子Group（随楼层移动）
+  // 单楼层模式：家具加载到场景家具组（独立存在）
+  var target = targetGroup || this.furnitureGroup;
+
+  // 单楼层模式：清空场景家具组
+  if (!targetGroup) {
+    while (this.furnitureGroup.children.length > 0) {
+      var child = this.furnitureGroup.children[0];
+      this.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();
+        }
       }
     }
   }
-  
+
   // 优先使用dataUrl，如果不存在则使用serverUrl（兼容旧版本）
   var serverUrl = kidataObj.dataUrl || kidataObj.serverUrl;
   var loadPromises = [];
   var loadedCount = 0;
   var failedCount = 0;
-  
-  // 加载每个家具模型
+
   kidataObj.furnitures.forEach(function(furniture) {
     var promise = self._loadSingleFurniture(furniture, serverUrl)
       .then(function(mesh) {
         if (mesh) {
-          self.furnitureGroup.add(mesh);
+          target.add(mesh);
           loadedCount++;
         } else {
           failedCount++;
@@ -1014,10 +1151,10 @@ KimapSDK.prototype._loadFurnitureModels = function(kidataObj) {
       .catch(function(error) {
         failedCount++;
       });
-    
+
     loadPromises.push(promise);
   });
-  
+
   return Promise.all(loadPromises).then(function() {
     return { loaded: loadedCount, failed: failedCount };
   });

package/src/core/SceneCore.js

@@ -62,9 +62,12 @@ function SceneCore(config) {
 
   // 多楼层支持（不影响单楼层原有渲染路径）
   this.floorGroups = [];
+  this.floorFurnitureGroups = []; // 每层独立的家具Group
+  this.floorTextGroups = [];      // 每层独立的文字Group
   this.floorHeight = 3; // 米
   this.isMultiFloor = Array.isArray(config.objUrl);
   this.floorOriginalY = []; // 每个楼层的原始世界Y偏移（含间隙）
+  this.onFloorModelsLoaded = null; // 回调：所有楼层模型加载完毕后触发
 }
 
 /**
@@ -97,6 +100,12 @@ 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();
+      }
     });
 };
 
@@ -268,10 +277,11 @@ SceneCore.prototype.loadMap = function(OBJLoader, MTLLoader) {
 };
 
 /**
- * 多楼层：依次加载多个模型（新增能力，不改变单楼层逻辑）
+ * 多楼层：依次加载多个模型（两阶段：先加载添加，再统一算中心对齐）
  * @private
+ * @param {Function} onAllLoaded - 所有楼层模型加载完毕后的回调（此时 floorGroups 已就绪）
  */
-SceneCore.prototype._loadMultiFloorMaps = function(OBJLoader, MTLLoader, objUrls) {
+SceneCore.prototype._loadMultiFloorMaps = function(OBJLoader, MTLLoader, objUrls, onAllLoaded) {
   var self = this;
   var floorIndex = 0;
 
@@ -280,8 +290,16 @@ 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._adjustCameraToAllFloors();
+      self._alignAllFloorsToCenter();
+    }
+    // 通知 SDK 层：楼层模型已就绪，可以加载各层 kidata 了
+    if (typeof onAllLoaded === 'function') {
+      onAllLoaded();
+    }
+    if (typeof self.onFloorModelsLoaded === 'function') {
+      self.onFloorModelsLoaded();
     }
   });
 };
@@ -373,15 +391,6 @@ SceneCore.prototype._loadKimapFileToGroup = function(kimapUrl, themeUrl, objLoad
           var object = objLoader.parse(objContent);
           self._processLoadedModelToGroup(object, materials, colorMap, floorGroup, floorIndex);
 
-          // 提取文字元素（每个楼层都提取，以第一个楼层为准）
-          if (!self._textElements || self._textElements.length === 0) {
-            var textElements = extractTextElementsFromOBJ(objContent);
-            if (textElements && textElements.length > 0) {
-              self._textElements = textElements;
-              self.renderTextElements(self._textElements);
-            }
-          }
-
           resolve();
         } catch (error) {
           reject(error);
@@ -418,26 +427,36 @@ 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 prevGroup = self.floorGroups[i];
-    if (prevGroup) {
-      var prevBox = new THREE.Box3().setFromObject(prevGroup);
-      floorY += (prevBox.max.y - prevBox.min.y);
-    }
+    var prevBox = self._floorBoxes[i];
+    if (prevBox) floorY += (prevBox.max.y - prevBox.min.y);
   }
 
-  // 所有楼层的 object 底部（box.min.y）对齐到本地 Y=0，统一基准
+  // 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.position.set(-box.min.x, -box.min.y, -box.min.z);
 
-  // ALL 模式时 floorGroup.position.y 持有累积偏移（含间隙）
-  floorGroup.position.y = floorY;
+  // 初始 Y 偏移（XZ 后续由 _alignAllFloorsToCenter 统一调整）
+  floorGroup.position.set(0, floorY, 0);
 
-  // 记录每个楼层的原始世界 Y 偏移（单层模式时用于将选中层拽回 Y=0）
+  // 记录原始 Y 偏移（showSingleFloor/showAllFloors 使用）
   self.floorOriginalY[floorIndex] = floorY;
 
   // 复用 backup 的材质处理策略，不改渲染风格
@@ -452,6 +471,34 @@ 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