""" 地形渲染器 负责渲染程序化生成的地形 """ import numpy as np import math from typing import Dict, Any, List, Tuple class TerrainRenderer: """ 地形渲染器 负责渲染程序化生成的地形，包括网格生成、纹理映射、光照计算等 """ def __init__(self, plugin): """ 初始化地形渲染器 Args: plugin: 程序化地形生成插件实例 """ self.plugin = plugin self.enabled = False self.initialized = False # 渲染配置 self.render_params = { 'resolution': plugin.config.get('terrain_size', 512), 'lod_levels': plugin.config.get('lod_levels', 5), 'chunk_size': plugin.config.get('chunk_size', 32), 'max_distance': 1000.0, 'lod_distance_factor': 2.0 } # 光照参数 self.lighting_params = { 'ambient_light': 0.3, 'diffuse_light': 0.7, 'specular_light': 0.2, 'light_direction': [0.5, 0.5, 0.5], 'light_color': [1.0, 1.0, 1.0] } # 材质参数 self.material_params = { 'diffuse_texture': True, 'normal_mapping': True, 'specular_mapping': False, 'texture_scale': 1.0, 'tessellation_factor': 1.0 } # 着色器参数 self.shader_params = { 'vertex_shader': 'terrain_vertex.glsl', 'fragment_shader': 'terrain_fragment.glsl', 'geometry_shader': None, 'tessellation_control_shader': None, 'tessellation_evaluation_shader': None } # 渲染状态 self.render_buffers = {} self.vertex_arrays = {} self.textures = {} self.shaders = {} # LOD管理 self.lod_chunks = {} self.visible_chunks = set() # 统计信息 self.stats = { 'chunks_rendered': 0, 'vertices_rendered': 0, 'triangles_rendered': 0, 'render_time': 0.0, 'average_render_time': 0.0, 'lod_switches': 0 } print("✓ 地形渲染器已创建") def initialize(self) -> bool: """ 初始化地形渲染器 Returns: 是否初始化成功 """ try: # 初始化渲染资源（在实际实现中会初始化GPU资源） self._initialize_render_resources() self.initialized = True print("✓ 地形渲染器初始化完成") return True except Exception as e: print(f"✗ 地形渲染器初始化失败: {e}") import traceback traceback.print_exc() return False def enable(self) -> bool: """ 启用地形渲染器 Returns: 是否启用成功 """ try: if not self.initialized: print("✗ 地形渲染器未初始化") return False self.enabled = True print("✓ 地形渲染器已启用") return True except Exception as e: print(f"✗ 地形渲染器启用失败: {e}") import traceback traceback.print_exc() return False def disable(self): """禁用地形渲染器""" try: self.enabled = False print("✓ 地形渲染器已禁用") except Exception as e: print(f"✗ 地形渲染器禁用失败: {e}") import traceback traceback.print_exc() def finalize(self): """清理地形渲染器资源""" try: self.disable() # 清理渲染资源 self._cleanup_render_resources() self.initialized = False print("✓ 地形渲染器资源已清理") except Exception as e: print(f"✗ 地形渲染器资源清理失败: {e}") import traceback traceback.print_exc() def update(self, dt: float): """ 更新地形渲染器状态 Args: dt: 时间增量 """ try: if not self.enabled: return # 更新LOD self._update_lod() # 更新可见区块 self._update_visible_chunks() except Exception as e: print(f"✗ 地形渲染器更新失败: {e}") import traceback traceback.print_exc() def _initialize_render_resources(self): """初始化渲染资源""" try: # 在实际实现中，这里会初始化GPU缓冲区、纹理、着色器等 print(" → 初始化渲染缓冲区...") print(" → 初始化着色器...") print(" → 初始化纹理...") # 模拟创建一些基本的渲染资源 self.render_buffers['terrain_vertices'] = [] self.render_buffers['terrain_indices'] = [] self.vertex_arrays['terrain_vao'] = [] self.textures['terrain_diffuse'] = [] self.textures['terrain_normal'] = [] self.shaders['terrain_shader'] = [] except Exception as e: print(f"✗ 渲染资源初始化失败: {e}") def _cleanup_render_resources(self): """清理渲染资源""" try: # 在实际实现中，这里会清理GPU资源 self.render_buffers.clear() self.vertex_arrays.clear() self.textures.clear() self.shaders.clear() self.lod_chunks.clear() self.visible_chunks.clear() except Exception as e: print(f"✗ 渲染资源清理失败: {e}") def render_terrain(self, camera_position: List[float], view_matrix: np.ndarray, projection_matrix: np.ndarray) -> bool: """ 渲染地形 Args: camera_position: 摄像机位置 view_matrix: 视图矩阵 projection_matrix: 投影矩阵 Returns: 是否渲染成功 """ try: if not self.enabled: print("✗ 地形渲染器未启用") return False import time render_start_time = time.time() print("✓ 开始渲染地形...") # 更新摄像机相关数据 self._update_camera_data(camera_position, view_matrix, projection_matrix) # 准备渲染数据 self._prepare_render_data() # 执行渲染 self._execute_rendering() # 更新统计信息 render_time = time.time() - render_start_time self.stats['render_time'] = render_time self.stats['chunks_rendered'] += len(self.visible_chunks) if self.stats['chunks_rendered'] > 0: self.stats['average_render_time'] = ( self.stats['average_render_time'] * (self.stats['chunks_rendered'] - 1) + render_time ) / self.stats['chunks_rendered'] print(f"✓ 地形渲染完成，耗时: {render_time:.3f}秒") return True except Exception as e: print(f"✗ 地形渲染失败: {e}") import traceback traceback.print_exc() return False def _update_camera_data(self, camera_position: List[float], view_matrix: np.ndarray, projection_matrix: np.ndarray): """更新摄像机相关数据""" try: # 在实际实现中，这里会更新着色器中的摄像机参数 pass except Exception as e: print(f"✗ 摄像机数据更新失败: {e}") def _prepare_render_data(self): """准备渲染数据""" try: # 在实际实现中，这里会准备顶点缓冲区、索引缓冲区等 pass except Exception as e: print(f"✗ 渲染数据准备失败: {e}") def _execute_rendering(self): """执行渲染""" try: # 在实际实现中，这里会调用GPU渲染命令 print(" → 绑定着色器程序...") print(" → 设置光照参数...") print(" → 绑定纹理...") print(" → 渲染可见区块...") # 模拟渲染过程 for chunk_key in self.visible_chunks: print(f" → 渲染区块 {chunk_key}") except Exception as e: print(f"✗ 渲染执行失败: {e}") def _update_lod(self): """更新LOD级别""" try: # 在实际实现中，这里会根据摄像机距离更新每个区块的LOD级别 pass except Exception as e: print(f"✗ LOD更新失败: {e}") def _update_visible_chunks(self): """更新可见区块""" try: # 在实际实现中，这里会根据视锥体剔除确定可见区块 if self.plugin.terrain_manager: terrain_data = self.plugin.terrain_manager.get_terrain_data() if terrain_data.get('is_generating', False): # 如果地形正在生成，暂时不更新可见区块 return # 获取可见区块列表 visible_chunk_keys = self.plugin.terrain_manager.get_visible_chunks() self.visible_chunks = set(visible_chunk_keys) except Exception as e: print(f"✗ 可见区块更新失败: {e}") def set_render_parameters(self, params: Dict[str, Any]): """ 设置渲染参数 Args: params: 渲染参数字典 """ self.render_params.update(params) print(f"✓ 渲染参数已更新: {self.render_params}") def set_lighting_parameters(self, params: Dict[str, Any]): """ 设置光照参数 Args: params: 光照参数字典 """ self.lighting_params.update(params) print(f"✓ 光照参数已更新: {self.lighting_params}") def set_material_parameters(self, params: Dict[str, Any]): """ 设置材质参数 Args: params: 材质参数字典 """ self.material_params.update(params) print(f"✓ 材质参数已更新: {self.material_params}") def set_shader_parameters(self, params: Dict[str, Any]): """ 设置着色器参数 Args: params: 着色器参数字典 """ self.shader_params.update(params) print(f"✓ 着色器参数已更新: {self.shader_params}") def get_stats(self) -> Dict[str, Any]: """ 获取统计信息 Returns: 统计信息字典 """ return self.stats.copy() def reset_stats(self): """重置统计信息""" self.stats = { 'chunks_rendered': 0, 'vertices_rendered': 0, 'triangles_rendered': 0, 'render_time': 0.0, 'average_render_time': 0.0, 'lod_switches': 0 } print("✓ 地形渲染器统计信息已重置") def generate_terrain_mesh(self, heightmap: np.ndarray, resolution: int = None) -> Dict[str, np.ndarray]: """ 生成地形网格 Args: heightmap: 高度图数据 resolution: 网格分辨率 Returns: 包含顶点、法线、纹理坐标和索引的字典 """ try: if resolution is None: resolution = self.render_params['resolution'] print(f"✓ 开始生成 {resolution}x{resolution} 地形网格...") # 创建网格数据 vertices = [] normals = [] texcoords = [] indices = [] # 生成顶点数据 height, width = heightmap.shape scale_x = 1.0 / (width - 1) scale_y = 1.0 / (height - 1) # 生成顶点 for y in range(height): for x in range(width): # 顶点位置 vertex_x = (x / (width - 1)) * 2.0 - 1.0 # -1 到 1 vertex_y = heightmap[y, x] # 高度值 vertex_z = (y / (height - 1)) * 2.0 - 1.0 # -1 到 1 vertices.extend([vertex_x, vertex_y, vertex_z]) # 纹理坐标 texcoord_u = x / (width - 1) texcoord_v = 1.0 - y / (height - 1) # 翻转V坐标 texcoords.extend([texcoord_u, texcoord_v]) # 计算法线 normals = self._calculate_normals(heightmap) # 生成索引（三角形列表） for y in range(height - 1): for x in range(width - 1): # 第一个三角形 indices.append(y * width + x) indices.append(y * width + x + 1) indices.append((y + 1) * width + x) # 第二个三角形 indices.append((y + 1) * width + x) indices.append(y * width + x + 1) indices.append((y + 1) * width + x + 1) # 转换为numpy数组 vertices_array = np.array(vertices, dtype=np.float32) normals_array = np.array(normals, dtype=np.float32) texcoords_array = np.array(texcoords, dtype=np.float32) indices_array = np.array(indices, dtype=np.uint32) # 更新统计信息 self.stats['vertices_rendered'] = len(vertices) // 3 self.stats['triangles_rendered'] = len(indices) // 3 print(f"✓ 地形网格生成完成: {len(vertices)//3} 顶点, {len(indices)//3} 三角形") return { 'vertices': vertices_array, 'normals': normals_array, 'texcoords': texcoords_array, 'indices': indices_array } except Exception as e: print(f"✗ 地形网格生成失败: {e}") import traceback traceback.print_exc() return { 'vertices': np.array([], dtype=np.float32), 'normals': np.array([], dtype=np.float32), 'texcoords': np.array([], dtype=np.float32), 'indices': np.array([], dtype=np.uint32) } def _calculate_normals(self, heightmap: np.ndarray) -> List[float]: """ 计算法线 Args: heightmap: 高度图数据 Returns: 法线数据列表 """ try: height, width = heightmap.shape normals = [] for y in range(height): for x in range(width): # 计算相邻点的高度 h_left = heightmap[y, max(0, x-1)] h_right = heightmap[y, min(width-1, x+1)] h_up = heightmap[max(0, y-1), x] h_down = heightmap[min(height-1, y+1), x] # 计算梯度 dx = (h_right - h_left) * width / 2.0 dy = (h_down - h_up) * height / 2.0 dz = 2.0 # 计算法线 normal = [-dx, -dy, dz] norm = math.sqrt(normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]) if norm > 0: normal = [n/norm for n in normal] else: normal = [0.0, 0.0, 1.0] normals.extend(normal) return normals except Exception as e: print(f"✗ 法线计算失败: {e}") # 返回默认法线 height, width = heightmap.shape return [0.0, 0.0, 1.0] * height * width def generate_terrain_texture(self, heightmap: np.ndarray, biome_map: np.ndarray = None, moisture_map: np.ndarray = None, temperature_map: np.ndarray = None) -> np.ndarray: """ 生成地形纹理 Args: heightmap: 高度图数据 biome_map: 生物群落图数据（可选） moisture_map: 湿度图数据（可选） temperature_map: 温度图数据（可选） Returns: 纹理数据 (RGBA格式) """ try: height, width = heightmap.shape print(f"✓ 开始生成 {width}x{height} 地形纹理...") # 创建RGBA纹理数据 texture_data = np.zeros((height, width, 4), dtype=np.uint8) # 如果有生物群落数据，基于生物群落生成纹理 if biome_map is not None and biome_map.shape == heightmap.shape: texture_data = self._generate_biome_based_texture(biome_map) else: # 基于高度生成基础纹理 texture_data = self._generate_height_based_texture(heightmap) # 如果有湿度和温度数据，添加细节 if moisture_map is not None and moisture_map.shape == heightmap.shape: texture_data = self._apply_moisture_effects(texture_data, moisture_map) if temperature_map is not None and temperature_map.shape == heightmap.shape: texture_data = self._apply_temperature_effects(texture_data, temperature_map) print("✓ 地形纹理生成完成") return texture_data except Exception as e: print(f"✗ 地形纹理生成失败: {e}") import traceback traceback.print_exc() # 返回默认纹理（蓝色） height, width = heightmap.shape return np.zeros((height, width, 4), dtype=np.uint8) def _generate_biome_based_texture(self, biome_map: np.ndarray) -> np.ndarray: """ 基于生物群落生成纹理 Args: biome_map: 生物群落图数据 Returns: 纹理数据 """ try: height, width = biome_map.shape texture_data = np.zeros((height, width, 4), dtype=np.uint8) # 生物群落颜色映射 biome_colors = { 0: [0, 0, 128, 255], # ocean - 深蓝色 1: [255, 255, 0, 255], # beach - 黄色 2: [144, 238, 144, 255], # plains - 浅绿色 3: [34, 139, 34, 255], # forest - 绿色 4: [0, 100, 0, 255], # jungle - 深绿色 5: [255, 165, 0, 255], # desert - 橙色 6: [139, 137, 137, 255], # mountain - 灰色 7: [255, 255, 255, 255], # snow - 白色 8: [0, 128, 128, 255], # taiga - 青色 9: [173, 216, 230, 255], # tundra - 淡蓝色 10: [128, 128, 0, 255], # swamp - 橄榄色 11: [255, 215, 0, 255] # savanna - 金色 } # 为每个像素分配颜色 for y in range(height): for x in range(width): biome_id = biome_map[y, x] color = biome_colors.get(biome_id, [128, 128, 128, 255]) # 默认灰色 texture_data[y, x] = color return texture_data except Exception as e: print(f"✗ 生物群落纹理生成失败: {e}") height, width = biome_map.shape return np.zeros((height, width, 4), dtype=np.uint8) def _generate_height_based_texture(self, heightmap: np.ndarray) -> np.ndarray: """ 基于高度生成纹理 Args: heightmap: 高度图数据 Returns: 纹理数据 """ try: height, width = heightmap.shape texture_data = np.zeros((height, width, 4), dtype=np.uint8) # 为每个像素根据高度分配颜色 for y in range(height): for x in range(width): height_value = heightmap[y, x] # 根据高度选择颜色 if height_value < 0.2: # 水域 - 蓝色 r, g, b = 0, 0, int(128 + height_value * 127) elif height_value < 0.3: # 浅水/海滩 - 浅蓝色 r, g, b = int(height_value * 255), int(height_value * 255), 255 elif height_value < 0.5: # 平原 - 绿色 r, g, b = 0, int(100 + height_value * 155), 0 elif height_value < 0.7: # 丘陵 - 棕色 r, g, b = int(139 * height_value), int(69 * height_value), int(19 * height_value) elif height_value < 0.9: # 山地 - 灰色 r, g, b = int(100 + height_value * 155), int(100 + height_value * 155), int(100 + height_value * 155) else: # 雪山 - 白色 r, g, b = 255, 255, 255 texture_data[y, x] = [r, g, b, 255] return texture_data except Exception as e: print(f"✗ 高度纹理生成失败: {e}") height, width = heightmap.shape return np.zeros((height, width, 4), dtype=np.uint8) def _apply_moisture_effects(self, texture_data: np.ndarray, moisture_map: np.ndarray) -> np.ndarray: """ 应用湿度效果到纹理 Args: texture_data: 原始纹理数据 moisture_map: 湿度图数据 Returns: 处理后的纹理数据 """ try: processed_texture = texture_data.copy() height, width = moisture_map.shape # 根据湿度调整颜色 for y in range(height): for x in range(width): moisture_value = moisture_map[y, x] # 增加蓝色调表示湿润 if moisture_value > 0.6: processed_texture[y, x, 2] = min(255, processed_texture[y, x, 2] + int(50 * moisture_value)) # 减少红色和绿色通道表示湿润 if moisture_value > 0.5: processed_texture[y, x, 0] = max(0, processed_texture[y, x, 0] - int(30 * moisture_value)) processed_texture[y, x, 1] = max(0, processed_texture[y, x, 1] - int(30 * moisture_value)) return processed_texture except Exception as e: print(f"✗ 湿度效果应用失败: {e}") return texture_data def _apply_temperature_effects(self, texture_data: np.ndarray, temperature_map: np.ndarray) -> np.ndarray: """ 应用温度效果到纹理 Args: texture_data: 原始纹理数据 temperature_map: 温度图数据 Returns: 处理后的纹理数据 """ try: processed_texture = texture_data.copy() height, width = temperature_map.shape # 根据温度调整颜色 for y in range(height): for x in range(width): temperature_value = temperature_map[y, x] # 增加热色调表示温暖 if temperature_value > 0.7: processed_texture[y, x, 0] = min(255, processed_texture[y, x, 0] + int(50 * (temperature_value - 0.7) / 0.3)) # 增加冷色调表示寒冷 if temperature_value < 0.3: processed_texture[y, x, 2] = min(255, processed_texture[y, x, 2] + int(50 * (0.3 - temperature_value) / 0.3)) return processed_texture except Exception as e: print(f"✗ 温度效果应用失败: {e}") return texture_data def generate_normal_map(self, heightmap: np.ndarray, strength: float = 1.0) -> np.ndarray: """ 生成法线贴图 Args: heightmap: 高度图数据 strength: 法线强度 Returns: 法线贴图数据 (RGB格式) """ try: height, width = heightmap.shape print(f"✓ 开始生成 {width}x{height} 法线贴图...") # 创建法线贴图数据 normal_map = np.zeros((height, width, 3), dtype=np.uint8) # 计算每个像素的法线 for y in range(height): for x in range(width): # 计算相邻点的高度 h_left = heightmap[y, max(0, x-1)] h_right = heightmap[y, min(width-1, x+1)] h_up = heightmap[max(0, y-1), x] h_down = heightmap[min(height-1, y+1), x] # 计算梯度 dx = (h_right - h_left) * strength dy = (h_down - h_up) * strength # 计算法线 (转换到0-1范围再转为0-255) normal_x = (dx + 1.0) * 0.5 normal_y = (dy + 1.0) * 0.5 normal_z = 1.0 # 假设主要朝向摄像机 normal_z = normal_z / math.sqrt(normal_x*normal_x + normal_y*normal_y + normal_z*normal_z) normal_z = (normal_z + 1.0) * 0.5 # 转换为8位值 normal_map[y, x] = [ int(normal_x * 255), int(normal_y * 255), int(normal_z * 255) ] print("✓ 法线贴图生成完成") return normal_map except Exception as e: print(f"✗ 法线贴图生成失败: {e}") import traceback traceback.print_exc() # 返回默认法线贴图（正面法线） height, width = heightmap.shape return np.full((height, width, 3), [128, 128, 255], dtype=np.uint8) def generate_splat_map(self, biome_map: np.ndarray, num_textures: int = 4) -> np.ndarray: """ 生成混合贴图（用于多重纹理混合） Args: biome_map: 生物群落图数据 num_textures: 纹理数量 Returns: 混合贴图数据 (RGBA格式，每个通道代表一种纹理的权重) """ try: height, width = biome_map.shape print(f"✓ 开始生成 {width}x{height} 混合贴图...") # 创建混合贴图数据 splat_map = np.zeros((height, width, 4), dtype=np.uint8) # 简化的混合贴图生成 # 在实际实现中，这里会根据生物群落类型和地形特征生成更复杂的混合 for y in range(height): for x in range(width): biome_id = biome_map[y, x] # 根据生物群落ID分配到不同的纹理通道 channel = biome_id % 4 splat_map[y, x, channel] = 255 print("✓ 混合贴图生成完成") return splat_map except Exception as e: print(f"✗ 混合贴图生成失败: {e}") import traceback traceback.print_exc() # 返回默认混合贴图 height, width = biome_map.shape return np.zeros((height, width, 4), dtype=np.uint8) def update_chunk_mesh(self, chunk_x: int, chunk_y: int, lod_level: int, heightmap: np.ndarray) -> bool: """ 更新区块网格 Args: chunk_x: 区块X坐标 chunk_y: 区块Y坐标 lod_level: LOD级别 heightmap: 高度图数据 Returns: 是否更新成功 """ try: chunk_key = f"{chunk_x},{chunk_y},{lod_level}" # 生成区块网格数据 mesh_data = self.generate_terrain_mesh(heightmap) # 存储到LOD区块中 if chunk_key not in self.lod_chunks: self.lod_chunks[chunk_key] = {} self.lod_chunks[chunk_key]['mesh_data'] = mesh_data self.lod_chunks[chunk_key]['last_update'] = time.time() print(f"✓ 区块 [{chunk_x}, {chunk_y}] LOD {lod_level} 网格已更新") return True except Exception as e: print(f"✗ 区块网格更新失败: {e}") import traceback traceback.print_exc() return False def get_chunk_mesh(self, chunk_x: int, chunk_y: int, lod_level: int) -> Dict[str, np.ndarray]: """ 获取区块网格数据 Args: chunk_x: 区块X坐标 chunk_y: 区块Y坐标 lod_level: LOD级别 Returns: 网格数据字典 """ try: chunk_key = f"{chunk_x},{chunk_y},{lod_level}" if chunk_key in self.lod_chunks: return self.lod_chunks[chunk_key].get('mesh_data', {}) else: return {} except Exception as e: print(f"✗ 区块网格获取失败: {e}") return {} def set_lod_distances(self, distances: List[float]): """ 设置LOD距离 Args: distances: LOD距离列表 """ self.render_params['lod_distances'] = distances print(f"✓ LOD距离已设置: {distances}") def get_lod_level(self, distance: float) -> int: """ 根据距离确定LOD级别 Args: distance: 距离 Returns: LOD级别 """ try: lod_distances = self.render_params.get('lod_distances', []) if not lod_distances: # 使用默认距离计算 base_distance = 100.0 for i in range(self.render_params['lod_levels']): if distance < base_distance * (i + 1): return i return self.render_params['lod_levels'] - 1 else: # 使用自定义距离 for i, lod_distance in enumerate(lod_distances): if distance < lod_distance: return i return len(lod_distances) - 1 except Exception as e: print(f"✗ LOD级别计算失败: {e}") return 0 def frustum_cull(self, camera_position: List[float], view_matrix: np.ndarray, projection_matrix: np.ndarray) -> List[Tuple[int, int]]: """ 视锥体剔除 Args: camera_position: 摄像机位置 view_matrix: 视图矩阵 projection_matrix: 投影矩阵 Returns: 可见区块列表 [(chunk_x, chunk_y), ...] """ try: # 在实际实现中，这里会进行复杂的视锥体剔除计算 # 简化实现：返回所有区块 visible_chunks = [] if self.plugin.terrain_manager: terrain_data = self.plugin.terrain_manager.get_terrain_data() terrain_size = terrain_data.get('stats', {}).get('chunks_generated', 0) if terrain_size > 0: # 模拟一些可见区块 for i in range(min(10, terrain_size)): visible_chunks.append((i, i)) return visible_chunks except Exception as e: print(f"✗ 视锥体剔除失败: {e}") return [] def occlusion_cull(self, visible_chunks: List[Tuple[int, int]]) -> List[Tuple[int, int]]: """ 遮挡剔除 Args: visible_chunks: 可见区块列表 Returns: 未被遮挡的区块列表 """ try: # 在实际实现中，这里会进行遮挡剔除计算 # 简化实现：返回所有可见区块 return visible_chunks except Exception as e: print(f"✗ 遮挡剔除失败: {e}") return visible_chunks def generate_terrain_materials(self, biome_map: np.ndarray) -> Dict[str, Any]: """ 生成地形材质 Args: biome_map: 生物群落图数据 Returns: 材质数据字典 """ try: print("✓ 开始生成地形材质...") # 在实际实现中，这里会生成多种材质纹理和属性 materials = { 'diffuse_textures': [], 'normal_textures': [], 'specular_textures': [], 'biome_mapping': {} } # 为每种生物群落生成材质ID unique_biomes = np.unique(biome_map) for biome_id in unique_biomes: materials['biome_mapping'][biome_id] = f"material_{biome_id}" print("✓ 地形材质生成完成") return materials except Exception as e: print(f"✗ 地形材质生成失败: {e}") import traceback traceback.print_exc() return {} def apply_tessellation(self, vertices: np.ndarray, tessellation_factor: float) -> np.ndarray: """ 应用细分曲面 Args: vertices: 顶点数据 tessellation_factor: 细分因子 Returns: 细分后的顶点数据 """ try: # 在实际实现中，这里会使用GPU细分着色器 # 简化实现：返回原始顶点 print(f"✓ 应用细分曲面 (因子: {tessellation_factor})") return vertices except Exception as e: print(f"✗ 细分曲面应用失败: {e}") return vertices def apply_displacement_mapping(self, heightmap: np.ndarray, displacement_factor: float) -> np.ndarray: """ 应用置换贴图 Args: heightmap: 高度图数据 displacement_factor: 置换因子 Returns: 置换后的顶点数据 """ try: # 在实际实现中，这里会在细分着色器中应用置换贴图 # 简化实现：返回处理后的高度图 displaced_heightmap = heightmap * displacement_factor print(f"✓ 应用置换贴图 (因子: {displacement_factor})") return displaced_heightmap except Exception as e: print(f"✗ 置换贴图应用失败: {e}") return heightmap def calculate_shadow_map(self, light_direction: List[float], heightmap: np.ndarray) -> np.ndarray: """ 计算阴影贴图 Args: light_direction: 光照方向 heightmap: 高度图数据 Returns: 阴影贴图数据 """ try: height, width = heightmap.shape print(f"✓ 开始计算 {width}x{height} 阴影贴图...") # 创建阴影贴图数据 shadow_map = np.ones((height, width), dtype=np.float32) # 简化的阴影计算 light_x, light_y, light_z = light_direction # 根据光照方向计算阴影 for y in range(height): for x in range(width): # 简单的高度遮挡计算 current_height = heightmap[y, x] shadow_factor = 1.0 # 检查在光照方向上是否有更高的地形遮挡 step_x = int(light_x * 10) step_y = int(light_y * 10) check_x = x + step_x check_y = y + step_y if 0 <= check_x < width and 0 <= check_y < height: check_height = heightmap[check_y, check_x] if check_height > current_height: shadow_factor = 0.5 # 简单的半阴影 shadow_map[y, x] = shadow_factor print("✓ 阴影贴图计算完成") return shadow_map except Exception as e: print(f"✗ 阴影贴图计算失败: {e}") import traceback traceback.print_exc() # 返回默认阴影贴图（无阴影） height, width = heightmap.shape return np.ones((height, width), dtype=np.float32) def apply_atmospheric_effects(self, color_data: np.ndarray, camera_position: List[float], sun_direction: List[float]) -> np.ndarray: """ 应用大气效果 Args: color_data: 颜色数据 camera_position: 摄像机位置 sun_direction: 太阳方向 Returns: 处理后的颜色数据 """ try: processed_colors = color_data.copy() height, width = processed_colors.shape[:2] print("✓ 应用大气效果...") # 简化的雾效和光照计算 fog_density = 0.01 sun_r, sun_g, sun_b = sun_direction for y in range(height): for x in range(width): # 计算到摄像机的距离（简化） distance = math.sqrt((x - camera_position[0])**2 + (y - camera_position[1])**2) # 应用雾效 fog_factor = math.exp(-distance * fog_density) fog_factor = max(0.0, min(1.0, fog_factor)) # 混合雾颜色（白色） processed_colors[y, x, 0] = int(processed_colors[y, x, 0] * fog_factor + 255 * (1 - fog_factor)) processed_colors[y, x, 1] = int(processed_colors[y, x, 1] * fog_factor + 255 * (1 - fog_factor)) processed_colors[y, x, 2] = int(processed_colors[y, x, 2] * fog_factor + 255 * (1 - fog_factor)) print("✓ 大气效果应用完成") return processed_colors except Exception as e: print(f"✗ 大气效果应用失败: {e}") return color_data def optimize_rendering(self, target_fps: float = 60.0): """ 优化渲染性能 Args: target_fps: 目标帧率 """ try: print(f"✓ 开始优化渲染性能 (目标FPS: {target_fps})") # 根据目标FPS调整渲染参数 current_fps = 1.0 / max(0.001, self.stats['average_render_time']) if current_fps < target_fps * 0.8: # 如果FPS低于目标的80% # 降低渲染质量以提高性能 self.render_params['lod_levels'] = max(1, self.render_params['lod_levels'] - 1) self.render_params['chunk_size'] = min(64, self.render_params['chunk_size'] * 2) print(" → 降低LOD级别和增加区块大小以提高性能") elif current_fps > target_fps * 1.2: # 如果FPS高于目标的120% # 提高渲染质量 self.render_params['lod_levels'] = min(10, self.render_params['lod_levels'] + 1) self.render_params['chunk_size'] = max(8, self.render_params['chunk_size'] // 2) print(" → 提高LOD级别和减小区块大小以提高质量") print("✓ 渲染性能优化完成") except Exception as e: print(f"✗ 渲染性能优化失败: {e}") def export_render_settings(self, filename: str) -> bool: """ 导出渲染设置 Args: filename: 文件名 Returns: 是否导出成功 """ try: import json settings = { 'render_params': self.render_params, 'lighting_params': self.lighting_params, 'material_params': self.material_params, 'shader_params': self.shader_params, 'timestamp': time.time() } with open(filename, 'w', encoding='utf-8') as f: json.dump(settings, f, ensure_ascii=False, indent=2) print(f"✓ 渲染设置已导出到: {filename}") return True except Exception as e: print(f"✗ 渲染设置导出失败: {e}") return False def import_render_settings(self, filename: str) -> bool: """ 导入渲染设置 Args: filename: 文件名 Returns: 是否导入成功 """ try: import json with open(filename, 'r', encoding='utf-8') as f: settings = json.load(f) # 更新参数 if 'render_params' in settings: self.render_params.update(settings['render_params']) if 'lighting_params' in settings: self.lighting_params.update(settings['lighting_params']) if 'material_params' in settings: self.material_params.update(settings['material_params']) if 'shader_params' in settings: self.shader_params.update(settings['shader_params']) print(f"✓ 渲染设置已从 {filename} 导入") return True except Exception as e: print(f"✗ 渲染设置导入失败: {e}") return False def get_render_capabilities(self) -> Dict[str, Any]: """ 获取渲染能力信息 Returns: 渲染能力信息字典 """ return { 'max_texture_size': 8192, 'max_lod_levels': 10, 'supported_shaders': ['vertex', 'fragment', 'geometry', 'tessellation'], 'supports_normal_mapping': True, 'supports_displacement_mapping': True, 'supports_tessellation': True, 'supports_shadow_mapping': True, 'max_anisotropy': 16.0 } def set_render_quality(self, quality_level: str): """ 设置渲染质量级别 Args: quality_level: 质量级别 ('low', 'medium', 'high', 'ultra') """ quality_settings = { 'low': { 'lod_levels': 2, 'chunk_size': 64, 'normal_mapping': False, 'tessellation_factor': 0.5 }, 'medium': { 'lod_levels': 4, 'chunk_size': 32, 'normal_mapping': True, 'tessellation_factor': 1.0 }, 'high': { 'lod_levels': 6, 'chunk_size': 16, 'normal_mapping': True, 'tessellation_factor': 2.0 }, 'ultra': { 'lod_levels': 8, 'chunk_size': 8, 'normal_mapping': True, 'tessellation_factor': 4.0 } } if quality_level in quality_settings: settings = quality_settings[quality_level] self.render_params['lod_levels'] = settings['lod_levels'] self.render_params['chunk_size'] = settings['chunk_size'] self.material_params['normal_mapping'] = settings['normal_mapping'] self.material_params['tessellation_factor'] = settings['tessellation_factor'] print(f"✓ 渲染质量已设置为: {quality_level}") else: print(f"✗ 无效的质量级别: {quality_level}")