670 lines
24 KiB
Python
670 lines
24 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
SUW Core - Data Manager Module
|
||
数据管理中心 - 统一管理所有共用数据
|
||
用途: 替代Ruby中的@zones、@parts、@hardwares等全局变量
|
||
版本: 1.0.0
|
||
作者: SUWood Team
|
||
"""
|
||
|
||
import logging
|
||
import threading
|
||
from typing import Dict, Any, Optional, List
|
||
|
||
# 设置日志
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# 检查Blender可用性
|
||
try:
|
||
import bpy
|
||
BLENDER_AVAILABLE = True
|
||
except ImportError:
|
||
BLENDER_AVAILABLE = False
|
||
|
||
# ==================== 数据管理器类 ====================
|
||
|
||
|
||
class DataManager:
|
||
"""数据管理器 - 统一管理所有SUWood数据"""
|
||
|
||
def __init__(self):
|
||
"""初始化数据管理器"""
|
||
# 核心数据存储 - 对应Ruby的实例变量
|
||
self.zones = {} # @zones - {uid: {zone_id: zone_data}}
|
||
self.parts = {} # @parts - {uid: {part_id: part_data}}
|
||
self.hardwares = {} # @hardwares - {uid: {hw_id: hw_data}}
|
||
self.labels = {} # @labels - {uid: {label_id: label_data}}
|
||
self.door_labels = {} # @door_labels - {uid: {door_label_id: door_label_data}}
|
||
self.machinings = {} # @machinings - {uid: [machining_list]}
|
||
self.dimensions = {} # @dimensions - {uid: [dimension_list]}
|
||
|
||
# 单元参数 - 对应Ruby的@unit_param和@unit_trans
|
||
self.unit_params = {} # @unit_param - {uid: params}
|
||
self.unit_trans = {} # @unit_trans - {uid: transformation}
|
||
|
||
# 材质和纹理 - 对应Ruby的@textures
|
||
self.textures = {} # @textures - {ckey: material}
|
||
|
||
# 系统状态
|
||
self.part_mode = False # @part_mode
|
||
self.hide_none = False # @hide_none
|
||
self.mat_type = 0 # @mat_type (MAT_TYPE_NORMAL)
|
||
self.back_material = False # @back_material
|
||
self.added_contour = False # @added_contour
|
||
|
||
# 选择状态 - 对应Ruby的类变量
|
||
self.selected_uid = None # @@selected_uid
|
||
self.selected_obj = None # @@selected_obj
|
||
self.selected_zone = None # @@selected_zone
|
||
self.selected_part = None # @@selected_part
|
||
self.scaled_zone = None # @@scaled_zone
|
||
|
||
# 选择集合
|
||
self.selected_faces = [] # @selected_faces
|
||
self.selected_parts = [] # @selected_parts
|
||
self.selected_hws = [] # @selected_hws
|
||
|
||
# Blender对象引用
|
||
self.labels_group = None # @labels - Blender组对象
|
||
self.door_labels_group = None # @door_labels - Blender组对象
|
||
self.door_layer = None # @door_layer
|
||
self.drawer_layer = None # @drawer_layer
|
||
self.default_zone = None # @@default_zone
|
||
|
||
# 线程安全
|
||
self.lock = threading.Lock()
|
||
|
||
logger.info("✅ 数据管理器初始化完成")
|
||
|
||
# ==================== Zones 数据管理 ====================
|
||
|
||
def get_zones(self, data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""获取区域数据 - 对应Ruby的get_zones方法"""
|
||
uid = data.get("uid")
|
||
if not uid:
|
||
return {}
|
||
|
||
with self.lock:
|
||
if uid not in self.zones:
|
||
self.zones[uid] = {}
|
||
return self.zones[uid]
|
||
|
||
def add_zone(self, uid: str, zid: Any, zone_obj: Any):
|
||
"""添加区域"""
|
||
with self.lock:
|
||
if uid not in self.zones:
|
||
self.zones[uid] = {}
|
||
self.zones[uid][zid] = zone_obj
|
||
logger.debug(f"添加区域: uid={uid}, zid={zid}")
|
||
|
||
def remove_zone(self, uid: str, zid: Any) -> bool:
|
||
"""删除区域"""
|
||
with self.lock:
|
||
if uid in self.zones and zid in self.zones[uid]:
|
||
del self.zones[uid][zid]
|
||
logger.debug(f"删除区域: uid={uid}, zid={zid}")
|
||
return True
|
||
return False
|
||
|
||
def clear_zones(self, uid: str):
|
||
"""清空指定uid的所有区域"""
|
||
with self.lock:
|
||
if uid in self.zones:
|
||
del self.zones[uid]
|
||
logger.debug(f"清空区域: uid={uid}")
|
||
|
||
# ==================== Parts 数据管理 ====================
|
||
|
||
def get_parts(self, data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""获取部件数据 - 对应Ruby的get_parts方法"""
|
||
uid = data.get("uid")
|
||
if not uid:
|
||
return {}
|
||
|
||
with self.lock:
|
||
if uid not in self.parts:
|
||
self.parts[uid] = {}
|
||
return self.parts[uid]
|
||
|
||
def add_part(self, uid: str, part_id: Any, part_obj: Any):
|
||
"""添加部件"""
|
||
with self.lock:
|
||
if uid not in self.parts:
|
||
self.parts[uid] = {}
|
||
self.parts[uid][part_id] = part_obj
|
||
logger.debug(f"添加部件: uid={uid}, part_id={part_id}")
|
||
|
||
def remove_part(self, uid: str, part_id: Any) -> bool:
|
||
"""删除部件"""
|
||
with self.lock:
|
||
if uid in self.parts and part_id in self.parts[uid]:
|
||
del self.parts[uid][part_id]
|
||
logger.debug(f"删除部件: uid={uid}, part_id={part_id}")
|
||
return True
|
||
return False
|
||
|
||
def clear_parts(self, uid: str):
|
||
"""清空指定uid的所有部件"""
|
||
with self.lock:
|
||
if uid in self.parts:
|
||
del self.parts[uid]
|
||
logger.debug(f"清空部件: uid={uid}")
|
||
|
||
# ==================== Hardwares 数据管理 ====================
|
||
|
||
def get_hardwares(self, data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""获取硬件数据 - 对应Ruby的get_hardwares方法"""
|
||
uid = data.get("uid")
|
||
if not uid:
|
||
return {}
|
||
|
||
with self.lock:
|
||
if uid not in self.hardwares:
|
||
self.hardwares[uid] = {}
|
||
return self.hardwares[uid]
|
||
|
||
def add_hardware(self, uid: str, hw_id: Any, hw_obj: Any):
|
||
"""添加硬件"""
|
||
with self.lock:
|
||
if uid not in self.hardwares:
|
||
self.hardwares[uid] = {}
|
||
self.hardwares[uid][hw_id] = hw_obj
|
||
logger.debug(f"添加硬件: uid={uid}, hw_id={hw_id}")
|
||
|
||
def remove_hardware(self, uid: str, hw_id: Any) -> bool:
|
||
"""删除硬件"""
|
||
with self.lock:
|
||
if uid in self.hardwares and hw_id in self.hardwares[uid]:
|
||
del self.hardwares[uid][hw_id]
|
||
logger.debug(f"删除硬件: uid={uid}, hw_id={hw_id}")
|
||
return True
|
||
return False
|
||
|
||
def clear_hardwares(self, uid: str):
|
||
"""清空指定uid的所有硬件"""
|
||
with self.lock:
|
||
if uid in self.hardwares:
|
||
del self.hardwares[uid]
|
||
logger.debug(f"清空硬件: uid={uid}")
|
||
|
||
# ==================== Labels 数据管理 ====================
|
||
|
||
def get_labels(self, uid: str) -> Dict[str, Any]:
|
||
"""获取标签数据"""
|
||
with self.lock:
|
||
if uid not in self.labels:
|
||
self.labels[uid] = {}
|
||
return self.labels[uid]
|
||
|
||
def get_door_labels(self, uid: str) -> Dict[str, Any]:
|
||
"""获取门标签数据"""
|
||
with self.lock:
|
||
if uid not in self.door_labels:
|
||
self.door_labels[uid] = {}
|
||
return self.door_labels[uid]
|
||
|
||
# ==================== Machinings 数据管理 ====================
|
||
|
||
def get_machinings(self, uid: str) -> List[Any]:
|
||
"""获取加工数据"""
|
||
with self.lock:
|
||
if uid not in self.machinings:
|
||
self.machinings[uid] = []
|
||
return self.machinings[uid]
|
||
|
||
def add_machining(self, uid: str, machining_obj: Any):
|
||
"""添加加工"""
|
||
with self.lock:
|
||
if uid not in self.machinings:
|
||
self.machinings[uid] = []
|
||
self.machinings[uid].append(machining_obj)
|
||
logger.debug(f"添加加工: uid={uid}")
|
||
|
||
def clear_machinings(self, uid: str):
|
||
"""清空指定uid的所有加工"""
|
||
with self.lock:
|
||
if uid in self.machinings:
|
||
self.machinings[uid].clear()
|
||
logger.debug(f"清空加工: uid={uid}")
|
||
|
||
def cleanup_machinings(self, uid: str):
|
||
"""清理指定uid的已删除加工对象"""
|
||
with self.lock:
|
||
if uid in self.machinings:
|
||
# 移除已删除的对象
|
||
self.machinings[uid] = [
|
||
machining for machining in self.machinings[uid]
|
||
if machining and self._is_entity_valid(machining)
|
||
]
|
||
logger.debug(
|
||
f"清理加工: uid={uid}, 剩余 {len(self.machinings[uid])} 个对象")
|
||
|
||
# ==================== Dimensions 数据管理 ====================
|
||
|
||
def get_dimensions(self, uid: str) -> List[Any]:
|
||
"""获取尺寸标注数据"""
|
||
with self.lock:
|
||
if uid not in self.dimensions:
|
||
self.dimensions[uid] = []
|
||
return self.dimensions[uid]
|
||
|
||
def add_dimension(self, uid: str, dimension_obj: Any):
|
||
"""添加尺寸标注"""
|
||
with self.lock:
|
||
if uid not in self.dimensions:
|
||
self.dimensions[uid] = []
|
||
self.dimensions[uid].append(dimension_obj)
|
||
logger.debug(f"添加尺寸标注: uid={uid}")
|
||
|
||
def clear_dimensions(self, uid: str):
|
||
"""清空指定uid的所有尺寸标注"""
|
||
with self.lock:
|
||
if uid in self.dimensions:
|
||
del self.dimensions[uid]
|
||
logger.debug(f"清空尺寸标注: uid={uid}")
|
||
|
||
# ==================== 材质管理 ====================
|
||
|
||
def get_texture(self, key: str) -> Any:
|
||
"""获取材质 - 对应Ruby的get_texture方法"""
|
||
if key and key in self.textures:
|
||
return self.textures[key]
|
||
return self.textures.get("mat_default")
|
||
|
||
def add_texture(self, key: str, material: Any):
|
||
"""添加材质"""
|
||
with self.lock:
|
||
self.textures[key] = material
|
||
logger.debug(f"添加材质: key={key}")
|
||
|
||
# ==================== 选择管理 ====================
|
||
|
||
def sel_clear(self):
|
||
"""清除所有选择 - 对应Ruby的sel_clear方法"""
|
||
with self.lock:
|
||
self.selected_uid = None
|
||
self.selected_obj = None
|
||
self.selected_zone = None
|
||
self.selected_part = None
|
||
self.selected_faces.clear()
|
||
self.selected_parts.clear()
|
||
self.selected_hws.clear()
|
||
logger.debug("清除所有选择")
|
||
|
||
def set_selected(self, uid: str, obj: Any, zone: Any = None, part: Any = None):
|
||
"""设置选择状态"""
|
||
with self.lock:
|
||
self.selected_uid = uid
|
||
self.selected_obj = obj
|
||
if zone:
|
||
self.selected_zone = zone
|
||
if part:
|
||
self.selected_part = part
|
||
logger.debug(f"设置选择: uid={uid}, obj={obj}")
|
||
|
||
# ==================== 删除实体的核心实现 ====================
|
||
|
||
def del_entities_by_type(self, entities: Dict[str, Any], typ: str, oid: int) -> int:
|
||
"""按类型删除实体 - 修复版本，确保删除所有相关对象"""
|
||
if not entities:
|
||
return 0
|
||
|
||
deleted_count = 0
|
||
entities_to_delete = []
|
||
|
||
# 【修复1】收集数据结构中需要删除的实体
|
||
for key, entity in entities.items():
|
||
if entity and self._is_entity_valid(entity):
|
||
# 对应Ruby逻辑: typ == "uid" || entity.get_attribute("sw", typ) == oid
|
||
if typ == "uid" or self._get_entity_attribute(entity, typ) == oid:
|
||
entities_to_delete.append(key)
|
||
|
||
# 【修复2】删除数据结构中的实体
|
||
for key in entities_to_delete:
|
||
entity = entities[key]
|
||
if self._delete_entity_safe(entity):
|
||
del entities[key]
|
||
deleted_count += 1
|
||
|
||
# 【修复3】遍历Blender中的所有对象，查找并删除相关对象
|
||
if BLENDER_AVAILABLE:
|
||
blender_deleted_count = self._delete_blender_objects_by_type(
|
||
typ, oid)
|
||
deleted_count += blender_deleted_count
|
||
logger.debug(
|
||
f"从Blender中删除对象: typ={typ}, oid={oid}, 删除数量={blender_deleted_count}")
|
||
|
||
logger.debug(f"按类型删除实体: typ={typ}, oid={oid}, 总删除数量={deleted_count}")
|
||
return deleted_count
|
||
|
||
def _matches_delete_condition(self, entity, typ: str, oid: int, uid: str = None) -> bool:
|
||
"""检查实体是否匹配删除条件 - 添加详细调试"""
|
||
try:
|
||
if not entity or not hasattr(entity, 'get'):
|
||
return False
|
||
|
||
# 【调试】打印实体的所有属性
|
||
entity_uid = entity.get("sw_uid")
|
||
entity_typ_value = entity.get(f"sw_{typ}")
|
||
|
||
logger.debug(
|
||
f"🔍 检查删除条件: {entity.name if hasattr(entity, 'name') else 'unknown'}")
|
||
logger.debug(
|
||
f" 实体属性: sw_uid={entity_uid}, sw_{typ}={entity_typ_value}")
|
||
logger.debug(f" 删除条件: uid={uid}, typ={typ}, oid={oid}")
|
||
|
||
# 【修复】正确的删除条件逻辑
|
||
if typ == "uid":
|
||
# 删除整个单元：检查sw_uid
|
||
uid_matches = entity_uid == oid
|
||
logger.debug(f" uid删除匹配: {uid_matches}")
|
||
return uid_matches
|
||
else:
|
||
# 删除特定类型：需要同时匹配uid和对应的类型属性
|
||
uid_matches = uid is None or entity_uid == uid
|
||
typ_matches = entity_typ_value == oid
|
||
|
||
logger.debug(
|
||
f" 类型删除匹配: uid匹配={uid_matches}, {typ}匹配={typ_matches}")
|
||
|
||
# 必须同时匹配uid和类型值
|
||
return uid_matches and typ_matches
|
||
|
||
except Exception as e:
|
||
logger.error(f"检查删除条件时发生错误: {e}")
|
||
return False
|
||
|
||
def _delete_blender_objects_by_type(self, typ: str, oid: int, uid: str = None) -> int:
|
||
"""从Blender中删除指定类型的对象 - 添加详细调试"""
|
||
deleted_count = 0
|
||
|
||
try:
|
||
logger.info(f" 开始搜索Blender对象: typ={typ}, oid={oid}, uid={uid}")
|
||
|
||
# 遍历所有Blender对象
|
||
objects_to_delete = []
|
||
checked_objects = []
|
||
|
||
for obj in bpy.data.objects:
|
||
checked_objects.append(obj.name)
|
||
if self._should_delete_blender_object(obj, typ, oid, uid):
|
||
objects_to_delete.append(obj)
|
||
logger.info(f"🎯 标记删除: {obj.name}")
|
||
|
||
logger.info(
|
||
f"📊 检查了 {len(checked_objects)} 个对象，标记删除 {len(objects_to_delete)} 个")
|
||
|
||
# 删除收集到的对象
|
||
for obj in objects_to_delete:
|
||
try:
|
||
logger.info(
|
||
f"️ 删除Blender对象: {obj.name}, typ={typ}, oid={oid}, uid={uid}")
|
||
bpy.data.objects.remove(obj, do_unlink=True)
|
||
deleted_count += 1
|
||
except Exception as e:
|
||
logger.error(f"删除Blender对象失败: {obj.name}, 错误: {e}")
|
||
|
||
# 清理孤立的网格数据
|
||
self._cleanup_orphaned_meshes()
|
||
|
||
except Exception as e:
|
||
logger.error(f"删除Blender对象时发生错误: {e}")
|
||
|
||
return deleted_count
|
||
|
||
def _should_delete_blender_object(self, obj, typ: str, oid: int, uid: str = None) -> bool:
|
||
"""判断是否应该删除Blender对象 - 添加详细调试"""
|
||
try:
|
||
if not obj or not hasattr(obj, 'get'):
|
||
return False
|
||
|
||
# 【调试】打印对象的所有sw_属性
|
||
sw_attrs = {}
|
||
for key, value in obj.items():
|
||
if key.startswith('sw_'):
|
||
sw_attrs[key] = value
|
||
|
||
logger.debug(f"🔍 检查对象 {obj.name} 的sw_属性: {sw_attrs}")
|
||
|
||
# 使用相同的删除条件逻辑
|
||
should_delete = self._matches_delete_condition(obj, typ, oid, uid)
|
||
|
||
if should_delete:
|
||
logger.info(f"✅ 对象 {obj.name} 匹配删除条件")
|
||
else:
|
||
logger.debug(f"❌ 对象 {obj.name} 不匹配删除条件")
|
||
|
||
return should_delete
|
||
|
||
except Exception as e:
|
||
logger.error(f"检查Blender对象删除条件时发生错误: {e}")
|
||
return False
|
||
|
||
def _cleanup_orphaned_meshes(self):
|
||
"""清理孤立的网格数据"""
|
||
try:
|
||
# 清理没有对象的网格
|
||
for mesh in bpy.data.meshes:
|
||
if mesh.users == 0:
|
||
bpy.data.meshes.remove(mesh)
|
||
logger.debug(f"清理孤立网格: {mesh.name}")
|
||
|
||
# 清理没有对象的材质
|
||
for material in bpy.data.materials:
|
||
if material.users == 0:
|
||
bpy.data.materials.remove(material)
|
||
logger.debug(f"清理孤立材质: {material.name}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"清理孤立数据时发生错误: {e}")
|
||
|
||
def _get_entity_attribute(self, entity, attr_name: str):
|
||
"""获取实体属性 - 改进版本"""
|
||
try:
|
||
if BLENDER_AVAILABLE and hasattr(entity, 'get'):
|
||
# 【修复7】检查多种可能的属性名
|
||
possible_attrs = [
|
||
f"sw_{attr_name}",
|
||
attr_name,
|
||
f"sw{attr_name}"
|
||
]
|
||
|
||
for attr in possible_attrs:
|
||
value = entity.get(attr)
|
||
if value is not None:
|
||
return value
|
||
|
||
return None
|
||
except:
|
||
return None
|
||
|
||
def _delete_entity_safe(self, entity) -> bool:
|
||
"""安全删除实体 - 改进版本"""
|
||
try:
|
||
if not entity or not BLENDER_AVAILABLE:
|
||
return False
|
||
|
||
# 【修复8】更全面的对象检查
|
||
if hasattr(entity, 'name'):
|
||
# 检查是否在Blender对象中
|
||
if entity.name in bpy.data.objects:
|
||
bpy.data.objects.remove(entity, do_unlink=True)
|
||
return True
|
||
# 检查是否在网格中
|
||
elif entity.name in bpy.data.meshes:
|
||
bpy.data.meshes.remove(entity, do_unlink=True)
|
||
return True
|
||
# 检查是否在材质中
|
||
elif entity.name in bpy.data.materials:
|
||
bpy.data.materials.remove(entity, do_unlink=True)
|
||
return True
|
||
|
||
return False
|
||
except Exception as e:
|
||
logger.error(f"删除实体失败: {e}")
|
||
return False
|
||
|
||
def _is_entity_valid(self, entity) -> bool:
|
||
"""检查实体是否有效"""
|
||
try:
|
||
if entity is None:
|
||
return False
|
||
|
||
# 检查是否是 Blender 对象
|
||
if hasattr(entity, 'name'):
|
||
# 检查对象是否已被删除
|
||
if hasattr(entity, 'is_valid'):
|
||
return entity.is_valid
|
||
elif hasattr(entity, 'users'):
|
||
return entity.users > 0
|
||
else:
|
||
return True
|
||
|
||
# 检查是否是字典或其他类型
|
||
return entity is not None
|
||
|
||
except Exception:
|
||
return False
|
||
|
||
# ==================== 统计和管理方法 ====================
|
||
|
||
def get_data_stats(self) -> Dict[str, Any]:
|
||
"""获取数据统计信息"""
|
||
with self.lock:
|
||
return {
|
||
"total_units": len(set(list(self.zones.keys()) + list(self.parts.keys()) + list(self.hardwares.keys()))),
|
||
"zones": {
|
||
"units": len(self.zones),
|
||
"total_zones": sum(len(zones) for zones in self.zones.values())
|
||
},
|
||
"parts": {
|
||
"units": len(self.parts),
|
||
"total_parts": sum(len(parts) for parts in self.parts.values())
|
||
},
|
||
"hardwares": {
|
||
"units": len(self.hardwares),
|
||
"total_hardwares": sum(len(hws) for hws in self.hardwares.values())
|
||
},
|
||
"machinings": {
|
||
"units": len(self.machinings),
|
||
"total_machinings": sum(len(machs) for machs in self.machinings.values())
|
||
},
|
||
"dimensions": {
|
||
"units": len(self.dimensions),
|
||
"total_dimensions": sum(len(dims) for dims in self.dimensions.values())
|
||
},
|
||
"textures": len(self.textures),
|
||
"selected_objects": {
|
||
"uid": self.selected_uid,
|
||
"obj": self.selected_obj,
|
||
"faces": len(self.selected_faces),
|
||
"parts": len(self.selected_parts),
|
||
"hardwares": len(self.selected_hws)
|
||
},
|
||
"system_state": {
|
||
"part_mode": self.part_mode,
|
||
"hide_none": self.hide_none,
|
||
"mat_type": self.mat_type,
|
||
"back_material": self.back_material,
|
||
"added_contour": self.added_contour
|
||
}
|
||
}
|
||
|
||
def cleanup_all(self):
|
||
"""清理所有数据"""
|
||
with self.lock:
|
||
self.zones.clear()
|
||
self.parts.clear()
|
||
self.hardwares.clear()
|
||
self.labels.clear()
|
||
self.door_labels.clear()
|
||
self.machinings.clear()
|
||
self.dimensions.clear()
|
||
self.textures.clear()
|
||
self.unit_params.clear()
|
||
self.unit_trans.clear()
|
||
self.sel_clear()
|
||
logger.info("✅ 数据管理器清理完成")
|
||
|
||
# ==================== 全局数据管理器实例 ====================
|
||
|
||
|
||
# 全局数据管理器实例
|
||
data_manager: Optional[DataManager] = None
|
||
|
||
|
||
def init_data_manager() -> DataManager:
|
||
"""初始化全局数据管理器实例"""
|
||
global data_manager
|
||
if data_manager is None:
|
||
data_manager = DataManager()
|
||
return data_manager
|
||
|
||
|
||
def get_data_manager() -> DataManager:
|
||
"""获取全局数据管理器实例"""
|
||
global data_manager
|
||
if data_manager is None:
|
||
data_manager = init_data_manager()
|
||
return data_manager
|
||
|
||
|
||
# 自动初始化
|
||
data_manager = init_data_manager()
|
||
|
||
# ==================== 兼容性函数 ====================
|
||
|
||
|
||
def get_zones(data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""兼容性函数 - 获取zones"""
|
||
return data_manager.get_zones(data)
|
||
|
||
|
||
def get_parts(data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""兼容性函数 - 获取parts"""
|
||
return data_manager.get_parts(data)
|
||
|
||
|
||
def get_hardwares(data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""兼容性函数 - 获取hardwares"""
|
||
return data_manager.get_hardwares(data)
|
||
|
||
|
||
def get_texture(key: str) -> Any:
|
||
"""兼容性函数 - 获取材质"""
|
||
return data_manager.get_texture(key)
|
||
|
||
|
||
def sel_clear():
|
||
"""兼容性函数 - 清除选择"""
|
||
return data_manager.sel_clear()
|
||
|
||
|
||
# ==================== 兼容性函数 ====================
|
||
|
||
|
||
def get_zones(data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""兼容性函数 - 获取zones"""
|
||
return data_manager.get_zones(data)
|
||
|
||
|
||
def get_parts(data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""兼容性函数 - 获取parts"""
|
||
return data_manager.get_parts(data)
|
||
|
||
|
||
def get_hardwares(data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""兼容性函数 - 获取hardwares"""
|
||
return data_manager.get_hardwares(data)
|
||
|
||
|
||
def get_texture(key: str) -> Any:
|
||
"""兼容性函数 - 获取材质"""
|
||
return data_manager.get_texture(key)
|
||
|
||
|
||
def sel_clear():
|
||
"""兼容性函数 - 清除选择"""
|
||
return data_manager.sel_clear()
|