@kimap/indoor-positioning-sdk-vue2 5.2.0 → 5.2.1

package/package.json

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

package/src/KimapCore.browser.js

@@ -277,6 +277,37 @@
     return wallOpacity;
   }
 
+  // 从OBJ内容中提取形状透明度信息（矩形、圆形、多边形）
+  function extractShapeOpacityFromOBJ(objContent) {
+    var shapeOpacity = {};
+    var lines = objContent.split('\n');
+    var currentShapeId = null;
+    var currentShapeType = null;
+    
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      
+      if (line.indexOf('o Shape_') === 0) {
+        // 提取形状ID和类型（格式：Shape_<type>_<id>）
+        var match = line.match(/Shape_([^_]+)_(.+)/);
+        if (match) {
+          currentShapeType = match[1];
+          currentShapeId = match[2];
+        }
+      } else if (currentShapeId && line.indexOf('# SHAPE_OPACITY') === 0) {
+        var opacity = parseFloat(line.split(' ')[2]);
+        if (!shapeOpacity[currentShapeId]) {
+          shapeOpacity[currentShapeId] = {};
+        }
+        shapeOpacity[currentShapeId].opacity = opacity;
+        shapeOpacity[currentShapeId].type = currentShapeType;
+      }
+    }
+    
+    console.log('[Parsers] 提取到的形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+    return shapeOpacity;
+  }
+
   /**
    * 3D 场景核心
    */
@@ -646,6 +677,13 @@
                   self._wallOpacity = wallOpacity;
                 }
                 
+                // 提取形状透明度信息（矩形、圆形、多边形）
+                var shapeOpacity = extractShapeOpacityFromOBJ(objContent);
+                if (shapeOpacity && Object.keys(shapeOpacity).length > 0) {
+                  console.log('✅ 从OBJ提取到形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+                  self._shapeOpacity = shapeOpacity;
+                }
+                
                 var object = objLoader.parse(objContent);
                 self.processModel(object, colorMap);
                 
@@ -769,11 +807,18 @@
                      child.material.name.startsWith('Stair_')) {
             roughness = 0.6;
             metalness = 0;
-            // 保持从MTL中获取的真实透明度
-            if (opacity === 1.0) {
-              opacity = 0.9;
+            
+            // 从OBJ提取的形状透明度数据中读取
+            if (self._shapeOpacity) {
+              var shapeId = child.material.name.replace('Shape_', '').replace(/^rectangle_/, '').replace(/^circle_/, '').replace(/^polygon_/, '');
+              if (self._shapeOpacity[shapeId]) {
+                opacity = self._shapeOpacity[shapeId].opacity;
+                transparent = opacity < 1.0;
+                // 高透明度时关闭depthWrite
+                depthWrite = opacity >= 0.8;
+                console.log('[SceneCore] 应用形状透明度:', shapeId, '=', opacity);
+              }
             }
-            transparent = opacity < 1.0;
             // 混合10%白色，让颜色更浅一点
             var color = new THREE.Color(mtlColor);
             color.lerp(new THREE.Color(0xffffff), 0.1);
@@ -1939,6 +1984,9 @@
       .then(function(result) {
         console.log('✅ 3D家具模型加载完成:', result);
         
+        // 加载完成后应用形状透明度
+        self._applyShapeOpacity(kidataObj);
+        
         return { success: true, loaded: result.loaded, failed: result.failed };
       })
       .catch(function(error) {
@@ -2708,6 +2756,100 @@
     }
   };
 
+  /**
+   * 应用矩形/圆形/多边形透明度
+   * @private
+   */
+  KimapSDK.prototype._applyShapeOpacity = function(kidataObj) {
+    if (!kidataObj || !kidataObj.floors || !this.core || !this.core.scene) {
+      console.log('[KimapSDK] _applyShapeOpacity: 缺少必要数据');
+      return;
+    }
+    
+    console.log('[KimapSDK] 开始应用形状透明度...');
+    
+    var shapeCount = 0;
+    var shapesInKidata = [];
+    var self = this;
+    
+    // 收集kidata中的所有形状数据（rectangle, circle, polygon）
+    kidataObj.floors.forEach(function(floor) {
+      if (floor.layers) {
+        floor.layers.forEach(function(layer) {
+          if (layer.elements) {
+            layer.elements.forEach(function(element) {
+              if (element.type === 'rectangle' || element.type === 'circle' || element.type === 'polygon') {
+                shapesInKidata.push({
+                  id: element.id,
+                  type: element.type,
+                  opacity: element.opacity !== undefined ? element.opacity : 0.9
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+    
+    console.log('[KimapSDK] Kidata中形状数量:', shapesInKidata.length);
+    
+    if (shapesInKidata.length === 0) {
+      console.log('[KimapSDK] Kidata中没有形状数据');
+      return;
+    }
+    
+    // 遍历场景中的所有对象，通过材质名称识别形状
+    this.core.scene.traverse(function(object) {
+      if (object instanceof THREE.Mesh && object.material) {
+        var materialName = object.material.name || '';
+        
+        // 通过材质名称识别形状（Shape_前缀）
+        if (materialName.startsWith('Shape_')) {
+          // 从材质名称中提取形状ID（格式：Shape_<type>_<id>）
+          var parts = materialName.split('_');
+          var shapeId = parts[parts.length - 1];
+          
+          // 在kidata中查找对应的形状数据
+          var shapeData = shapesInKidata.find(function(s) {
+            return s.id === shapeId;
+          });
+          
+          if (shapeData) {
+            var opacity = shapeData.opacity;
+            
+            console.log('[KimapSDK] 应用形状透明度:', {
+              id: shapeId,
+              type: shapeData.type,
+              opacity: opacity,
+              materialName: materialName
+            });
+            
+            // 应用透明度到材质
+            if (Array.isArray(object.material)) {
+              object.material.forEach(function(mat) {
+                mat.transparent = opacity < 1;
+                mat.opacity = opacity;
+                mat.needsUpdate = true;
+              });
+            } else {
+              object.material.transparent = opacity < 1;
+              object.material.opacity = opacity;
+              object.material.needsUpdate = true;
+            }
+            
+            shapeCount++;
+          }
+        }
+      }
+    });
+    
+    if (shapeCount > 0) {
+      console.log('[KimapSDK] ✅ 应用形状透明度完成:', shapeCount, '个形状');
+    } else {
+      console.log('[KimapSDK] ⚠️ 未找到匹配的形状对象');
+    }
+  };
+
   /**
    * 从kidata内容加载家具模型（不处理文本和墙体透明度）
    * @param {string} kidataContent - kidata文件内容（加密或未加密）
@@ -2742,6 +2884,10 @@
       return self._loadFurnitureModels(kidataObj)
         .then(function(result) {
           console.log('[KimapSDK] ✅ 3D家具模型加载完成:', result);
+          
+          // 加载完成后应用形状透明度
+          self._applyShapeOpacity(kidataObj);
+          
           return { success: true, loaded: result.loaded, failed: result.failed };
         });
     } catch (error) {

package/src/core/SceneCore.js

@@ -28,6 +28,7 @@ var extractMapConfigFromOBJ = parsers.extractMapConfigFromOBJ;
 var extractColorsFromOBJ = parsers.extractColorsFromOBJ;
 var extractTextElementsFromOBJ = parsers.extractTextElementsFromOBJ;
 var extractWallOpacityFromOBJ = parsers.extractWallOpacityFromOBJ;
+var extractShapeOpacityFromOBJ = parsers.extractShapeOpacityFromOBJ;
 
 /**
  * SceneCore 构造函数
@@ -385,6 +386,13 @@ SceneCore.prototype._loadKimapFile = function(kimapUrl, themeUrl, objLoader, mtl
             console.log('[SceneCore] ✅ 从OBJ提取到墙体透明度:', Object.keys(wallOpacity).length, '个墙体');
             self._wallOpacity = wallOpacity;
           }
+          
+          // 提取形状透明度信息（矩形、圆形、多边形）
+          var shapeOpacity = extractShapeOpacityFromOBJ(objContent);
+          if (shapeOpacity && Object.keys(shapeOpacity).length > 0) {
+            console.log('[SceneCore] ✅ 从OBJ提取到形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+            self._shapeOpacity = shapeOpacity;
+          }
         
           // 解析OBJ内容
           var object = objLoader.parse(objContent);
@@ -627,11 +635,17 @@ SceneCore.prototype._processMaterial = function(child, materials, colorMap) {
     } else if (child.material.name.startsWith('Shape_') || child.material.name.startsWith('Stair_')) {
       roughness = 0.6;
       metalness = 0;
-      // 保持从MTL中获取的真实透明度
-      if (opacity === 1.0) {
-        opacity = 0.9;
+      // 从OBJ提取的形状透明度数据中读取
+      if (self._shapeOpacity) {
+        var shapeId = child.material.name.replace('Shape_', '').replace(/^rectangle_/, '').replace(/^circle_/, '').replace(/^polygon_/, '');
+        if (self._shapeOpacity[shapeId]) {
+          opacity = self._shapeOpacity[shapeId].opacity;
+          transparent = opacity < 1.0;
+          // 高透明度时关闭depthWrite
+          depthWrite = opacity >= 0.8;
+          console.log('[SceneCore] 应用形状透明度:', shapeId, '=', opacity);
+        }
       }
-      transparent = opacity < 1.0;
       // 混合10%白色，让颜色更浅一点
       var color = new THREE.Color(mtlColor);
       color.lerp(new THREE.Color(0xffffff), 0.1);

package/src/core/parsers.js

@@ -213,11 +213,46 @@ function extractWallOpacityFromOBJ(objContent) {
   return wallOpacity;
 }
 
+/**
+ * 从OBJ内容中提取形状透明度信息（矩形、圆形、多边形）
+ * 格式: # SHAPE_OPACITY 0.9
+ */
+function extractShapeOpacityFromOBJ(objContent) {
+  var shapeOpacity = {};
+  var lines = objContent.split('\n');
+  var currentShapeId = null;
+  var currentShapeType = null;
+  
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    
+    if (line.indexOf('o Shape_') === 0) {
+      // 提取形状ID和类型（格式：Shape_<type>_<id>）
+      var match = line.match(/Shape_([^_]+)_(.+)/);
+      if (match) {
+        currentShapeType = match[1];
+        currentShapeId = match[2];
+      }
+    } else if (currentShapeId && line.indexOf('# SHAPE_OPACITY') === 0) {
+      var opacity = parseFloat(line.split(' ')[2]);
+      if (!shapeOpacity[currentShapeId]) {
+        shapeOpacity[currentShapeId] = {};
+      }
+      shapeOpacity[currentShapeId].opacity = opacity;
+      shapeOpacity[currentShapeId].type = currentShapeType;
+    }
+  }
+  
+  console.log('[Parsers] 提取到的形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+  return shapeOpacity;
+}
+
 module.exports = {
   extractBorderFromOBJ: extractBorderFromOBJ,
   extractMapConfigFromOBJ: extractMapConfigFromOBJ,
   extractColorsFromOBJ: extractColorsFromOBJ,
   extractCoordinateSystem: extractCoordinateSystem,
   extractTextElementsFromOBJ: extractTextElementsFromOBJ,
-  extractWallOpacityFromOBJ: extractWallOpacityFromOBJ
+  extractWallOpacityFromOBJ: extractWallOpacityFromOBJ,
+  extractShapeOpacityFromOBJ: extractShapeOpacityFromOBJ
 };