417 lines
17 KiB
Python
417 lines
17 KiB
Python
"""
|
||
地形材质和纹理系统
|
||
提供完整的地形材质和纹理管理功能，支持多层纹理混合、程序化材质生成等高级功能
|
||
"""
|
||
|
||
import os
|
||
from panda3d.core import Material, Texture, TextureStage, Vec4, PNMImage, Filename
|
||
from panda3d.core import GeoMipTerrain, Shader, ShaderAttrib
|
||
|
||
class TerrainMaterials:
|
||
"""
|
||
地形材质和纹理系统类
|
||
提供完整的地形材质和纹理管理功能
|
||
"""
|
||
|
||
def __init__(self, world):
|
||
self.world = world
|
||
self.materials = {} # 存储材质
|
||
self.terrain_layers = {} # 存储地形图层信息
|
||
self.texture_atlases = {} # 存储纹理图集
|
||
|
||
def create_material(self, name, ambient=(0.5, 0.5, 0.5, 1.0),
|
||
diffuse=(0.8, 0.8, 0.8, 1.0),
|
||
specular=(0.2, 0.2, 0.2, 1.0),
|
||
shininess=5.0,
|
||
emissive=(0.0, 0.0, 0.0, 1.0)):
|
||
"""
|
||
创建新材质
|
||
"""
|
||
material = Material()
|
||
material.setName(name)
|
||
material.setAmbient(ambient)
|
||
material.setDiffuse(diffuse)
|
||
material.setSpecular(specular)
|
||
material.setShininess(shininess)
|
||
material.setEmission(emissive)
|
||
|
||
self.materials[name] = material
|
||
print(f"创建材质: {name}")
|
||
return material
|
||
|
||
def apply_material_to_terrain(self, terrain_node, material_name):
|
||
"""
|
||
为地形应用材质
|
||
"""
|
||
if material_name in self.materials:
|
||
material = self.materials[material_name]
|
||
terrain_node.setMaterial(material)
|
||
print(f"为地形应用材质: {material_name}")
|
||
return True
|
||
else:
|
||
print(f"材质 {material_name} 不存在")
|
||
return False
|
||
|
||
def load_texture(self, texture_path):
|
||
"""
|
||
加载纹理
|
||
"""
|
||
try:
|
||
# 检查文件是否存在
|
||
if not os.path.exists(texture_path):
|
||
print(f"纹理文件不存在: {texture_path}")
|
||
return None
|
||
|
||
texture = self.world.loader.loadTexture(texture_path)
|
||
if texture:
|
||
print(f"纹理加载成功: {texture_path}")
|
||
return texture
|
||
else:
|
||
print(f"纹理加载失败: {texture_path}")
|
||
return None
|
||
except Exception as e:
|
||
print(f"加载纹理时出错: {e}")
|
||
return None
|
||
|
||
def apply_texture_to_terrain(self, terrain_node, texture_path, texture_stage_name="diffuse"):
|
||
"""
|
||
为地形应用纹理
|
||
"""
|
||
texture = self.load_texture(texture_path)
|
||
if texture:
|
||
# 创建纹理阶段
|
||
texture_stage = TextureStage(texture_stage_name)
|
||
# 应用纹理到地形
|
||
terrain_node.setTexture(texture_stage, texture)
|
||
print(f"为地形应用纹理: {texture_path}")
|
||
return True
|
||
return False
|
||
|
||
def apply_multi_texture_to_terrain(self, terrain_node, texture_paths, blend_factors=None):
|
||
"""
|
||
为地形应用多纹理混合
|
||
texture_paths: 纹理路径列表
|
||
blend_factors: 混合因子列表，控制每个纹理的混合权重
|
||
"""
|
||
if not texture_paths:
|
||
print("纹理路径列表为空")
|
||
return False
|
||
|
||
# 如果没有提供混合因子，使用默认值
|
||
if blend_factors is None:
|
||
blend_factors = [1.0] * len(texture_paths)
|
||
|
||
# 确保混合因子数量与纹理数量一致
|
||
if len(blend_factors) != len(texture_paths):
|
||
print("混合因子数量与纹理数量不匹配")
|
||
return False
|
||
|
||
# 应用每个纹理
|
||
for i, (texture_path, blend_factor) in enumerate(zip(texture_paths, blend_factors)):
|
||
texture = self.load_texture(texture_path)
|
||
if texture:
|
||
# 为每个纹理创建不同的纹理阶段
|
||
texture_stage = TextureStage(f"texture_{i}")
|
||
texture_stage.setSort(i) # 设置排序
|
||
|
||
# 应用纹理
|
||
terrain_node.setTexture(texture_stage, texture)
|
||
|
||
# 如果支持，设置混合因子
|
||
if hasattr(texture_stage, 'setBlendFactor'):
|
||
texture_stage.setBlendFactor(blend_factor)
|
||
|
||
print(f"为地形应用 {len(texture_paths)} 个多纹理混合")
|
||
return True
|
||
|
||
def create_terrain_layer_system(self, terrain_node, layer_configs):
|
||
"""
|
||
创建地形图层系统
|
||
layer_configs: 图层配置列表，每个配置包含纹理路径、混合贴图等信息
|
||
"""
|
||
try:
|
||
# 清除现有的地形纹理
|
||
terrain_node.clearTexture()
|
||
|
||
# 为每个图层创建纹理阶段
|
||
for i, layer_config in enumerate(layer_configs):
|
||
# 加载漫反射纹理
|
||
if 'diffuse' in layer_config:
|
||
diffuse_texture = self.load_texture(layer_config['diffuse'])
|
||
if diffuse_texture:
|
||
diffuse_stage = TextureStage(f"diffuse_{i}")
|
||
diffuse_stage.setSort(i * 10) # 设置排序
|
||
terrain_node.setTexture(diffuse_stage, diffuse_texture)
|
||
|
||
# 加载法线纹理
|
||
if 'normal' in layer_config:
|
||
normal_texture = self.load_texture(layer_config['normal'])
|
||
if normal_texture:
|
||
normal_stage = TextureStage(f"normal_{i}")
|
||
normal_stage.setMode(TextureStage.M_normal) # 设置为法线贴图模式
|
||
normal_stage.setSort(i * 10 + 1)
|
||
terrain_node.setTexture(normal_stage, normal_texture)
|
||
|
||
# 加载混合纹理（控制图层混合）
|
||
if 'blend' in layer_config:
|
||
blend_texture = self.load_texture(layer_config['blend'])
|
||
if blend_texture:
|
||
blend_stage = TextureStage(f"blend_{i}")
|
||
blend_stage.setMode(TextureStage.M_blend) # 设置为混合模式
|
||
blend_stage.setSort(i * 10 + 2)
|
||
terrain_node.setTexture(blend_stage, blend_texture)
|
||
|
||
# 保存图层信息
|
||
self.terrain_layers[terrain_node] = layer_configs
|
||
|
||
print(f"为地形创建 {len(layer_configs)} 个图层系统")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"创建地形图层系统时出错: {e}")
|
||
return False
|
||
|
||
def update_terrain_layer(self, terrain_node, layer_index, layer_config):
|
||
"""
|
||
更新地形图层
|
||
"""
|
||
if terrain_node not in self.terrain_layers:
|
||
print("地形没有图层系统")
|
||
return False
|
||
|
||
if layer_index >= len(self.terrain_layers[terrain_node]):
|
||
print("图层索引超出范围")
|
||
return False
|
||
|
||
# 更新图层配置
|
||
self.terrain_layers[terrain_node][layer_index] = layer_config
|
||
|
||
# 重新应用纹理
|
||
return self.create_terrain_layer_system(terrain_node, self.terrain_layers[terrain_node])
|
||
|
||
def create_procedural_terrain_material(self, terrain_node,
|
||
base_color=(0.5, 0.6, 0.3, 1.0),
|
||
roughness=0.8,
|
||
metallic=0.1,
|
||
uv_scale=(1.0, 1.0),
|
||
use_normal_map=True):
|
||
"""
|
||
创建程序化地形材质
|
||
"""
|
||
try:
|
||
# 创建基础材质
|
||
material = Material()
|
||
material.setName(f"procedural_terrain_{id(terrain_node)}")
|
||
material.setBaseColor(base_color)
|
||
material.setRoughness(roughness)
|
||
material.setMetallic(metallic)
|
||
|
||
# 应用材质
|
||
terrain_node.setMaterial(material)
|
||
|
||
# 如果使用RenderPipeline，可以应用PBR效果
|
||
if hasattr(self.world, 'render_pipeline'):
|
||
try:
|
||
effect_options = {
|
||
"normal_mapping": use_normal_map,
|
||
"parallax_mapping": False,
|
||
"uv_scale": uv_scale
|
||
}
|
||
|
||
self.world.render_pipeline.set_effect(
|
||
terrain_node,
|
||
"effects/terrain.yaml", # 假设有专门的地形效果文件
|
||
effect_options,
|
||
10 # 排序值
|
||
)
|
||
print("应用PBR地形效果")
|
||
except Exception as e:
|
||
print(f"应用PBR效果失败: {e}")
|
||
|
||
self.materials[material.getName()] = material
|
||
print(f"创建程序化地形材质: {material.getName()}")
|
||
return material
|
||
|
||
except Exception as e:
|
||
print(f"创建程序化地形材质时出错: {e}")
|
||
return None
|
||
|
||
def create_texture_atlas(self, atlas_name, texture_paths, atlas_size=(1024, 1024)):
|
||
"""
|
||
创建纹理图集
|
||
"""
|
||
try:
|
||
# 创建新的PNMImage作为图集
|
||
atlas_image = PNMImage(atlas_size[0], atlas_size[1])
|
||
atlas_image.fill(0, 0, 0) # 填充黑色背景
|
||
|
||
# 计算每个纹理在图集中的位置
|
||
num_textures = len(texture_paths)
|
||
grid_size = int(math.ceil(math.sqrt(num_textures)))
|
||
tile_width = atlas_size[0] // grid_size
|
||
tile_height = atlas_size[1] // grid_size
|
||
|
||
# 存储纹理坐标信息
|
||
texture_coords = {}
|
||
|
||
# 将每个纹理复制到图集中
|
||
for i, texture_path in enumerate(texture_paths):
|
||
if not os.path.exists(texture_path):
|
||
print(f"纹理文件不存在: {texture_path}")
|
||
continue
|
||
|
||
# 加载纹理图像
|
||
texture_image = PNMImage(Filename.fromOsSpecific(texture_path))
|
||
if texture_image.empty():
|
||
print(f"无法加载纹理图像: {texture_path}")
|
||
continue
|
||
|
||
# 计算在图集中的位置
|
||
row = i // grid_size
|
||
col = i % grid_size
|
||
x_offset = col * tile_width
|
||
y_offset = row * tile_height
|
||
|
||
# 将纹理复制到图集
|
||
atlas_image.blendSubImage(texture_image, x_offset, y_offset, 0, 0,
|
||
min(tile_width, texture_image.getXSize()),
|
||
min(tile_height, texture_image.getYSize()))
|
||
|
||
# 计算纹理坐标
|
||
u0 = x_offset / atlas_size[0]
|
||
v0 = y_offset / atlas_size[1]
|
||
u1 = (x_offset + tile_width) / atlas_size[0]
|
||
v1 = (y_offset + tile_height) / atlas_size[1]
|
||
|
||
texture_coords[os.path.basename(texture_path)] = (u0, v0, u1, v1)
|
||
|
||
# 保存图集到临时文件
|
||
temp_path = f"/tmp/{atlas_name}_atlas.png"
|
||
atlas_image.write(Filename.fromOsSpecific(temp_path))
|
||
|
||
# 加载图集纹理
|
||
atlas_texture = self.world.loader.loadTexture(temp_path)
|
||
if atlas_texture:
|
||
self.texture_atlases[atlas_name] = {
|
||
'texture': atlas_texture,
|
||
'coords': texture_coords,
|
||
'size': atlas_size
|
||
}
|
||
print(f"创建纹理图集: {atlas_name}")
|
||
return atlas_texture
|
||
|
||
except Exception as e:
|
||
print(f"创建纹理图集时出错: {e}")
|
||
return None
|
||
|
||
def apply_texture_atlas_to_terrain(self, terrain_node, atlas_name, texture_name):
|
||
"""
|
||
为地形应用纹理图集中的特定纹理
|
||
"""
|
||
if atlas_name not in self.texture_atlases:
|
||
print(f"纹理图集 {atlas_name} 不存在")
|
||
return False
|
||
|
||
atlas_info = self.texture_atlases[atlas_name]
|
||
if texture_name not in atlas_info['coords']:
|
||
print(f"纹理 {texture_name} 不在图集中")
|
||
return False
|
||
|
||
# 应用图集纹理
|
||
texture_stage = TextureStage("atlas_diffuse")
|
||
terrain_node.setTexture(texture_stage, atlas_info['texture'])
|
||
|
||
# 设置纹理坐标偏移（需要着色器支持）
|
||
coords = atlas_info['coords'][texture_name]
|
||
print(f"应用纹理图集 {atlas_name} 中的 {texture_name}")
|
||
return True
|
||
|
||
def update_material_property(self, material_name, property_name, value):
|
||
"""
|
||
更新材质属性
|
||
"""
|
||
if material_name in self.materials:
|
||
material = self.materials[material_name]
|
||
setter_name = f'set{property_name.capitalize()}'
|
||
if hasattr(material, setter_name):
|
||
# 特殊处理某些属性
|
||
if property_name in ['ambient', 'diffuse', 'specular', 'emission'] and isinstance(value, (list, tuple)):
|
||
getattr(material, setter_name)(Vec4(*value))
|
||
else:
|
||
getattr(material, setter_name)(value)
|
||
print(f"更新材质 {material_name} 的属性 {property_name} 为 {value}")
|
||
return True
|
||
print(f"无法更新材质 {material_name} 的属性 {property_name}")
|
||
return False
|
||
|
||
def get_material_info(self, material_name):
|
||
"""
|
||
获取材质信息
|
||
"""
|
||
if material_name in self.materials:
|
||
material = self.materials[material_name]
|
||
return {
|
||
"name": material.getName(),
|
||
"ambient": material.getAmbient(),
|
||
"diffuse": material.getDiffuse(),
|
||
"specular": material.getSpecular(),
|
||
"shininess": material.getShininess(),
|
||
"emissive": material.getEmission()
|
||
}
|
||
return None
|
||
|
||
def create_splatting_material(self, terrain_node, splat_map_path, texture_paths):
|
||
"""
|
||
创建地形分层混合材质（Splating）
|
||
splat_map_path: 控制混合的灰度图路径
|
||
texture_paths: 纹理路径列表（通常4个：R、G、B、A通道分别控制）
|
||
"""
|
||
try:
|
||
# 加载混合图
|
||
splat_texture = self.load_texture(splat_map_path)
|
||
if not splat_texture:
|
||
print("无法加载混合图")
|
||
return False
|
||
|
||
# 加载纹理图集
|
||
for i, texture_path in enumerate(texture_paths):
|
||
texture = self.load_texture(texture_path)
|
||
if texture:
|
||
texture_stage = TextureStage(f"splat_texture_{i}")
|
||
texture_stage.setSort(i)
|
||
terrain_node.setTexture(texture_stage, texture)
|
||
|
||
# 应用混合图
|
||
splat_stage = TextureStage("splat_map")
|
||
splat_stage.setMode(TextureStage.M_blend)
|
||
terrain_node.setTexture(splat_stage, splat_texture)
|
||
|
||
print(f"创建分层混合材质，使用 {len(texture_paths)} 个纹理")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"创建分层混合材质时出错: {e}")
|
||
return False
|
||
|
||
def apply_terrain_shader(self, terrain_node, shader_path, shader_params=None):
|
||
"""
|
||
为地形应用自定义着色器
|
||
"""
|
||
try:
|
||
# 加载着色器
|
||
shader = Shader.load(Shader.SL_GLSL, shader_path + ".vert", shader_path + ".frag")
|
||
|
||
# 应用着色器
|
||
terrain_node.setShader(shader)
|
||
|
||
# 设置着色器参数
|
||
if shader_params:
|
||
for param_name, param_value in shader_params.items():
|
||
terrain_node.setShaderInput(param_name, param_value)
|
||
|
||
print(f"为地形应用着色器: {shader_path}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"应用着色器时出错: {e}")
|
||
return False |