1558 lines
62 KiB
Python
1558 lines
62 KiB
Python
"""
|
||
地形天气和环境系统
|
||
提供完整的天气模拟、环境效果、光照控制、动态天空等功能
|
||
"""
|
||
|
||
from panda3d.core import NodePath, Vec3, Point3, Vec4, LVector3f
|
||
from panda3d.core import AmbientLight, DirectionalLight, PointLight, Spotlight
|
||
from panda3d.core import Fog, Shader, ShaderAttrib, PerspectiveLens
|
||
from panda3d.core import Texture, TextureStage, CardMaker
|
||
from panda3d.core import PNMImage, Filename, ClockObject
|
||
from panda3d.core import deg2Rad, rad2Deg
|
||
import math
|
||
import random
|
||
import json
|
||
import os
|
||
from collections import deque
|
||
|
||
class EnvironmentSystem:
|
||
"""
|
||
地形天气和环境系统类
|
||
提供完整的天气模拟、环境效果、光照控制、动态天空等功能
|
||
"""
|
||
|
||
def __init__(self, world):
|
||
self.world = world
|
||
self.weather_conditions = {} # 存储天气条件
|
||
self.environment_effects = {} # 存储环境效果
|
||
self.lighting_system = {} # 存储光照系统
|
||
self.particle_systems = [] # 存储粒子系统
|
||
self.weather_enabled = True
|
||
self.current_weather = 'sunny'
|
||
self.time_of_day = 12.0 # 24小时制
|
||
self.current_season = 'summer'
|
||
self.weather_transition = None # 天气过渡状态
|
||
self.sky_dome = None # 天空穹顶
|
||
self.cloud_layer = None # 云层
|
||
self.wind_vector = Vec3(1, 0, 0) # 风向量
|
||
self.wind_strength = 0.1 # 风力强度
|
||
|
||
# 性能监控
|
||
self.performance_stats = {
|
||
'last_update_time': 0.0,
|
||
'update_count': 0,
|
||
'avg_update_time': 0.0
|
||
}
|
||
|
||
# 初始化环境系统
|
||
self._init_environment_system()
|
||
|
||
def _init_environment_system(self):
|
||
"""
|
||
初始化环境系统
|
||
"""
|
||
try:
|
||
# 定义默认天气条件
|
||
self._define_default_weather()
|
||
|
||
# 初始化光照系统
|
||
self._init_lighting_system()
|
||
|
||
# 初始化环境效果
|
||
self._init_environment_effects()
|
||
|
||
# 创建动态天空
|
||
self.create_dynamic_sky('dome')
|
||
|
||
print("环境系统初始化完成")
|
||
|
||
except Exception as e:
|
||
print(f"初始化环境系统时出错: {e}")
|
||
|
||
def _define_default_weather(self):
|
||
"""
|
||
定义默认天气条件（增强版）
|
||
"""
|
||
self.weather_conditions = {
|
||
'sunny': {
|
||
'name': '晴天',
|
||
'ambient_light': (0.3, 0.3, 0.3, 1.0),
|
||
'directional_light': (0.8, 0.8, 0.8, 1.0),
|
||
'light_color_temp': 5500, # 色温(K)
|
||
'fog_color': (0.5, 0.5, 0.5, 1.0),
|
||
'fog_density': 0.0,
|
||
'particle_effects': [],
|
||
'wind_strength': 0.1,
|
||
'temperature': 25.0,
|
||
'humidity': 30.0,
|
||
'visibility': 20000.0, # 能见度(米)
|
||
'cloud_coverage': 0.1, # 云覆盖率
|
||
'precipitation': 0.0, # 降水量
|
||
'sky_tint': (1.0, 1.0, 1.0, 1.0), # 天空着色
|
||
'sun_intensity': 1.0,
|
||
'moon_intensity': 0.0
|
||
},
|
||
'cloudy': {
|
||
'name': '多云',
|
||
'ambient_light': (0.2, 0.2, 0.2, 1.0),
|
||
'directional_light': (0.5, 0.5, 0.5, 1.0),
|
||
'light_color_temp': 4500,
|
||
'fog_color': (0.7, 0.7, 0.7, 1.0),
|
||
'fog_density': 0.001,
|
||
'particle_effects': ['clouds'],
|
||
'wind_strength': 0.3,
|
||
'temperature': 20.0,
|
||
'humidity': 60.0,
|
||
'visibility': 5000.0,
|
||
'cloud_coverage': 0.7,
|
||
'precipitation': 0.0,
|
||
'sky_tint': (0.8, 0.8, 0.8, 1.0),
|
||
'sun_intensity': 0.6,
|
||
'moon_intensity': 0.1
|
||
},
|
||
'rainy': {
|
||
'name': '雨天',
|
||
'ambient_light': (0.1, 0.1, 0.1, 1.0),
|
||
'directional_light': (0.3, 0.3, 0.3, 1.0),
|
||
'light_color_temp': 6500,
|
||
'fog_color': (0.8, 0.8, 0.8, 1.0),
|
||
'fog_density': 0.002,
|
||
'particle_effects': ['rain', 'clouds'],
|
||
'wind_strength': 0.5,
|
||
'temperature': 15.0,
|
||
'humidity': 90.0,
|
||
'visibility': 1000.0,
|
||
'cloud_coverage': 0.9,
|
||
'precipitation': 5.0,
|
||
'sky_tint': (0.7, 0.7, 0.7, 1.0),
|
||
'sun_intensity': 0.3,
|
||
'moon_intensity': 0.2
|
||
},
|
||
'stormy': {
|
||
'name': '暴风雨',
|
||
'ambient_light': (0.05, 0.05, 0.05, 1.0),
|
||
'directional_light': (0.2, 0.2, 0.2, 1.0),
|
||
'light_color_temp': 7000,
|
||
'fog_color': (0.9, 0.9, 0.9, 1.0),
|
||
'fog_density': 0.003,
|
||
'particle_effects': ['rain', 'lightning', 'clouds'],
|
||
'wind_strength': 1.0,
|
||
'temperature': 10.0,
|
||
'humidity': 95.0,
|
||
'visibility': 500.0,
|
||
'cloud_coverage': 1.0,
|
||
'precipitation': 20.0,
|
||
'sky_tint': (0.5, 0.5, 0.5, 1.0),
|
||
'sun_intensity': 0.1,
|
||
'moon_intensity': 0.3
|
||
},
|
||
'snowy': {
|
||
'name': '雪天',
|
||
'ambient_light': (0.2, 0.2, 0.2, 1.0),
|
||
'directional_light': (0.4, 0.4, 0.4, 1.0),
|
||
'light_color_temp': 5000,
|
||
'fog_color': (0.9, 0.9, 0.9, 1.0),
|
||
'fog_density': 0.001,
|
||
'particle_effects': ['snow', 'clouds'],
|
||
'wind_strength': 0.4,
|
||
'temperature': -5.0,
|
||
'humidity': 80.0,
|
||
'visibility': 2000.0,
|
||
'cloud_coverage': 0.8,
|
||
'precipitation': 3.0,
|
||
'sky_tint': (0.9, 0.9, 1.0, 1.0),
|
||
'sun_intensity': 0.4,
|
||
'moon_intensity': 0.4
|
||
},
|
||
'foggy': {
|
||
'name': '雾天',
|
||
'ambient_light': (0.15, 0.15, 0.15, 1.0),
|
||
'directional_light': (0.2, 0.2, 0.2, 1.0),
|
||
'light_color_temp': 3000,
|
||
'fog_color': (0.95, 0.95, 0.95, 1.0),
|
||
'fog_density': 0.005,
|
||
'particle_effects': ['mist'],
|
||
'wind_strength': 0.2,
|
||
'temperature': 12.0,
|
||
'humidity': 98.0,
|
||
'visibility': 200.0,
|
||
'cloud_coverage': 0.3,
|
||
'precipitation': 0.1,
|
||
'sky_tint': (0.9, 0.9, 0.9, 1.0),
|
||
'sun_intensity': 0.2,
|
||
'moon_intensity': 0.1
|
||
}
|
||
}
|
||
|
||
def _init_lighting_system(self):
|
||
"""
|
||
初始化光照系统（增强版）
|
||
"""
|
||
try:
|
||
# 创建环境光
|
||
ambient_light = AmbientLight('ambient_light')
|
||
ambient_light.setColor(Vec4(0.3, 0.3, 0.3, 1.0))
|
||
self.ambient_light_np = self.world.render.attachNewNode(ambient_light)
|
||
self.world.render.setLight(self.ambient_light_np)
|
||
|
||
# 创建方向光（太阳光）
|
||
directional_light = DirectionalLight('directional_light')
|
||
directional_light.setColor(Vec4(0.8, 0.8, 0.8, 1.0))
|
||
directional_light.setShadowCaster(True, 2048, 2048)
|
||
directional_light.setCameraMask(0x00000001) # 设置相机掩码
|
||
self.directional_light_np = self.world.render.attachNewNode(directional_light)
|
||
self.directional_light_np.setHpr(45, -45, 0)
|
||
self.world.render.setLight(self.directional_light_np)
|
||
|
||
# 创建月光
|
||
moon_light = DirectionalLight('moon_light')
|
||
moon_light.setColor(Vec4(0.1, 0.1, 0.2, 1.0))
|
||
self.moon_light_np = self.world.render.attachNewNode(moon_light)
|
||
self.moon_light_np.setHpr(225, -30, 0)
|
||
# 初始时禁用月光
|
||
self.world.render.clearLight(self.moon_light_np)
|
||
|
||
# 保存光照节点
|
||
self.lighting_system = {
|
||
'ambient': {
|
||
'node': ambient_light,
|
||
'nodepath': self.ambient_light_np
|
||
},
|
||
'directional': {
|
||
'node': directional_light,
|
||
'nodepath': self.directional_light_np
|
||
},
|
||
'moon': {
|
||
'node': moon_light,
|
||
'nodepath': self.moon_light_np,
|
||
'enabled': False
|
||
}
|
||
}
|
||
|
||
except Exception as e:
|
||
print(f"初始化光照系统时出错: {e}")
|
||
|
||
def _init_environment_effects(self):
|
||
"""
|
||
初始化环境效果（增强版）
|
||
"""
|
||
try:
|
||
# 初始化雾效
|
||
self.fog = Fog('environment_fog')
|
||
self.fog.setColor(0.5, 0.5, 0.5, 1.0)
|
||
self.fog.setExpDensity(0.0)
|
||
self.world.render.setFog(self.fog)
|
||
|
||
# 初始化风效
|
||
self.wind_vector = Vec3(1, 0, 0)
|
||
self.wind_strength = 0.1
|
||
|
||
# 初始化粒子系统容器
|
||
self.particle_containers = {
|
||
'rain': [],
|
||
'snow': [],
|
||
'clouds': [],
|
||
'lightning': [],
|
||
'mist': []
|
||
}
|
||
|
||
except Exception as e:
|
||
print(f"初始化环境效果时出错: {e}")
|
||
|
||
def set_weather(self, weather_type, transition_time=5.0):
|
||
"""
|
||
设置天气（增强版）
|
||
"""
|
||
try:
|
||
if weather_type not in self.weather_conditions:
|
||
print(f"未知的天气类型: {weather_type}")
|
||
return False
|
||
|
||
# 如果已经有过渡效果，取消它
|
||
if self.weather_transition:
|
||
self.weather_transition = None
|
||
|
||
# 如果需要平滑过渡
|
||
if transition_time > 0 and self.current_weather != weather_type:
|
||
self.weather_transition = {
|
||
'from': self.current_weather,
|
||
'to': weather_type,
|
||
'start_time': self.world.globalClock.getFrameTime(),
|
||
'duration': transition_time,
|
||
'progress': 0.0
|
||
}
|
||
print(f"开始天气过渡: {self.current_weather} -> {weather_type}")
|
||
else:
|
||
# 直接切换天气
|
||
self._apply_weather_immediately(weather_type)
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"设置天气时出错: {e}")
|
||
return False
|
||
|
||
def _apply_weather_immediately(self, weather_type):
|
||
"""
|
||
立即应用天气
|
||
"""
|
||
try:
|
||
weather = self.weather_conditions[weather_type]
|
||
self.current_weather = weather_type
|
||
|
||
# 更新环境光
|
||
if 'ambient' in self.lighting_system:
|
||
light_node = self.lighting_system['ambient']['node']
|
||
light_node.setColor(Vec4(*weather['ambient_light']))
|
||
|
||
# 更新方向光
|
||
if 'directional' in self.lighting_system:
|
||
light_node = self.lighting_system['directional']['node']
|
||
light_node.setColor(Vec4(*weather['directional_light']))
|
||
|
||
# 更新雾效
|
||
fog_color = weather['fog_color']
|
||
self.fog.setColor(fog_color[0], fog_color[1], fog_color[2], fog_color[3])
|
||
self.fog.setExpDensity(weather['fog_density'])
|
||
|
||
# 更新风效
|
||
self.wind_strength = weather['wind_strength']
|
||
|
||
# 更新粒子效果
|
||
self._update_particle_effects(weather['particle_effects'])
|
||
|
||
# 应用天气着色器
|
||
self._apply_weather_shader(weather_type)
|
||
|
||
# 更新天空
|
||
self._update_sky_for_weather(weather_type)
|
||
|
||
print(f"设置天气为: {weather['name']}")
|
||
|
||
except Exception as e:
|
||
print(f"立即应用天气时出错: {e}")
|
||
|
||
def _update_particle_effects(self, effects_list):
|
||
"""
|
||
更新粒子效果（增强版）
|
||
"""
|
||
try:
|
||
# 清除现有粒子效果
|
||
self._clear_particle_effects()
|
||
|
||
# 创建新的粒子效果
|
||
for effect in effects_list:
|
||
if effect == 'rain':
|
||
self._create_rain_effect()
|
||
elif effect == 'snow':
|
||
self._create_snow_effect()
|
||
elif effect == 'clouds':
|
||
self._create_cloud_effect()
|
||
elif effect == 'lightning':
|
||
self._create_lightning_effect()
|
||
elif effect == 'mist':
|
||
self._create_mist_effect()
|
||
|
||
except Exception as e:
|
||
print(f"更新粒子效果时出错: {e}")
|
||
|
||
def _clear_particle_effects(self):
|
||
"""
|
||
清除粒子效果（增强版）
|
||
"""
|
||
try:
|
||
# 移除所有粒子系统节点
|
||
for effect_type, particles in self.particle_containers.items():
|
||
for particle in particles:
|
||
if particle['node'] and not particle['node'].isEmpty():
|
||
particle['node'].removeNode()
|
||
self.particle_containers[effect_type] = []
|
||
|
||
# 清空旧的粒子系统列表
|
||
self.particle_systems = []
|
||
|
||
except Exception as e:
|
||
print(f"清除粒子效果时出错: {e}")
|
||
|
||
def _create_rain_effect(self):
|
||
"""
|
||
创建雨天效果（增强版）
|
||
"""
|
||
try:
|
||
# 创建雨滴粒子系统
|
||
rain_particles = []
|
||
|
||
# 创建多个雨滴发射器以提高性能
|
||
for i in range(5):
|
||
# 创建雨滴节点
|
||
cm = CardMaker(f'rain_drop_{i}')
|
||
cm.setFrame(-0.01, 0.01, -0.1, 0.1)
|
||
rain_node = self.world.render.attachNewNode(cm.generate())
|
||
rain_node.setBin("fixed", 40) # 确保在最上层
|
||
rain_node.setDepthWrite(False)
|
||
rain_node.setDepthTest(False)
|
||
|
||
# 设置雨滴纹理（简化版本）
|
||
# 实际项目中应该加载真实的雨滴纹理
|
||
rain_node.setColor(0.5, 0.5, 1.0, 0.7)
|
||
|
||
# 创建粒子信息
|
||
particle_info = {
|
||
'type': 'rain',
|
||
'node': rain_node,
|
||
'position': Vec3(random.uniform(-50, 50), random.uniform(-50, 50), 20),
|
||
'velocity': Vec3(random.uniform(-1, 1), random.uniform(-1, 1), -20.0),
|
||
'lifetime': random.uniform(1.0, 3.0),
|
||
'age': 0.0,
|
||
'emitter_id': i
|
||
}
|
||
|
||
rain_node.setPos(particle_info['position'])
|
||
rain_particles.append(particle_info)
|
||
|
||
self.particle_containers['rain'].extend(rain_particles)
|
||
self.particle_systems.extend(rain_particles)
|
||
|
||
print("创建雨天效果")
|
||
return rain_particles
|
||
|
||
except Exception as e:
|
||
print(f"创建雨天效果时出错: {e}")
|
||
return []
|
||
|
||
def _create_snow_effect(self):
|
||
"""
|
||
创建雪天效果（增强版）
|
||
"""
|
||
try:
|
||
# 创建雪花粒子系统
|
||
snow_particles = []
|
||
|
||
# 创建多个雪花发射器
|
||
for i in range(8):
|
||
# 创建雪花节点
|
||
cm = CardMaker(f'snow_flake_{i}')
|
||
size = random.uniform(0.05, 0.15)
|
||
cm.setFrame(-size, size, -size, size)
|
||
snow_node = self.world.render.attachNewNode(cm.generate())
|
||
snow_node.setBin("fixed", 35)
|
||
snow_node.setDepthWrite(False)
|
||
snow_node.setDepthTest(False)
|
||
|
||
# 设置雪花颜色
|
||
snow_node.setColor(1.0, 1.0, 1.0, 0.8)
|
||
|
||
# 创建粒子信息
|
||
particle_info = {
|
||
'type': 'snow',
|
||
'node': snow_node,
|
||
'position': Vec3(random.uniform(-100, 100), random.uniform(-100, 100), 30),
|
||
'velocity': Vec3(random.uniform(-2, 2), random.uniform(-2, 2), random.uniform(-5, -2)),
|
||
'lifetime': random.uniform(5.0, 10.0),
|
||
'age': 0.0,
|
||
'rotation_speed': random.uniform(-10, 10),
|
||
'emitter_id': i
|
||
}
|
||
|
||
snow_node.setPos(particle_info['position'])
|
||
snow_particles.append(particle_info)
|
||
|
||
self.particle_containers['snow'].extend(snow_particles)
|
||
self.particle_systems.extend(snow_particles)
|
||
|
||
print("创建雪天效果")
|
||
return snow_particles
|
||
|
||
except Exception as e:
|
||
print(f"创建雪天效果时出错: {e}")
|
||
return []
|
||
|
||
def _create_cloud_effect(self):
|
||
"""
|
||
创建云效果（增强版）
|
||
"""
|
||
try:
|
||
# 创建云朵粒子系统
|
||
cloud_particles = []
|
||
|
||
# 创建多个云朵
|
||
for i in range(10):
|
||
# 创建云朵节点
|
||
cm = CardMaker(f'cloud_{i}')
|
||
size = random.uniform(10, 30)
|
||
cm.setFrame(-size, size, -size/2, size/2)
|
||
cloud_node = self.world.render.attachNewNode(cm.generate())
|
||
cloud_node.setBin("fixed", 30)
|
||
cloud_node.setDepthWrite(False)
|
||
cloud_node.setDepthTest(False)
|
||
|
||
# 设置云朵颜色和透明度
|
||
cloud_node.setColor(1.0, 1.0, 1.0, random.uniform(0.3, 0.7))
|
||
|
||
# 创建粒子信息
|
||
particle_info = {
|
||
'type': 'clouds',
|
||
'node': cloud_node,
|
||
'position': Vec3(random.uniform(-200, 200), random.uniform(-200, 200), random.uniform(50, 80)),
|
||
'velocity': Vec3(random.uniform(-0.5, 0.5), random.uniform(-0.5, 0.5), 0),
|
||
'lifetime': float('inf'), # 永久存在
|
||
'age': 0.0,
|
||
'scale': size,
|
||
'emitter_id': i
|
||
}
|
||
|
||
cloud_node.setPos(particle_info['position'])
|
||
cloud_particles.append(particle_info)
|
||
|
||
self.particle_containers['clouds'].extend(cloud_particles)
|
||
self.particle_systems.extend(cloud_particles)
|
||
|
||
print("创建云效果")
|
||
return cloud_particles
|
||
|
||
except Exception as e:
|
||
print(f"创建云效果时出错: {e}")
|
||
return []
|
||
|
||
def _create_lightning_effect(self):
|
||
"""
|
||
创建闪电效果（增强版）
|
||
"""
|
||
try:
|
||
# 创建闪电效果
|
||
lightning_effects = []
|
||
|
||
# 创建闪电节点
|
||
cm = CardMaker('lightning')
|
||
cm.setFrame(-100, 100, -100, 100)
|
||
lightning_node = self.world.render.attachNewNode(cm.generate())
|
||
lightning_node.setBin("fixed", 50)
|
||
lightning_node.setDepthWrite(False)
|
||
lightning_node.setDepthTest(False)
|
||
|
||
# 设置初始不可见
|
||
lightning_node.hide()
|
||
|
||
# 创建闪电信息
|
||
lightning_info = {
|
||
'type': 'lightning',
|
||
'node': lightning_node,
|
||
'position': Vec3(0, 0, 100),
|
||
'lifetime': 0.1, # 闪电持续时间很短
|
||
'age': 0.0,
|
||
'next_strike_time': random.uniform(5, 15), # 下次闪电时间
|
||
'intensity': 2.0
|
||
}
|
||
|
||
lightning_node.setPos(lightning_info['position'])
|
||
lightning_effects.append(lightning_info)
|
||
|
||
self.particle_containers['lightning'].extend(lightning_effects)
|
||
self.particle_systems.extend(lightning_effects)
|
||
|
||
print("创建闪电效果")
|
||
return lightning_effects
|
||
|
||
except Exception as e:
|
||
print(f"创建闪电效果时出错: {e}")
|
||
return []
|
||
|
||
def _create_mist_effect(self):
|
||
"""
|
||
创建雾气效果（增强版）
|
||
"""
|
||
try:
|
||
# 创建雾气粒子系统
|
||
mist_particles = []
|
||
|
||
# 创建多个雾气发射器
|
||
for i in range(3):
|
||
# 创建雾气节点
|
||
cm = CardMaker(f'mist_{i}')
|
||
size = random.uniform(20, 50)
|
||
cm.setFrame(-size, size, -size/2, size/2)
|
||
mist_node = self.world.render.attachNewNode(cm.generate())
|
||
mist_node.setBin("fixed", 25)
|
||
mist_node.setDepthWrite(False)
|
||
mist_node.setDepthTest(False)
|
||
|
||
# 设置雾气颜色
|
||
mist_node.setColor(0.9, 0.9, 0.9, random.uniform(0.2, 0.4))
|
||
|
||
# 创建粒子信息
|
||
particle_info = {
|
||
'type': 'mist',
|
||
'node': mist_node,
|
||
'position': Vec3(random.uniform(-100, 100), random.uniform(-100, 100), random.uniform(0, 5)),
|
||
'velocity': Vec3(random.uniform(-0.2, 0.2), random.uniform(-0.2, 0.2), 0),
|
||
'lifetime': float('inf'),
|
||
'age': 0.0,
|
||
'scale': size,
|
||
'emitter_id': i
|
||
}
|
||
|
||
mist_node.setPos(particle_info['position'])
|
||
mist_particles.append(particle_info)
|
||
|
||
self.particle_containers['mist'].extend(mist_particles)
|
||
self.particle_systems.extend(mist_particles)
|
||
|
||
print("创建雾气效果")
|
||
return mist_particles
|
||
|
||
except Exception as e:
|
||
print(f"创建雾气效果时出错: {e}")
|
||
return []
|
||
|
||
def _apply_weather_shader(self, weather_type):
|
||
"""
|
||
应用天气着色器（增强版）
|
||
"""
|
||
try:
|
||
# 如果使用RenderPipeline，应用天气效果
|
||
if hasattr(self.world, 'render_pipeline'):
|
||
try:
|
||
# 根据天气类型选择着色器
|
||
if weather_type == 'rainy':
|
||
effect_file = "effects/rain_weather.yaml"
|
||
elif weather_type == 'stormy':
|
||
effect_file = "effects/storm_weather.yaml"
|
||
elif weather_type == 'snowy':
|
||
effect_file = "effects/snow_weather.yaml"
|
||
elif weather_type == 'foggy':
|
||
effect_file = "effects/fog_weather.yaml"
|
||
else:
|
||
effect_file = "effects/default_weather.yaml"
|
||
|
||
self.world.render_pipeline.set_effect(
|
||
self.world.render,
|
||
effect_file,
|
||
{
|
||
"weather_type": weather_type,
|
||
"wind_strength": self.wind_strength,
|
||
"fog_density": self.weather_conditions[weather_type]['fog_density'],
|
||
"time_of_day": self.time_of_day
|
||
},
|
||
5 # 排序值
|
||
)
|
||
|
||
except Exception as e:
|
||
print(f"应用天气着色器失败: {e}")
|
||
|
||
except Exception as e:
|
||
print(f"应用天气着色器时出错: {e}")
|
||
|
||
def update_environment(self, time_delta):
|
||
"""
|
||
更新环境系统（增强版）
|
||
"""
|
||
try:
|
||
if not self.weather_enabled:
|
||
return
|
||
|
||
# 性能监控开始
|
||
start_time = self.world.globalClock.getRealTime()
|
||
|
||
# 更新天气过渡
|
||
self._update_weather_transition(time_delta)
|
||
|
||
# 更新粒子效果
|
||
self._update_particles(time_delta)
|
||
|
||
# 更新风效
|
||
self._update_wind(time_delta)
|
||
|
||
# 更新光照
|
||
self._update_lighting(time_delta)
|
||
|
||
# 更新天空
|
||
self._update_sky(time_delta)
|
||
|
||
# 更新性能统计
|
||
end_time = self.world.globalClock.getRealTime()
|
||
update_time = end_time - start_time
|
||
self.performance_stats['last_update_time'] = update_time
|
||
self.performance_stats['update_count'] += 1
|
||
|
||
# 计算平均更新时间
|
||
if self.performance_stats['update_count'] > 1:
|
||
alpha = 0.1
|
||
self.performance_stats['avg_update_time'] = (
|
||
alpha * update_time +
|
||
(1 - alpha) * self.performance_stats['avg_update_time']
|
||
)
|
||
else:
|
||
self.performance_stats['avg_update_time'] = update_time
|
||
|
||
except Exception as e:
|
||
print(f"更新环境系统时出错: {e}")
|
||
|
||
def _update_weather_transition(self, time_delta):
|
||
"""
|
||
更新天气过渡效果
|
||
"""
|
||
try:
|
||
if not self.weather_transition:
|
||
return
|
||
|
||
# 更新过渡进度
|
||
current_time = self.world.globalClock.getFrameTime()
|
||
elapsed = current_time - self.weather_transition['start_time']
|
||
progress = min(1.0, elapsed / self.weather_transition['duration'])
|
||
|
||
self.weather_transition['progress'] = progress
|
||
|
||
# 获取起始和目标天气
|
||
from_weather = self.weather_conditions[self.weather_transition['from']]
|
||
to_weather = self.weather_conditions[self.weather_transition['to']]
|
||
|
||
# 插值计算当前天气参数
|
||
if progress >= 1.0:
|
||
# 过渡完成，应用最终天气
|
||
self._apply_weather_immediately(self.weather_transition['to'])
|
||
self.weather_transition = None
|
||
else:
|
||
# 过渡中，插值计算参数
|
||
self._interpolate_weather_parameters(from_weather, to_weather, progress)
|
||
|
||
except Exception as e:
|
||
print(f"更新天气过渡时出错: {e}")
|
||
|
||
def _interpolate_weather_parameters(self, from_weather, to_weather, progress):
|
||
"""
|
||
插值计算天气参数
|
||
"""
|
||
try:
|
||
# 线性插值函数
|
||
def lerp(a, b, t):
|
||
if isinstance(a, (list, tuple)) and len(a) == len(b):
|
||
return [a[i] + (b[i] - a[i]) * t for i in range(len(a))]
|
||
return a + (b - a) * t
|
||
|
||
# 插值环境光
|
||
if 'ambient' in self.lighting_system:
|
||
ambient_from = from_weather['ambient_light']
|
||
ambient_to = to_weather['ambient_light']
|
||
ambient_current = lerp(ambient_from, ambient_to, progress)
|
||
light_node = self.lighting_system['ambient']['node']
|
||
light_node.setColor(Vec4(*ambient_current))
|
||
|
||
# 插值方向光
|
||
if 'directional' in self.lighting_system:
|
||
directional_from = from_weather['directional_light']
|
||
directional_to = to_weather['directional_light']
|
||
directional_current = lerp(directional_from, directional_to, progress)
|
||
light_node = self.lighting_system['directional']['node']
|
||
light_node.setColor(Vec4(*directional_current))
|
||
|
||
# 插值雾效
|
||
fog_from = from_weather['fog_color']
|
||
fog_to = to_weather['fog_color']
|
||
fog_color_current = lerp(fog_from, fog_to, progress)
|
||
self.fog.setColor(fog_color_current[0], fog_color_current[1], fog_color_current[2], fog_color_current[3])
|
||
|
||
fog_density_from = from_weather['fog_density']
|
||
fog_density_to = to_weather['fog_density']
|
||
fog_density_current = lerp(fog_density_from, fog_density_to, progress)
|
||
self.fog.setExpDensity(fog_density_current)
|
||
|
||
# 插值风力
|
||
wind_from = from_weather['wind_strength']
|
||
wind_to = to_weather['wind_strength']
|
||
self.wind_strength = lerp(wind_from, wind_to, progress)
|
||
|
||
except Exception as e:
|
||
print(f"插值天气参数时出错: {e}")
|
||
|
||
def _update_particles(self, time_delta):
|
||
"""
|
||
更新粒子效果（增强版）
|
||
"""
|
||
try:
|
||
current_time = self.world.globalClock.getFrameTime()
|
||
|
||
# 更新所有粒子系统
|
||
for particle in self.particle_systems[:]: # 使用切片复制
|
||
# 更新粒子年龄
|
||
particle['age'] += time_delta
|
||
|
||
# 检查生命周期
|
||
if particle['lifetime'] != float('inf') and particle['age'] > particle['lifetime']:
|
||
# 移除过期粒子
|
||
if particle['node'] and not particle['node'].isEmpty():
|
||
particle['node'].removeNode()
|
||
if particle in self.particle_systems:
|
||
self.particle_systems.remove(particle)
|
||
continue
|
||
|
||
# 根据粒子类型更新
|
||
if particle['type'] == 'rain':
|
||
self._update_rain_particle(particle, time_delta, current_time)
|
||
elif particle['type'] == 'snow':
|
||
self._update_snow_particle(particle, time_delta, current_time)
|
||
elif particle['type'] == 'clouds':
|
||
self._update_cloud_particle(particle, time_delta, current_time)
|
||
elif particle['type'] == 'lightning':
|
||
self._update_lightning_particle(particle, time_delta, current_time)
|
||
elif particle['type'] == 'mist':
|
||
self._update_mist_particle(particle, time_delta, current_time)
|
||
|
||
except Exception as e:
|
||
print(f"更新粒子效果时出错: {e}")
|
||
|
||
def _update_rain_particle(self, particle, time_delta, current_time):
|
||
"""
|
||
更新雨滴粒子
|
||
"""
|
||
try:
|
||
# 更新位置
|
||
particle['position'] += particle['velocity'] * time_delta
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
# 如果雨滴落到地面以下，重置位置
|
||
if particle['position'].getZ() < 0:
|
||
particle['position'].setZ(20) # 重置到高处
|
||
particle['position'].setX(random.uniform(-50, 50))
|
||
particle['position'].setY(random.uniform(-50, 50))
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
except Exception as e:
|
||
print(f"更新雨滴粒子时出错: {e}")
|
||
|
||
def _update_snow_particle(self, particle, time_delta, current_time):
|
||
"""
|
||
更新雪花粒子
|
||
"""
|
||
try:
|
||
# 更新位置
|
||
particle['position'] += particle['velocity'] * time_delta
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
# 添加摆动效果
|
||
sway = math.sin(current_time * 2 + particle['emitter_id']) * 0.5
|
||
particle['position'].setX(particle['position'].getX() + sway * time_delta)
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
# 更新旋转
|
||
particle['node'].setHpr(particle['node'].getHpr() + Vec3(0, 0, particle['rotation_speed'] * time_delta))
|
||
|
||
# 如果雪花落到地面以下，重置位置
|
||
if particle['position'].getZ() < 0:
|
||
particle['position'].setZ(30) # 重置到高处
|
||
particle['position'].setX(random.uniform(-100, 100))
|
||
particle['position'].setY(random.uniform(-100, 100))
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
except Exception as e:
|
||
print(f"更新雪花粒子时出错: {e}")
|
||
|
||
def _update_cloud_particle(self, particle, time_delta, current_time):
|
||
"""
|
||
更新云朵粒子
|
||
"""
|
||
try:
|
||
# 更新位置
|
||
particle['position'] += particle['velocity'] * time_delta
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
# 添加缓慢变化效果
|
||
if random.random() < 0.01: # 1%概率改变速度
|
||
particle['velocity'] = Vec3(
|
||
random.uniform(-0.5, 0.5),
|
||
random.uniform(-0.5, 0.5),
|
||
0
|
||
)
|
||
|
||
# 如果云朵移出范围，重置位置
|
||
if (abs(particle['position'].getX()) > 300 or
|
||
abs(particle['position'].getY()) > 300):
|
||
particle['position'].setX(random.uniform(-200, 200))
|
||
particle['position'].setY(random.uniform(-200, 200))
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
except Exception as e:
|
||
print(f"更新云朵粒子时出错: {e}")
|
||
|
||
def _update_lightning_particle(self, particle, time_delta, current_time):
|
||
"""
|
||
更新闪电粒子
|
||
"""
|
||
try:
|
||
# 更新计时器
|
||
particle['next_strike_time'] -= time_delta
|
||
|
||
# 检查是否触发闪电
|
||
if particle['next_strike_time'] <= 0:
|
||
# 显示闪电
|
||
particle['node'].show()
|
||
particle['age'] = 0 # 重置年龄
|
||
|
||
# 随机改变闪电位置
|
||
particle['position'] = Vec3(
|
||
random.uniform(-100, 100),
|
||
random.uniform(-100, 100),
|
||
100
|
||
)
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
# 设置下次闪电时间
|
||
particle['next_strike_time'] = random.uniform(5, 15)
|
||
|
||
# 增强环境光模拟闪电光照
|
||
if 'ambient' in self.lighting_system:
|
||
light_node = self.lighting_system['ambient']['node']
|
||
light_node.setColor(Vec4(0.8, 0.8, 0.8, 1.0))
|
||
else:
|
||
# 检查是否需要隐藏闪电
|
||
if particle['age'] > particle['lifetime']:
|
||
particle['node'].hide()
|
||
# 恢复正常环境光
|
||
current_weather = self.weather_conditions[self.current_weather]
|
||
if 'ambient' in self.lighting_system:
|
||
light_node = self.lighting_system['ambient']['node']
|
||
light_node.setColor(Vec4(*current_weather['ambient_light']))
|
||
|
||
except Exception as e:
|
||
print(f"更新闪电粒子时出错: {e}")
|
||
|
||
def _update_mist_particle(self, particle, time_delta, current_time):
|
||
"""
|
||
更新雾气粒子
|
||
"""
|
||
try:
|
||
# 更新位置
|
||
particle['position'] += particle['velocity'] * time_delta
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
# 缓慢改变透明度
|
||
alpha = particle['node'].getColor().getW()
|
||
alpha += random.uniform(-0.01, 0.01)
|
||
alpha = max(0.1, min(0.5, alpha)) # 限制在合理范围内
|
||
particle['node'].setColor(
|
||
particle['node'].getColor().getX(),
|
||
particle['node'].getColor().getY(),
|
||
particle['node'].getColor().getZ(),
|
||
alpha
|
||
)
|
||
|
||
# 如果雾气移出范围，重置位置
|
||
if (abs(particle['position'].getX()) > 200 or
|
||
abs(particle['position'].getY()) > 200):
|
||
particle['position'].setX(random.uniform(-100, 100))
|
||
particle['position'].setY(random.uniform(-100, 100))
|
||
particle['node'].setPos(particle['position'])
|
||
|
||
except Exception as e:
|
||
print(f"更新雾气粒子时出错: {e}")
|
||
|
||
def _update_wind(self, time_delta):
|
||
"""
|
||
更新风效（增强版）
|
||
"""
|
||
try:
|
||
# 可以实现风向和风力的变化
|
||
# 例如随机改变风向或模拟阵风
|
||
current_weather = self.weather_conditions[self.current_weather]
|
||
|
||
# 模拟阵风效果
|
||
gust_factor = 1.0 + math.sin(self.world.globalClock.getFrameTime() * 0.5) * 0.3
|
||
self.wind_vector = Vec3(
|
||
math.cos(self.world.globalClock.getFrameTime() * 0.1) * gust_factor,
|
||
math.sin(self.world.globalClock.getFrameTime() * 0.1) * gust_factor,
|
||
0
|
||
) * current_weather['wind_strength']
|
||
|
||
except Exception as e:
|
||
print(f"更新风效时出错: {e}")
|
||
|
||
def _update_lighting(self, time_delta):
|
||
"""
|
||
更新光照（增强版）
|
||
"""
|
||
try:
|
||
# 更新时间
|
||
self.time_of_day += time_delta / 3600.0 # 假设1秒对应1小时
|
||
if self.time_of_day >= 24.0:
|
||
self.time_of_day -= 24.0
|
||
|
||
# 根据时间调整太阳和月亮位置
|
||
self._update_celestial_positions()
|
||
|
||
# 根据时间调整光照颜色
|
||
self._update_lighting_colors()
|
||
|
||
except Exception as e:
|
||
print(f"更新光照时出错: {e}")
|
||
|
||
def _update_celestial_positions(self):
|
||
"""
|
||
更新天体位置
|
||
"""
|
||
try:
|
||
# 计算太阳位置（简化模型）
|
||
sun_angle = self.time_of_day / 24.0 * 360.0
|
||
sun_elevation = math.sin(deg2Rad(sun_angle)) * 60.0 # 最大仰角60度
|
||
|
||
if hasattr(self, 'directional_light_np'):
|
||
self.directional_light_np.setHpr(sun_angle, -sun_elevation, 0)
|
||
|
||
# 计算月亮位置（与太阳相差180度）
|
||
moon_angle = (sun_angle + 180.0) % 360.0
|
||
moon_elevation = math.sin(deg2Rad(moon_angle)) * 50.0
|
||
|
||
if hasattr(self, 'moon_light_np'):
|
||
self.moon_light_np.setHpr(moon_angle, -moon_elevation, 0)
|
||
|
||
# 根据太阳高度控制月亮显示
|
||
if sun_elevation < -10.0: # 太阳在地平线以下10度时显示月亮
|
||
if not self.lighting_system['moon']['enabled']:
|
||
self.world.render.setLight(self.moon_light_np)
|
||
self.lighting_system['moon']['enabled'] = True
|
||
else:
|
||
if self.lighting_system['moon']['enabled']:
|
||
self.world.render.clearLight(self.moon_light_np)
|
||
self.lighting_system['moon']['enabled'] = False
|
||
|
||
except Exception as e:
|
||
print(f"更新天体位置时出错: {e}")
|
||
|
||
def _update_lighting_colors(self):
|
||
"""
|
||
更新光照颜色
|
||
"""
|
||
try:
|
||
# 根据太阳高度调整光照颜色
|
||
sun_elevation = math.sin(deg2Rad(self.time_of_day / 24.0 * 360.0)) * 60.0
|
||
|
||
# 计算日照因子
|
||
day_factor = max(0.0, min(1.0, (sun_elevation + 10.0) / 70.0)) # 从-10度到60度
|
||
|
||
# 获取当前天气
|
||
current_weather = self.weather_conditions[self.current_weather]
|
||
|
||
# 插值计算光照颜色
|
||
if 'directional' in self.lighting_system:
|
||
day_color = current_weather['directional_light']
|
||
night_color = (0.1, 0.1, 0.2, 1.0) # 月光颜色
|
||
light_color = [
|
||
day_color[i] * day_factor + night_color[i] * (1.0 - day_factor)
|
||
for i in range(4)
|
||
]
|
||
light_node = self.lighting_system['directional']['node']
|
||
light_node.setColor(Vec4(*light_color))
|
||
|
||
# 更新环境光
|
||
if 'ambient' in self.lighting_system:
|
||
day_ambient = current_weather['ambient_light']
|
||
night_ambient = (0.05, 0.05, 0.1, 1.0)
|
||
ambient_color = [
|
||
day_ambient[i] * day_factor + night_ambient[i] * (1.0 - day_factor)
|
||
for i in range(4)
|
||
]
|
||
light_node = self.lighting_system['ambient']['node']
|
||
light_node.setColor(Vec4(*ambient_color))
|
||
|
||
except Exception as e:
|
||
print(f"更新光照颜色时出错: {e}")
|
||
|
||
def _update_sky(self, time_delta):
|
||
"""
|
||
更新天空（增强版）
|
||
"""
|
||
try:
|
||
# 更新天空颜色
|
||
self._update_sky_color()
|
||
|
||
# 更新云层
|
||
self._update_cloud_layer(time_delta)
|
||
|
||
except Exception as e:
|
||
print(f"更新天空时出错: {e}")
|
||
|
||
def _update_sky_color(self):
|
||
"""
|
||
更新天空颜色
|
||
"""
|
||
try:
|
||
# 根据时间、天气和季节调整天空颜色
|
||
current_weather = self.weather_conditions[self.current_weather]
|
||
sky_tint = current_weather['sky_tint']
|
||
|
||
# 根据太阳高度调整天空颜色
|
||
sun_elevation = math.sin(deg2Rad(self.time_of_day / 24.0 * 360.0)) * 60.0
|
||
day_factor = max(0.0, min(1.0, (sun_elevation + 10.0) / 70.0))
|
||
|
||
# 计算天空颜色
|
||
day_sky = (0.4, 0.6, 1.0, 1.0) # 白天天空蓝
|
||
night_sky = (0.05, 0.05, 0.1, 1.0) # 夜晚天空暗
|
||
|
||
sky_color = [
|
||
(day_sky[i] * sky_tint[i] * day_factor + night_sky[i] * (1.0 - day_factor))
|
||
* current_weather['sun_intensity']
|
||
for i in range(4)
|
||
]
|
||
|
||
# 应用天空颜色到天空穹顶
|
||
if self.sky_dome:
|
||
self.sky_dome.setColor(Vec4(*sky_color))
|
||
|
||
except Exception as e:
|
||
print(f"更新天空颜色时出错: {e}")
|
||
|
||
def _update_cloud_layer(self, time_delta):
|
||
"""
|
||
更新云层
|
||
"""
|
||
# 云层更新已在粒子系统中处理
|
||
pass
|
||
|
||
def _update_sky_for_weather(self, weather_type):
|
||
"""
|
||
根据天气更新天空
|
||
"""
|
||
try:
|
||
if self.sky_dome:
|
||
current_weather = self.weather_conditions[weather_type]
|
||
# 可以根据天气调整天空穹顶的纹理或颜色
|
||
pass
|
||
|
||
except Exception as e:
|
||
print(f"根据天气更新天空时出错: {e}")
|
||
|
||
def set_time_of_day(self, hour, minute=0):
|
||
"""
|
||
设置一天中的时间（增强版）
|
||
"""
|
||
try:
|
||
self.time_of_day = hour + minute / 60.0
|
||
|
||
# 立即更新光照和天空
|
||
self._update_celestial_positions()
|
||
self._update_lighting_colors()
|
||
self._update_sky_color()
|
||
|
||
print(f"设置时间为: {hour:02d}:{minute:02d}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"设置时间时出错: {e}")
|
||
return False
|
||
|
||
def set_season(self, season):
|
||
"""
|
||
设置季节（增强版）
|
||
"""
|
||
try:
|
||
seasons = {
|
||
'spring': {'temperature': 15.0, 'vegetation_color': (0.3, 0.7, 0.3, 1.0)},
|
||
'summer': {'temperature': 25.0, 'vegetation_color': (0.2, 0.8, 0.2, 1.0)},
|
||
'autumn': {'temperature': 10.0, 'vegetation_color': (0.8, 0.5, 0.2, 1.0)},
|
||
'winter': {'temperature': -5.0, 'vegetation_color': (0.6, 0.6, 0.8, 1.0)}
|
||
}
|
||
|
||
if season in seasons:
|
||
self.current_season = season
|
||
season_data = seasons[season]
|
||
print(f"设置季节为: {season}")
|
||
return season_data
|
||
|
||
except Exception as e:
|
||
print(f"设置季节时出错: {e}")
|
||
return None
|
||
|
||
def create_dynamic_sky(self, sky_type='dome'):
|
||
"""
|
||
创建动态天空（增强版）
|
||
"""
|
||
try:
|
||
# 移除现有的天空
|
||
if self.sky_dome and not self.sky_dome.isEmpty():
|
||
self.sky_dome.removeNode()
|
||
|
||
# 创建天空穹顶
|
||
if sky_type == 'dome':
|
||
self._create_sky_dome()
|
||
elif sky_type == 'box':
|
||
self._create_sky_box()
|
||
elif sky_type == 'procedural':
|
||
self._create_procedural_sky()
|
||
|
||
print(f"创建动态天空: {sky_type}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"创建动态天空时出错: {e}")
|
||
return False
|
||
|
||
def _create_sky_dome(self):
|
||
"""
|
||
创建天空穹顶（增强版）
|
||
"""
|
||
try:
|
||
# 创建天空穹顶几何体
|
||
from panda3d.core import GeomVertexFormat, GeomVertexData, GeomVertexWriter
|
||
from panda3d.core import GeomTriangles, Geom, GeomNode
|
||
|
||
# 创建顶点数据
|
||
vformat = GeomVertexFormat.getV3c4()
|
||
vdata = GeomVertexData('sky_dome', vformat, Geom.UHStatic)
|
||
|
||
# 添加顶点
|
||
vertex = GeomVertexWriter(vdata, 'vertex')
|
||
color = GeomVertexWriter(vdata, 'color')
|
||
|
||
# 创建半球形穹顶
|
||
radius = 1000.0
|
||
segments = 32
|
||
rings = 16
|
||
|
||
vertices = []
|
||
indices = []
|
||
|
||
# 生成顶点
|
||
for r in range(rings + 1):
|
||
for s in range(segments + 1):
|
||
# 球面坐标
|
||
theta = math.pi * r / rings # 从0到π
|
||
phi = 2 * math.pi * s / segments # 从0到2π
|
||
|
||
x = radius * math.sin(theta) * math.cos(phi)
|
||
y = radius * math.sin(theta) * math.sin(phi)
|
||
z = radius * math.cos(theta)
|
||
|
||
vertices.append((x, y, z))
|
||
|
||
# 生成索引
|
||
for r in range(rings):
|
||
for s in range(segments):
|
||
# 计算四个顶点的索引
|
||
i1 = r * (segments + 1) + s
|
||
i2 = r * (segments + 1) + (s + 1)
|
||
i3 = (r + 1) * (segments + 1) + s
|
||
i4 = (r + 1) * (segments + 1) + (s + 1)
|
||
|
||
# 添加两个三角形
|
||
indices.extend([i1, i3, i2])
|
||
indices.extend([i2, i3, i4])
|
||
|
||
# 写入顶点数据
|
||
for i, (x, y, z) in enumerate(vertices):
|
||
vertex.addData3(x, y, z)
|
||
# 默认天空颜色
|
||
color.addData4(0.4, 0.6, 1.0, 1.0)
|
||
|
||
# 创建几何体
|
||
geom = Geom(vdata)
|
||
prim = GeomTriangles(Geom.UHStatic)
|
||
|
||
# 添加索引
|
||
for idx in indices:
|
||
prim.addVertex(idx)
|
||
prim.closePrimitive()
|
||
|
||
geom.addPrimitive(prim)
|
||
|
||
# 创建节点
|
||
node = GeomNode('sky_dome')
|
||
node.addGeom(geom)
|
||
|
||
# 创建节点路径
|
||
self.sky_dome = self.world.render.attachNewNode(node)
|
||
|
||
# 设置渲染属性
|
||
self.sky_dome.setBin("background", 0)
|
||
self.sky_dome.setDepthWrite(False)
|
||
self.sky_dome.setDepthTest(False)
|
||
self.sky_dome.setLightOff()
|
||
self.sky_dome.setFogOff()
|
||
|
||
# 设置位置在相机中心
|
||
self.sky_dome.setCompass() # 跟随相机旋转但不移动
|
||
|
||
print("创建天空穹顶")
|
||
|
||
except Exception as e:
|
||
print(f"创建天空穹顶时出错: {e}")
|
||
|
||
def _create_sky_box(self):
|
||
"""
|
||
创建天空盒
|
||
"""
|
||
# 简化实现，实际项目中应该加载立方体贴图
|
||
print("创建天空盒（简化实现）")
|
||
pass
|
||
|
||
def _create_procedural_sky(self):
|
||
"""
|
||
创建程序化天空
|
||
"""
|
||
# 简化实现，实际项目中应该使用着色器生成程序化天空
|
||
print("创建程序化天空（简化实现）")
|
||
pass
|
||
|
||
def simulate_weather_cycle(self, duration=3600.0, cycle_pattern=None):
|
||
"""
|
||
模拟天气循环（增强版）
|
||
"""
|
||
try:
|
||
# 创建天气变化序列
|
||
if cycle_pattern is None:
|
||
# 默认循环模式
|
||
cycle_pattern = ['sunny', 'cloudy', 'rainy', 'stormy', 'snowy', 'foggy']
|
||
|
||
# 可以实现定时改变天气
|
||
print(f"开始天气循环模拟，持续时间: {duration}秒")
|
||
print(f"循环模式: {cycle_pattern}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"模拟天气循环时出错: {e}")
|
||
return False
|
||
|
||
def get_environment_stats(self):
|
||
"""
|
||
获取环境统计信息（增强版）
|
||
"""
|
||
stats = {
|
||
'current_weather': self.current_weather,
|
||
'time_of_day': self.time_of_day,
|
||
'current_season': self.current_season,
|
||
'weather_enabled': self.weather_enabled,
|
||
'particle_systems': len(self.particle_systems),
|
||
'fog_density': self.fog.getExpDensity() if self.fog else 0.0,
|
||
'wind_strength': self.wind_strength,
|
||
'wind_vector': (self.wind_vector.getX(), self.wind_vector.getY(), self.wind_vector.getZ()),
|
||
'ambient_light': self.lighting_system['ambient']['node'].getColor() if 'ambient' in self.lighting_system else Vec4(0,0,0,0),
|
||
'directional_light': self.lighting_system['directional']['node'].getColor() if 'directional' in self.lighting_system else Vec4(0,0,0,0),
|
||
'moon_light_enabled': self.lighting_system['moon']['enabled'] if 'moon' in self.lighting_system else False,
|
||
'sky_dome_exists': self.sky_dome is not None and not self.sky_dome.isEmpty(),
|
||
'performance': {
|
||
'last_update_time': self.performance_stats['last_update_time'],
|
||
'avg_update_time': self.performance_stats['avg_update_time'],
|
||
'update_count': self.performance_stats['update_count']
|
||
}
|
||
}
|
||
|
||
return stats
|
||
|
||
def save_environment_data(self, output_path):
|
||
"""
|
||
保存环境数据（增强版）
|
||
"""
|
||
try:
|
||
# 收集环境数据
|
||
environment_data = {
|
||
'current_weather': self.current_weather,
|
||
'time_of_day': self.time_of_day,
|
||
'current_season': self.current_season,
|
||
'weather_conditions': self.weather_conditions,
|
||
'lighting': {
|
||
'ambient': list(self.lighting_system['ambient']['node'].getColor()) if 'ambient' in self.lighting_system else [],
|
||
'directional': list(self.lighting_system['directional']['node'].getColor()) if 'directional' in self.lighting_system else [],
|
||
'moon_enabled': self.lighting_system['moon']['enabled'] if 'moon' in self.lighting_system else False
|
||
},
|
||
'fog': {
|
||
'color': list(self.fog.getColor()) if self.fog else [],
|
||
'density': self.fog.getExpDensity() if self.fog else 0.0
|
||
},
|
||
'wind': {
|
||
'strength': self.wind_strength,
|
||
'vector': [self.wind_vector.getX(), self.wind_vector.getY(), self.wind_vector.getZ()]
|
||
}
|
||
}
|
||
|
||
# 确保输出目录存在
|
||
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(environment_data, f, indent=2, ensure_ascii=False)
|
||
|
||
print(f"环境数据保存成功: {output_path}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"保存环境数据时出错: {e}")
|
||
return False
|
||
|
||
def load_environment_data(self, 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:
|
||
environment_data = json.load(f)
|
||
|
||
# 恢复时间
|
||
if 'time_of_day' in environment_data:
|
||
self.time_of_day = environment_data['time_of_day']
|
||
|
||
# 恢复季节
|
||
if 'current_season' in environment_data:
|
||
self.current_season = environment_data['current_season']
|
||
|
||
# 恢复天气条件
|
||
if 'weather_conditions' in environment_data:
|
||
self.weather_conditions = environment_data['weather_conditions']
|
||
|
||
# 恢复当前天气
|
||
if 'current_weather' in environment_data:
|
||
self.set_weather(environment_data['current_weather'], transition_time=0)
|
||
|
||
# 恢复光照
|
||
if 'lighting' in environment_data:
|
||
lighting = environment_data['lighting']
|
||
if 'ambient' in lighting and len(lighting['ambient']) == 4:
|
||
if 'ambient' in self.lighting_system:
|
||
light_node = self.lighting_system['ambient']['node']
|
||
light_node.setColor(Vec4(*lighting['ambient']))
|
||
if 'directional' in lighting and len(lighting['directional']) == 4:
|
||
if 'directional' in self.lighting_system:
|
||
light_node = self.lighting_system['directional']['node']
|
||
light_node.setColor(Vec4(*lighting['directional']))
|
||
if 'moon_enabled' in lighting:
|
||
if lighting['moon_enabled'] and not self.lighting_system['moon']['enabled']:
|
||
self.world.render.setLight(self.moon_light_np)
|
||
self.lighting_system['moon']['enabled'] = True
|
||
elif not lighting['moon_enabled'] and self.lighting_system['moon']['enabled']:
|
||
self.world.render.clearLight(self.moon_light_np)
|
||
self.lighting_system['moon']['enabled'] = False
|
||
|
||
# 恢复雾效
|
||
if 'fog' in environment_data:
|
||
fog_data = environment_data['fog']
|
||
if 'color' in fog_data and len(fog_data['color']) == 4:
|
||
self.fog.setColor(*fog_data['color'])
|
||
if 'density' in fog_data:
|
||
self.fog.setExpDensity(fog_data['density'])
|
||
|
||
# 恢复风效
|
||
if 'wind' in environment_data:
|
||
wind_data = environment_data['wind']
|
||
if 'strength' in wind_data:
|
||
self.wind_strength = wind_data['strength']
|
||
if 'vector' in wind_data and len(wind_data['vector']) == 3:
|
||
self.wind_vector = Vec3(*wind_data['vector'])
|
||
|
||
# 更新光照和天空
|
||
self._update_celestial_positions()
|
||
self._update_lighting_colors()
|
||
self._update_sky_color()
|
||
|
||
print(f"环境数据加载成功: {input_path}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"加载环境数据时出错: {e}")
|
||
return False
|
||
|
||
def set_weather_enabled(self, enabled):
|
||
"""
|
||
启用或禁用天气系统
|
||
"""
|
||
self.weather_enabled = enabled
|
||
print(f"天气系统已{'启用' if enabled else '禁用'}")
|
||
|
||
def clear_all_environment_effects(self):
|
||
"""
|
||
清除所有环境效果（增强版）
|
||
"""
|
||
try:
|
||
# 清除粒子效果
|
||
self._clear_particle_effects()
|
||
|
||
# 重置为晴天
|
||
self.set_weather('sunny', transition_time=0)
|
||
|
||
# 清除雾效
|
||
if self.fog:
|
||
self.fog.setExpDensity(0.0)
|
||
|
||
# 重置时间
|
||
self.set_time_of_day(12, 0)
|
||
|
||
# 重置季节
|
||
self.set_season('summer')
|
||
|
||
print("清除所有环境效果")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"清除所有环境效果时出错: {e}")
|
||
return False
|
||
|
||
def create_weather_zone(self, position, radius, weather_type, transition_time=2.0):
|
||
"""
|
||
创建局部天气区域（增强版）
|
||
"""
|
||
try:
|
||
# 创建局部天气区域
|
||
# 可以实现球形或盒形的局部天气效果
|
||
weather_zone = {
|
||
'position': position,
|
||
'radius': radius,
|
||
'weather_type': weather_type,
|
||
'transition_time': transition_time,
|
||
'node': None, # 可视化节点
|
||
'creation_time': self.world.globalClock.getFrameTime(),
|
||
'active': True
|
||
}
|
||
|
||
# 可以创建一个可视化表示
|
||
cm = CardMaker('weather_zone')
|
||
cm.setFrame(-radius, radius, -radius, radius)
|
||
zone_node = self.world.render.attachNewNode(cm.generate())
|
||
zone_node.setPos(position)
|
||
zone_node.setBin("fixed", 10)
|
||
zone_node.setDepthWrite(False)
|
||
zone_node.setDepthTest(False)
|
||
zone_node.setColor(1, 1, 1, 0.2) # 半透明
|
||
zone_node.hide() # 默认隐藏
|
||
|
||
weather_zone['node'] = zone_node
|
||
|
||
print(f"创建局部天气区域: {weather_type} at {position}")
|
||
return weather_zone
|
||
|
||
except Exception as e:
|
||
print(f"创建局部天气区域时出错: {e}")
|
||
return None
|
||
|
||
def add_weather_event(self, event_type, duration, intensity=1.0):
|
||
"""
|
||
添加天气事件（如突然的阵雨、雷暴等）
|
||
"""
|
||
try:
|
||
weather_event = {
|
||
'type': event_type,
|
||
'duration': duration,
|
||
'intensity': intensity,
|
||
'start_time': self.world.globalClock.getFrameTime(),
|
||
'active': True
|
||
}
|
||
|
||
# 根据事件类型应用效果
|
||
if event_type == 'sudden_rain':
|
||
# 增加雨天粒子效果
|
||
self._create_rain_effect()
|
||
elif event_type == 'thunderstorm':
|
||
# 增加闪电和雨天效果
|
||
self._create_lightning_effect()
|
||
self._create_rain_effect()
|
||
elif event_type == 'gust_of_wind':
|
||
# 增加风力
|
||
self.wind_strength *= (1.0 + intensity)
|
||
|
||
print(f"添加天气事件: {event_type}, 持续时间: {duration}秒")
|
||
return weather_event
|
||
|
||
except Exception as e:
|
||
print(f"添加天气事件时出错: {e}")
|
||
return None |