""" 地形植被系统 提供完整的植被分布、生长模拟、LOD控制、生态模拟等功能 """ from panda3d.core import NodePath, Vec3, Point3, BitMask32 from panda3d.core import Texture, TextureStage, Material import random import math import json import os import numpy as np class VegetationSystem: """ 地形植被系统类 提供完整的植被分布、生长模拟、LOD控制、生态模拟等功能 """ def __init__(self, world): self.world = world self.vegetation_instances = [] # 存储植被实例 self.vegetation_types = {} # 存储植被类型定义 self.density_maps = {} # 存储密度图 self.lod_settings = {} # 存储LOD设置 self.ecosystem = {} # 存储生态系统信息 self.growth_simulator = None # 生长模拟器 self.wind_effect = { # 风力效果参数 'strength': 0.5, 'direction': Vec3(1, 0, 0), 'speed': 1.0, 'turbulence': 0.2 } def define_vegetation_type(self, name, model_path, scale_range=(1.0, 1.0), rotation_range=(0, 360), color_variation=(0.8, 1.2), growth_params=None, ecosystem_role='general'): """ 定义植被类型 growth_params: 生长参数字典 ecosystem_role: 生态角色 ('tree', 'shrub', 'grass', 'flower', 'general') """ self.vegetation_types[name] = { 'model_path': model_path, 'scale_range': scale_range, 'rotation_range': rotation_range, 'color_variation': color_variation, 'instances': [], 'growth_params': growth_params or { 'max_height': 10.0, 'growth_rate': 0.1, 'lifespan': 100.0, 'seed_production': 0.5, 'water_requirement': 0.5, 'sunlight_requirement': 0.7 }, 'ecosystem_role': ecosystem_role, 'seasonal_variations': { 'spring': {'color_shift': (0.1, 0.2, 0.0), 'scale_factor': 1.1}, 'summer': {'color_shift': (0.0, 0.0, 0.0), 'scale_factor': 1.0}, 'autumn': {'color_shift': (0.3, 0.2, 0.0), 'scale_factor': 0.9}, 'winter': {'color_shift': (0.1, 0.1, 0.1), 'scale_factor': 0.8} } } print(f"定义植被类型: {name} (生态角色: {ecosystem_role})") def load_vegetation_models(self): """ 预加载所有植被模型 """ for name, veg_type in self.vegetation_types.items(): try: model = self.world.loader.loadModel(veg_type['model_path']) if model: veg_type['model'] = model print(f"加载植被模型: {name}") else: print(f"无法加载植被模型: {name}") except Exception as e: print(f"加载植被模型 {name} 时出错: {e}") def generate_vegetation(self, terrain_info, vegetation_config, density=0.1, distribution_method='random'): """ 在地形上生成植被 vegetation_config: 植被配置字典，指定不同类型植被的分布参数 distribution_method: 分布方法 ('random', 'clustered', 'ecosystem') """ try: terrain_node = terrain_info['node'] heightfield = terrain_info['heightfield'] if not heightfield: print("无法获取地形高度图数据") return False width = heightfield.getXSize() height = heightfield.getYSize() # 获取地形节点信息 terrain_pos = terrain_node.getPos() terrain_scale = terrain_node.getScale() # 根据分布方法选择生成策略 if distribution_method == 'ecosystem': return self._generate_ecosystem_vegetation(terrain_info, vegetation_config, density) elif distribution_method == 'clustered': return self._generate_clustered_vegetation(terrain_info, vegetation_config, density) else: return self._generate_random_vegetation(terrain_info, vegetation_config, density) except Exception as e: print(f"生成植被时出错: {e}") return False def _generate_random_vegetation(self, terrain_info, vegetation_config, density): """ 随机生成植被 """ try: terrain_node = terrain_info['node'] heightfield = terrain_info['heightfield'] width = heightfield.getXSize() height = heightfield.getYSize() terrain_pos = terrain_node.getPos() terrain_scale = terrain_node.getScale() # 为每种植被类型生成实例 total_instances = 0 for veg_type_name, veg_params in vegetation_config.items(): if veg_type_name not in self.vegetation_types: print(f"未定义的植被类型: {veg_type_name}") continue veg_type = self.vegetation_types[veg_type_name] # 获取环境限制条件 min_height = veg_params.get('min_height', 0.0) max_height = veg_params.get('max_height', 1.0) slope_threshold = veg_params.get('slope_threshold', 45.0) moisture_preference = veg_params.get('moisture_preference', 0.5) # 计算植被数量 total_points = int(width * height * density * veg_params.get('density_factor', 1.0)) # 生成植被实例 instances_created = 0 attempts = 0 max_attempts = total_points * 10 # 防止无限循环 while instances_created < total_points and attempts < max_attempts: attempts += 1 # 随机选择位置 x = random.randint(0, width - 1) y = random.randint(0, height - 1) # 获取高度值 height_value = heightfield.getRed(x, y) # 检查高度限制 if height_value < min_height or height_value > max_height: continue # 检查坡度 if self._calculate_slope(heightfield, x, y) > slope_threshold: continue # 检查湿度条件（简化模拟） moisture = self._calculate_moisture(heightfield, x, y) if abs(moisture - moisture_preference) > 0.3: continue # 计算世界坐标 center_offset = (width - 1) / 2 world_x = (x - center_offset) * terrain_scale.getX() + terrain_pos.getX() world_y = (y - center_offset) * terrain_scale.getY() + terrain_pos.getY() world_z = height_value * terrain_scale.getZ() + terrain_pos.getZ() # 创建植被实例 if self._create_vegetation_instance(veg_type_name, Point3(world_x, world_y, world_z)): instances_created += 1 total_instances += instances_created print(f"植被类型 {veg_type_name} 生成了 {instances_created} 个实例") print(f"随机生成植被完成，共创建 {total_instances} 个实例") return True except Exception as e: print(f"随机生成植被时出错: {e}") return False def _generate_clustered_vegetation(self, terrain_info, vegetation_config, density): """ 簇状生成植被 """ try: terrain_node = terrain_info['node'] heightfield = terrain_info['heightfield'] width = heightfield.getXSize() height = heightfield.getYSize() terrain_pos = terrain_node.getPos() terrain_scale = terrain_node.getScale() # 为每种植被类型生成簇 total_instances = 0 for veg_type_name, veg_params in vegetation_config.items(): if veg_type_name not in self.vegetation_types: continue # 计算簇的数量 cluster_count = int((width * height * density * veg_params.get('density_factor', 1.0)) / 10) for _ in range(cluster_count): # 随机选择簇中心 center_x = random.randint(0, width - 1) center_y = random.randint(0, height - 1) center_height = heightfield.getRed(center_x, center_y) # 确定簇大小 cluster_size = random.randint(3, 10) # 在簇内生成植被 for _ in range(cluster_size): # 在簇中心附近随机分布 offset_x = random.randint(-5, 5) offset_y = random.randint(-5, 5) x = max(0, min(width - 1, center_x + offset_x)) y = max(0, min(height - 1, center_y + offset_y)) # 计算世界坐标 center_offset = (width - 1) / 2 world_x = (x - center_offset) * terrain_scale.getX() + terrain_pos.getX() world_y = (y - center_offset) * terrain_scale.getY() + terrain_pos.getY() world_z = heightfield.getRed(x, y) * terrain_scale.getZ() + terrain_pos.getZ() # 创建植被实例 if self._create_vegetation_instance(veg_type_name, Point3(world_x, world_y, world_z)): total_instances += 1 print(f"簇状生成植被完成，共创建 {total_instances} 个实例") return True except Exception as e: print(f"簇状生成植被时出错: {e}") return False def _generate_ecosystem_vegetation(self, terrain_info, vegetation_config, density): """ 生态系统方式生成植被 """ try: terrain_node = terrain_info['node'] heightfield = terrain_info['heightfield'] width = heightfield.getXSize() height = heightfield.getYSize() terrain_pos = terrain_node.getPos() terrain_scale = terrain_node.getScale() # 创建生态位地图 niche_map = self._create_niche_map(heightfield) # 为每种植被类型根据生态位生成 total_instances = 0 for veg_type_name, veg_params in vegetation_config.items(): if veg_type_name not in self.vegetation_types: continue veg_type = self.vegetation_types[veg_type_name] ecosystem_role = veg_type['ecosystem_role'] # 根据生态角色确定分布偏好 if ecosystem_role == 'tree': preferred_niches = ['high_ground', 'flat_area'] elif ecosystem_role == 'shrub': preferred_niches = ['slope', 'transition'] elif ecosystem_role == 'grass': preferred_niches = ['flat_area', 'low_ground'] else: preferred_niches = ['any'] # 计算植被数量 total_points = int(width * height * density * veg_params.get('density_factor', 1.0)) # 根据生态位偏好生成植被 instances_created = 0 attempts = 0 max_attempts = total_points * 20 while instances_created < total_points and attempts < max_attempts: attempts += 1 # 根据生态位偏好选择位置 x, y = self._select_ecosystem_position(niche_map, preferred_niches) if x is None or y is None: continue # 检查环境条件 height_value = heightfield.getRed(x, y) slope = self._calculate_slope(heightfield, x, y) # 根据植被类型检查条件 if not self._check_environment_conditions(veg_type_name, height_value, slope): continue # 计算世界坐标 center_offset = (width - 1) / 2 world_x = (x - center_offset) * terrain_scale.getX() + terrain_pos.getX() world_y = (y - center_offset) * terrain_scale.getY() + terrain_pos.getY() world_z = height_value * terrain_scale.getZ() + terrain_pos.getZ() # 创建植被实例 if self._create_vegetation_instance(veg_type_name, Point3(world_x, world_y, world_z)): instances_created += 1 total_instances += instances_created print(f"生态系统生成植被类型 {veg_type_name}: {instances_created} 个实例") print(f"生态系统生成植被完成，共创建 {total_instances} 个实例") return True except Exception as e: print(f"生态系统生成植被时出错: {e}") return False def _create_niche_map(self, heightfield): """ 创建生态位地图 """ try: width = heightfield.getXSize() height = heightfield.getYSize() niche_map = {} for x in range(width): for y in range(height): # 分析位置特征 slope = self._calculate_slope(heightfield, x, y) height_value = heightfield.getRed(x, y) # 确定生态位 if slope > 30: niche = 'steep_slope' elif slope > 15: niche = 'slope' elif height_value > 0.7: niche = 'high_ground' elif height_value < 0.3: niche = 'low_ground' else: niche = 'flat_area' # 检查是否为过渡区域 if self._is_transition_zone(heightfield, x, y): niche = 'transition' niche_map[(x, y)] = niche return niche_map except Exception as e: print(f"创建生态位地图时出错: {e}") return {} def _is_transition_zone(self, heightfield, x, y): """ 检查是否为过渡区域 """ try: width = heightfield.getXSize() height = heightfield.getYSize() if x < 2 or x >= width - 2 or y < 2 or y >= height - 2: return False # 计算周围点的高度差异 center_height = heightfield.getRed(x, y) height_diff = 0 for dx in [-1, 0, 1]: for dy in [-1, 0, 1]: if dx == 0 and dy == 0: continue neighbor_height = heightfield.getRed(x + dx, y + dy) height_diff += abs(neighbor_height - center_height) # 如果高度差异较大，则为过渡区域 return height_diff > 0.1 except: return False def _select_ecosystem_position(self, niche_map, preferred_niches): """ 根据生态位偏好选择位置 """ try: if not niche_map: return None, None # 如果偏好'any'，随机选择 if 'any' in preferred_niches: positions = list(niche_map.keys()) if positions: return random.choice(positions) return None, None # 根据偏好选择 preferred_positions = [] for pos, niche in niche_map.items(): if niche in preferred_niches: preferred_positions.append(pos) if preferred_positions: return random.choice(preferred_positions) # 如果没有偏好位置，随机选择 positions = list(niche_map.keys()) if positions: return random.choice(positions) return None, None except: return None, None def _check_environment_conditions(self, veg_type_name, height_value, slope): """ 检查环境条件是否适合植被生长 """ try: if veg_type_name not in self.vegetation_types: return True veg_type = self.vegetation_types[veg_type_name] growth_params = veg_type['growth_params'] # 检查高度限制 max_height = growth_params.get('max_height', 100.0) if height_value * 100 > max_height: # 假设高度值0-1对应0-100米 return False # 检查坡度限制 max_slope = growth_params.get('max_slope', 45.0) if slope > max_slope: return False return True except: return True def _calculate_slope(self, heightfield, x, y): """ 计算指定点的坡度 """ try: width = heightfield.getXSize() height = heightfield.getYSize() # 获取周围点的高度 heights = [] for dx in [-1, 0, 1]: for dy in [-1, 0, 1]: nx, ny = x + dx, y + dy if 0 <= nx < width and 0 <= ny < height: heights.append(heightfield.getRed(nx, ny)) else: heights.append(heightfield.getRed(x, y)) # 计算X和Y方向的梯度 dx = heights[2] - heights[0] # 右侧点 - 左侧点 dy = heights[6] - heights[0] # 下方点 - 上方点 # 计算坡度（角度） slope = math.degrees(math.atan(math.sqrt(dx*dx + dy*dy))) return slope except: return 0.0 def _calculate_moisture(self, heightfield, x, y): """ 计算指定点的湿度（简化模拟） """ try: # 简化的湿度计算：低洼地区湿度较高 width = heightfield.getXSize() height = heightfield.getYSize() # 计算周围点的平均高度 total_height = 0 count = 0 for dx in [-2, -1, 0, 1, 2]: for dy in [-2, -1, 0, 1, 2]: nx, ny = x + dx, y + dy if 0 <= nx < width and 0 <= ny < height: total_height += heightfield.getRed(nx, ny) count += 1 if count > 0: avg_height = total_height / count current_height = heightfield.getRed(x, y) # 低洼地区湿度较高 moisture = max(0.0, min(1.0, 0.5 + (avg_height - current_height) * 2)) return moisture return 0.5 except: return 0.5 def _create_vegetation_instance(self, veg_type_name, position): """ 创建植被实例 """ try: if veg_type_name not in self.vegetation_types: return None veg_type = self.vegetation_types[veg_type_name] # 检查模型是否已加载 if 'model' not in veg_type: # 尝试加载模型 try: model = self.world.loader.loadModel(veg_type['model_path']) if model: veg_type['model'] = model else: print(f"无法加载植被模型: {veg_type['model_path']}") return None except Exception as e: print(f"加载植被模型时出错: {e}") return None # 克隆模型创建实例 instance = veg_type['model'].copyTo(self.world.render) instance.setPos(position) # 应用随机缩放 scale_min, scale_max = veg_type['scale_range'] scale = random.uniform(scale_min, scale_max) instance.setScale(scale) # 应用随机旋转 rot_min, rot_max = veg_type['rotation_range'] rotation = random.uniform(rot_min, rot_max) instance.setH(rotation) # 应用颜色变化 color_min, color_max = veg_type['color_variation'] color_factor = random.uniform(color_min, color_max) # 应用季节性颜色变化 season_color = self._get_seasonal_color(veg_type_name) if season_color: # 这里可以应用颜色变化到模型材质 pass # 设置标签 instance.setTag("vegetation_type", veg_type_name) instance.setTag("is_scene_element", "1") instance.setTag("tree_item_type", "VEGETATION_NODE") instance.setTag("creation_time", str(self.world.globalClock.getFrameTime())) # 添加碰撞体 instance.setCollideMask(BitMask32.bit(3)) # 使用第3位作为植被碰撞掩码 # 初始化生长状态 creation_time = self.world.globalClock.getFrameTime() # 保存实例信息 instance_info = { 'node': instance, 'type': veg_type_name, 'position': position, 'scale': scale, 'rotation': rotation, 'creation_time': creation_time, 'age': 0.0, 'health': 1.0, 'growth_stage': 0, # 0=seedling, 1=sapling, 2=mature, 3=elderly 'last_update': creation_time, 'wind_offset': Vec3(0, 0, 0) } self.vegetation_instances.append(instance_info) veg_type['instances'].append(instance_info) return instance_info except Exception as e: print(f"创建植被实例时出错: {e}") return None def _get_seasonal_color(self, veg_type_name): """ 获取季节性颜色变化 """ try: if veg_type_name in self.vegetation_types: veg_type = self.vegetation_types[veg_type_name] # 这里可以根据当前季节返回相应的颜色变化 # 简化实现，返回默认值 return veg_type['seasonal_variations'].get('summer', {'color_shift': (0, 0, 0)}) return None except: return None def remove_vegetation_instance(self, instance_info): """ 移除植被实例 """ try: if instance_info in self.vegetation_instances: # 从全局列表中移除 self.vegetation_instances.remove(instance_info) # 从类型列表中移除 veg_type_name = instance_info['type'] if veg_type_name in self.vegetation_types: if instance_info in self.vegetation_types[veg_type_name]['instances']: self.vegetation_types[veg_type_name]['instances'].remove(instance_info) # 移除节点 if instance_info['node'] and not instance_info['node'].isEmpty(): instance_info['node'].removeNode() print("移除植被实例") return True except Exception as e: print(f"移除植被实例时出错: {e}") return False def clear_all_vegetation(self): """ 清除所有植被 """ try: # 移除所有实例节点 for instance_info in self.vegetation_instances: if instance_info['node'] and not instance_info['node'].isEmpty(): instance_info['node'].removeNode() # 清空数据结构 self.vegetation_instances = [] # 清空各类型实例列表 for veg_type in self.vegetation_types.values(): veg_type['instances'] = [] print("清除所有植被") return True except Exception as e: print(f"清除所有植被时出错: {e}") return False def set_vegetation_lod(self, lod_settings): """ 设置植被LOD lod_settings: LOD设置字典，包含距离阈值和简化策略 """ self.lod_settings = lod_settings print("设置植被LOD") def update_vegetation_lod(self, camera_pos): """ 更新植被LOD """ try: for instance_info in self.vegetation_instances: node = instance_info['node'] if node and not node.isEmpty(): # 计算到相机的距离 distance = (node.getPos() - camera_pos).length() # 根据距离应用LOD策略 if distance > self.lod_settings.get('far_distance', 100): # 远距离时隐藏 node.hide() elif distance > self.lod_settings.get('medium_distance', 50): # 中距离时显示简化版本 node.show() self._apply_medium_lod(node) else: # 近距离时显示完整版本 node.show() self._apply_full_lod(node) except Exception as e: print(f"更新植被LOD时出错: {e}") def _apply_medium_lod(self, node): """ 应用中距离LOD """ try: # 减少多边形数量的简化版本 # 这里可以实现模型简化或使用公告板 # 简化实现：使用缩放来模拟简化效果 original_scale = node.getScale() node.setScale(original_scale * 0.8) except: pass def _apply_full_lod(self, node): """ 应用完整LOD """ # 恢复完整细节 pass def simulate_growth(self, time_step=1.0): """ 模拟植被生长 """ try: current_time = self.world.globalClock.getFrameTime() for instance_info in self.vegetation_instances: node = instance_info['node'] if node and not node.isEmpty(): # 获取植被类型信息 veg_type_name = instance_info['type'] if veg_type_name not in self.vegetation_types: continue veg_type = self.vegetation_types[veg_type_name] growth_params = veg_type['growth_params'] # 计算生长时间 elapsed_time = current_time - instance_info['last_update'] instance_info['last_update'] = current_time # 更新年龄 instance_info['age'] += elapsed_time # 计算生长率（受健康状况影响） growth_rate = growth_params.get('growth_rate', 0.1) * instance_info['health'] # 生长模拟 if instance_info['growth_stage'] == 0: # seedling # 幼苗阶段：快速增长 new_scale = node.getScale() * (1.0 + growth_rate * elapsed_time * 0.1) node.setScale(new_scale) # 检查是否进入下一阶段 if instance_info['age'] > 5.0: # 5秒后进入sapling阶段 instance_info['growth_stage'] = 1 elif instance_info['growth_stage'] == 1: # sapling # 树苗阶段：中等速度增长 new_scale = node.getScale() * (1.0 + growth_rate * elapsed_time * 0.05) node.setScale(new_scale) # 检查是否进入下一阶段 if instance_info['age'] > 20.0: # 20秒后进入mature阶段 instance_info['growth_stage'] = 2 elif instance_info['growth_stage'] == 2: # mature # 成熟阶段：缓慢增长 new_scale = node.getScale() * (1.0 + growth_rate * elapsed_time * 0.01) node.setScale(new_scale) # 检查是否进入下一阶段 lifespan = growth_params.get('lifespan', 100.0) if instance_info['age'] > lifespan * 0.8: # 80%寿命后进入elderly阶段 instance_info['growth_stage'] = 3 elif instance_info['growth_stage'] == 3: # elderly # 老年阶段：可能开始衰退 if random.random() < 0.001: # 小概率开始衰退 instance_info['health'] -= 0.01 * elapsed_time if instance_info['health'] < 0: instance_info['health'] = 0 # 缩放可能减小 health_factor = max(0.5, instance_info['health']) new_scale = node.getScale() * (1.0 - (1.0 - health_factor) * 0.001 * elapsed_time) node.setScale(new_scale) # 更新实例信息 instance_info['scale'] = node.getScale() except Exception as e: print(f"模拟植被生长时出错: {e}") def apply_wind_effect(self, wind_strength=None, wind_direction=None, wind_speed=None): """ 应用风力效果 """ try: # 更新风力参数 if wind_strength is not None: self.wind_effect['strength'] = wind_strength if wind_direction is not None: self.wind_effect['direction'] = wind_direction if wind_speed is not None: self.wind_effect['speed'] = wind_speed current_time = self.world.globalClock.getFrameTime() for instance_info in self.vegetation_instances: node = instance_info['node'] if node and not node.isEmpty(): # 计算风力影响 time_factor = current_time * self.wind_effect['speed'] # 添加湍流效果 turbulence = math.sin(time_factor * 3) * self.wind_effect['turbulence'] # 计算摆动量 sway_amount = math.sin(time_factor) * self.wind_effect['strength'] * 10 sway_amount += turbulence * 5 # 根据植被类型调整摆动（大树摆动较小，小草摆动较大） veg_type_name = instance_info['type'] if veg_type_name in self.vegetation_types: veg_type = self.vegetation_types[veg_type_name] scale_factor = node.getScale().length() # 简化的大尺度因子 sway_amount *= max(0.1, 1.0 / scale_factor) # 大树摆动小 # 应用摆动效果 original_rotation = instance_info['rotation'] new_h = original_rotation + sway_amount node.setH(new_h) # 添加轻微的位置偏移 sway_offset = Vec3( math.cos(time_factor * 2) * self.wind_effect['strength'] * 0.1, math.sin(time_factor * 2) * self.wind_effect['strength'] * 0.1, 0 ) instance_info['wind_offset'] = sway_offset except Exception as e: print(f"应用风力效果时出错: {e}") def simulate_ecosystem_interactions(self, time_step=1.0): """ 模拟生态系统相互作用 """ try: # 模拟植物间的竞争、繁殖、死亡等生态过程 current_time = self.world.globalClock.getFrameTime() # 检查植物健康状况 for instance_info in self.vegetation_instances[:]: # 使用切片复制避免修改列表时的问题 node = instance_info['node'] if not node or node.isEmpty(): continue # 检查年龄相关死亡 veg_type_name = instance_info['type'] if veg_type_name in self.vegetation_types: veg_type = self.vegetation_types[veg_type_name] lifespan = veg_type['growth_params'].get('lifespan', 100.0) if instance_info['age'] > lifespan: # 植物死亡 if random.random() < 0.01: # 每帧1%概率死亡 print(f"植物死亡: {veg_type_name}") self.remove_vegetation_instance(instance_info) continue # 检查健康状况 if instance_info['health'] <= 0: print(f"植物因健康状况不佳死亡: {veg_type_name}") self.remove_vegetation_instance(instance_info) continue # 模拟繁殖（简化） if instance_info['growth_stage'] >= 2: # 成熟植物才能繁殖 growth_params = veg_type['growth_params'] seed_production = growth_params.get('seed_production', 0.5) if random.random() < seed_production * 0.001: # 繁殖概率 self._attempt_reproduction(instance_info) except Exception as e: print(f"模拟生态系统相互作用时出错: {e}") def _attempt_reproduction(self, parent_instance): """ 尝试繁殖 """ try: # 在父植物附近生成新植物 parent_pos = parent_instance['position'] # 随机生成在附近位置 offset_range = 5.0 # 5米范围内 new_x = parent_pos.getX() + random.uniform(-offset_range, offset_range) new_y = parent_pos.getY() + random.uniform(-offset_range, offset_range) new_z = parent_pos.getZ() # 高度保持一致 # 创建新植物实例 veg_type_name = parent_instance['type'] self._create_vegetation_instance(veg_type_name, Point3(new_x, new_y, new_z)) except Exception as e: print(f"尝试繁殖时出错: {e}") def save_vegetation_data(self, terrain_info, output_path): """ 保存植被数据 """ try: # 收集植被数据 vegetation_data = { 'vegetation_types': {}, 'instances': [], 'ecosystem_settings': { 'wind_effect': self.wind_effect } } # 保存植被类型定义 for name, veg_type in self.vegetation_types.items(): vegetation_data['vegetation_types'][name] = { 'model_path': veg_type['model_path'], 'scale_range': veg_type['scale_range'], 'rotation_range': veg_type['rotation_range'], 'color_variation': veg_type['color_variation'], 'growth_params': veg_type['growth_params'], 'ecosystem_role': veg_type['ecosystem_role'] } # 保存实例信息 for instance_info in self.vegetation_instances: instance_data = { 'type': instance_info['type'], 'position': [instance_info['position'].x, instance_info['position'].y, instance_info['position'].z], 'scale': [instance_info['scale'].x, instance_info['scale'].y, instance_info['scale'].z], 'rotation': instance_info['rotation'], 'age': instance_info['age'], 'health': instance_info['health'], 'growth_stage': instance_info['growth_stage'], 'creation_time': instance_info['creation_time'] } vegetation_data['instances'].append(instance_data) # 确保输出目录存在 output_dir = os.path.dirname(output_path) if not os.path.exists(output_dir): os.makedirs(output_dir) # 写入JSON文件 with open(output_path, 'w', encoding='utf-8') as f: json.dump(vegetation_data, f, indent=2, ensure_ascii=False) print(f"植被数据保存成功: {output_path}") return True except Exception as e: print(f"保存植被数据时出错: {e}") return False def load_vegetation_data(self, terrain_info, input_path): """ 加载植被数据 """ try: if not os.path.exists(input_path): print(f"植被数据文件不存在: {input_path}") return False # 读取JSON文件 with open(input_path, 'r', encoding='utf-8') as f: vegetation_data = json.load(f) # 清除现有植被 self.clear_all_vegetation() # 加载植被类型定义 if 'vegetation_types' in vegetation_data: for name, veg_def in vegetation_data['vegetation_types'].items(): self.define_vegetation_type( name=name, model_path=veg_def['model_path'], scale_range=veg_def.get('scale_range', (1.0, 1.0)), rotation_range=veg_def.get('rotation_range', (0, 360)), color_variation=veg_def.get('color_variation', (0.8, 1.2)), growth_params=veg_def.get('growth_params'), ecosystem_role=veg_def.get('ecosystem_role', 'general') ) # 加载实例 if 'instances' in vegetation_data: for instance_data in vegetation_data['instances']: position = Point3(instance_data['position'][0], instance_data['position'][1], instance_data['position'][2]) # 创建实例 instance_info = self._create_vegetation_instance(instance_data['type'], position) if instance_info: # 恢复实例状态 if 'scale' in instance_data: scale_vec = instance_data['scale'] if len(scale_vec) == 3: instance_info['node'].setScale(scale_vec[0], scale_vec[1], scale_vec[2]) else: instance_info['node'].setScale(scale_vec[0]) if 'age' in instance_data: instance_info['age'] = instance_data['age'] if 'health' in instance_data: instance_info['health'] = instance_data['health'] if 'growth_stage' in instance_data: instance_info['growth_stage'] = instance_data['growth_stage'] if 'creation_time' in instance_data: instance_info['creation_time'] = instance_data['creation_time'] # 恢复生态系统设置 if 'ecosystem_settings' in vegetation_data: eco_settings = vegetation_data['ecosystem_settings'] if 'wind_effect' in eco_settings: self.wind_effect = eco_settings['wind_effect'] print(f"植被数据加载成功: {input_path}") return True except Exception as e: print(f"加载植被数据时出错: {e}") return False def get_vegetation_stats(self): """ 获取植被统计信息 """ stats = { 'total_instances': len(self.vegetation_instances), 'vegetation_types': {}, 'ecosystem_stats': { 'wind_strength': self.wind_effect['strength'], 'wind_speed': self.wind_effect['speed'] }, 'growth_stages': { 'seedling': 0, 'sapling': 0, 'mature': 0, 'elderly': 0 } } # 统计植被类型 for name, veg_type in self.vegetation_types.items(): stats['vegetation_types'][name] = { 'count': len(veg_type['instances']), 'model_path': veg_type['model_path'], 'ecosystem_role': veg_type['ecosystem_role'] } # 统计生长阶段 for instance_info in self.vegetation_instances: stage = instance_info['growth_stage'] if stage == 0: stats['growth_stages']['seedling'] += 1 elif stage == 1: stats['growth_stages']['sapling'] += 1 elif stage == 2: stats['growth_stages']['mature'] += 1 elif stage == 3: stats['growth_stages']['elderly'] += 1 return stats def paint_vegetation(self, terrain_info, brush_position, brush_radius, vegetation_type, density=1.0): """ 绘制植被（笔刷工具） """ try: terrain_node = terrain_info['node'] heightfield = terrain_info['heightfield'] if not heightfield: print("无法获取地形高度图数据") return False width = heightfield.getXSize() height = heightfield.getYSize() # 获取地形节点信息 terrain_pos = terrain_node.getPos() terrain_scale = terrain_node.getScale() # 计算笔刷区域 center_offset = (width - 1) / 2 brush_x = int((brush_position.getX() - terrain_pos.getX()) / terrain_scale.getX() + center_offset) brush_y = int((brush_position.getY() - terrain_pos.getY()) / terrain_scale.getY() + center_offset) brush_pixels = int(brush_radius / max(terrain_scale.getX(), terrain_scale.getY())) # 在笔刷区域内生成植被 instances_created = 0 for dx in range(-brush_pixels, brush_pixels + 1): for dy in range(-brush_pixels, brush_pixels + 1): # 检查是否在笔刷范围内 distance = math.sqrt(dx*dx + dy*dy) if distance <= brush_pixels: # 计算实际位置 x = brush_x + dx y = brush_y + dy # 检查边界 if 0 <= x < width and 0 <= y < height: # 根据密度决定是否创建 if random.random() < density: # 计算世界坐标 world_x = (x - center_offset) * terrain_scale.getX() + terrain_pos.getX() world_y = (y - center_offset) * terrain_scale.getY() + terrain_pos.getY() world_z = heightfield.getRed(x, y) * terrain_scale.getZ() + terrain_pos.getZ() # 创建植被实例 if self._create_vegetation_instance(vegetation_type, Point3(world_x, world_y, world_z)): instances_created += 1 print(f"绘制植被完成，创建了 {instances_created} 个实例") return True except Exception as e: print(f"绘制植被时出错: {e}") return False def update_all_systems(self, time_delta): """ 更新所有植被系统 """ try: # 更新生长模拟 self.simulate_growth(time_delta) # 更新风力效果 self.apply_wind_effect() # 更新生态系统相互作用 self.simulate_ecosystem_interactions(time_delta) # 更新LOD（如果已设置相机位置） # 这里需要从外部传入相机位置 # self.update_vegetation_lod(camera_pos) except Exception as e: print(f"更新植被系统时出错: {e}")