从HDRi到游戏画面：手把手教你用Blender和Python预处理IBL环境贴图（含代码）

# 清除默认场景 bpy.ops.wm.read_factory_settings(use_empty=True)

# 创建世界环境节点 world = bpy.data.worlds['World'] world.use_nodes = True nodes = world.node_tree.nodes

# 添加环境纹理节点 env_node = nodes.new('ShaderNodeTexEnvironment') env_node.image = bpy.data.images.load(hdri_path) world.node_tree.links.new( env_node.outputs['Color'], nodes['World Output'].inputs['Surface'] )

gamma_node = nodes.new('ShaderNodeGamma') gamma_node.inputs['Gamma'].default_value = 1.8 world.node_tree.links.new( env_node.outputs['Color'], gamma_node.inputs['Color'] )

# 添加映射节点控制投影 mapping_node = nodes.new('ShaderNodeMapping') mapping_node.inputs['Rotation'].default_value[2] = 0.25 # 旋转90度 world.node_tree.links.new( gamma_node.outputs['Color'], mapping_node.inputs['Vector'] )

u = 0.5 + atan2(z, x) / (2π) v = 0.5 - arcsin(y) / π

# 设置渲染引擎为Cycles bpy.context.scene.render.engine = 'CYCLES' bpy.context.scene.cycles.samples = 64

# 创建相机 rig cam = bpy.data.cameras.new("CubemapCamera") cam_obj = bpy.data.objects.new("CubemapCamera", cam) bpy.context.scene.collection.objects.link(cam_obj)

# 设置6个渲染方向 directions = [ ('posx', (90, 0, 90)), ('negx', (90, 0, -90)), ('posy', (0, 0, 0)), ('negy', (180, 0, 0)), ('posz', (90, 0, 180)), ('negz', (90, 0, 0)) ]

# 渲染各面并保存 output = {} for name, rot in directions: cam_obj.rotation_euler = [radians(r) for r in rot] bpy.context.scene.render.filepath = f"/tmp/{name}.exr" bpy.ops.render.render(write_still=True) output[name] = bpy.data.images.load(f"/tmp/{name}.exr")

return output

from math import pi, sin, cos

def generate_irradiance_map(cubemap_faces, size=32): """生成低分辨率辐照度图""" irradiance = {k: np.zeros((size, size, 3)) for k in cubemap_faces}

for face_name, face_data in cubemap_faces.items(): for i in range(size): for j in range(size): # 将像素坐标转换为方向向量 u = (i + 0.5) / size * 2 - 1 v = (j + 0.5) / size * 2 - 1

if face_name in ['posx', 'negx']: dir = np.array([1 if 'pos' in face_name else -1, -v, -u]) elif face_name in ['posy', 'negy']: dir = np.array([u, 1 if 'pos' in face_name else -1, v]) else: dir = np.array([u, -v, 1 if 'pos' in face_name else -1])

dir = dir / np.linalg.norm(dir)

# 余弦加权采样 irradiance[face_name][i,j] = sample_cubemap(dir, cubemap_faces)

return irradiance

def sample_cubemap(dir, cubemap_faces, samples=1024): """蒙特卡洛积分采样""" total = np.zeros(3) for _ in range(samples): # 余弦重要性采样 theta = np.arccos(np.sqrt(np.random.rand())) phi = 2 * pi * np.random.rand()

# 构建采样向量 x = sin(theta) * cos(phi) y = sin(theta) * sin(phi) z = cos(theta)

sample_dir = np.array([ dir[0] * x + dir[1] * y + dir[2] * z, dir[0] * y - dir[1] * x + dir[2] * z, dir[0] * z - dir[1] * y - dir[2] * x ])

# 获取采样颜色并加权 color = get_cubemap_pixel(sample_dir, cubemap_faces) weight = max(0, np.dot(dir, sample_dir)) total += color * weight

return total / samples

"""生成Mipmap链式预过滤图""" prefiltered = {}

for level in range(levels): size = base_size // (2 ** level) roughness = level / (levels - 1) prefiltered[level] = {k: np.zeros((size, size, 3)) for k in cubemap_faces}

for face_name in cubemap_faces: for i in range(size): for j in range(size): # 方向向量计算同上 dir = compute_face_direction(face_name, i, j, size)

# GGX重要性采样 prefiltered[level][face_name][i,j] = ggx_sample(dir, roughness, cubemap_faces)

return prefiltered

def ggx_sample(normal, roughness, cubemap_faces, samples=1024): """GGX重要性采样""" total = np.zeros(3) for _ in range(samples): # 生成GGX分布的半向量 alpha = roughness * roughness phi = 2 * pi * np.random.rand() cos_theta = np.sqrt((1 - np.random.rand()) / (1 + (alpha*alpha - 1) * np.random.rand())) sin_theta = np.sqrt(1 - cos_theta*cos_theta)

h = np.array([ sin_theta * cos(phi), sin_theta * sin(phi), cos_theta ])

# 转换到世界空间 up = np.array([0,0,1]) if abs(normal[2]) < 0.999 else np.array([1,0,0]) tangent = np.cross(up, normal) tangent = tangent / np.linalg.norm(tangent) bitangent = np.cross(normal, tangent)

h_world = tangent * h[0] + bitangent * h[1] + normal * h[2] h_world = h_world / np.linalg.norm(h_world)

# 计算反射向量 v = normal # 假设视角方向等于法线 l = 2 * np.dot(v, h_world) * h_world - v

# 采样并加权 n_dot_l = max(0, np.dot(normal, l)) if n_dot_l > 0: color = get_cubemap_pixel(l, cubemap_faces) total += color * n_dot_l

return total / samples

def parallel_process_face(args): face_name, face_data, size, roughness = args result = np.zeros((size, size, 3)) for i in range(size): for j in range(size): dir = compute_face_direction(face_name, i, j, size) result[i,j] = ggx_sample(dir, roughness, cubemap_faces) return face_name, result

def generate_prefiltered_parallel(cubemap_faces, size=512, levels=5): with Pool() as p: args = [(face, data, size//(2**level), level/(levels-1)) for level in range(levels) for face, data in cubemap_faces.items()] results = p.map(parallel_process_face, args)

# 重组结果 prefiltered = {} for level in range(levels): prefiltered[level] = {} for face in cubemap_faces: for r in results: if r[0] == face and r[2] == size//(2**level): prefiltered[level][face] = r[1] return prefiltered

with open(input_path, 'rb') as f: header = read_exr_header(f)

for y in range(0, header['height'], chunk_size): for x in range(0, header['width'], chunk_size): chunk = read_exr_chunk(f, x, y, min(chunk_size, header['width']-x), min(chunk_size, header['height']-y))

processed = process_chunk(chunk)

write_exr_chunk(output_path, x, y, processed)

1. 输入检测 → 2. 动态范围分析 → 3. 白平衡校正 → 4. Cubemap转换 → 5. 辐照度图生成 → 6. 预过滤图生成 → 7. 格式转换 → 8. 输出打包

from pathlib import Path

class IBLProcessor: def __init__(self, input_path, output_dir): self.input_path = Path(input_path) self.output_dir = Path(output_dir) self.temp_dir = self.output_dir / 'temp'

# 创建目录结构 self.temp_dir.mkdir(exist_ok=True) (self.output_dir / 'irradiance').mkdir(exist_ok=True) (self.output_dir / 'prefiltered').mkdir(exist_ok=True)

def run_pipeline(self): try: # 步骤1：HDRI预处理 self.preprocess_hdri()

# 步骤2：Cubemap转换 cubemap = self.generate_cubemap()

# 步骤3：IBL资源生成 self.generate_irradiance(cubemap) self.generate_prefiltered(cubemap)

# 步骤4：输出整理 self.package_output()

except Exception as e: print(f"处理失败: {str(e)}") self.cleanup() raise

self.cleanup() print("处理完成！

")

def preprocess_hdri(self): """执行动态范围调整、裁剪等操作""" print("预处理HDRI...") # 实现细节...

def generate_cubemap(self): """生成立方体贴图""" print("生成Cubemap...") # 实现细节... return cubemap_faces

def generate_irradiance(self, cubemap): """生成辐照度图""" print("生成辐照度图...") # 实现细节...

def generate_prefiltered(self, cubemap): """生成预过滤环境图""" print("生成预过滤环境图...") # 实现细节...

def package_output(self): """整理输出文件""" print("打包输出...") # 实现细节...

def cleanup(self): """清理临时文件""" # 实现细节...

if __name__ == "__main__": parser = argparse.ArgumentParser(description='IBL处理管线') parser.add_argument('input', help='输入HDRI文件路径') parser.add_argument('output', help='输出目录') parser.add_argument('--resolution', type=int, default=2048, help='基础分辨率（默认：2048）')

args = parser.parse_args()

processor = IBLProcessor(args.input, args.output) processor.run_pipeline()