render_preview.py

# render_preview.py — 병합된 최종 캐릭터의 정면을 렌더
# 명령어: blender --background --python render_preview.py -- <glb_path> <out_png>

import bpy
import sys
import os
import math
from mathutils import Vector

def log(msg):
    print(f"[RENDER] {msg}", flush=True)

# -------------------- Args --------------------
argv = sys.argv
argv = argv[argv.index("--") + 1:] if "--" in argv else []
if len(argv) < 2:
    print("Usage: blender --background --python render_preview.py -- <glb_path> <out_png>")
    sys.exit(1)

glb_path, out_png = argv[:2]
glb_path = os.path.abspath(glb_path)
out_png = os.path.abspath(out_png)

# 출력 폴더가 없으면 생성
out_dir = os.path.dirname(out_png)
if out_dir and not os.path.exists(out_dir):
    os.makedirs(out_dir, exist_ok=True)

# -------------------- Reset scene --------------------
bpy.ops.wm.read_factory_settings(use_empty=True)
try:
    bpy.data.orphans_purge(do_recursive=True)
except Exception:
    pass

scn = bpy.context.scene

# 해상도 먼저 지정(카메라 FOV 계산에 영향을 줌)
scn.render.resolution_x = 1536
scn.render.resolution_y = 1536
scn.render.resolution_percentage = 100

# -------------------- Import GLB --------------------
log(f"IMPORT {glb_path}")
bpy.ops.import_scene.gltf(filepath=glb_path, loglevel=0)
objs = list(bpy.context.scene.objects)
log(f"IMPORTED objects={len(objs)}")

# -------------------- Camera --------------------
cam_data = bpy.data.cameras.new("Camera")
cam = bpy.data.objects.new("Camera", cam_data)
bpy.context.scene.collection.objects.link(cam)
bpy.context.scene.camera = cam

# 카메라 기본값
cam.data.type = 'PERSP'
cam.data.lens = 35
cam.data.sensor_fit = 'VERTICAL'
cam.data.dof.use_dof = False
cam.location = (0.0, -3.0, 1.5)
cam.rotation_euler = (1.47, 0.0, 0.0)

# --- 자동 전신 프레이밍 ---
def frame_objects_full_body(cam_obj, objs, margin=1.07, elev_deg=17):
    meshes = [o for o in objs if o.type == 'MESH']
    if not meshes:
        return None

    mins = Vector((1e9, 1e9, 1e9))
    maxs = Vector((-1e9, -1e9, -1e9))
    for o in meshes:
        try:
            bb = o.bound_box
        except Exception:
            continue
        for v in bb:
            vw = o.matrix_world @ Vector(v)
            mins.x = min(mins.x, vw.x); mins.y = min(mins.y, vw.y); mins.z = min(mins.z, vw.z)
            maxs.x = max(maxs.x, vw.x); maxs.y = max(maxs.y, vw.y); maxs.z = max(maxs.z, vw.z)

    center = (mins + maxs) * 0.5
    size   = maxs - mins
    width, height = size.x, size.z

    # 카메라 FOV (렌즈/센서/해상도에 의존)
    fov_y = cam_obj.data.angle_y
    fov_x = cam_obj.data.angle_x

    dist_v = (height * margin * 0.5) / math.tan(fov_y * 0.5)
    dist_h = (width  * margin * 0.5) / math.tan(fov_x * 0.5)
    dist = max(dist_v, dist_h)

    phi = math.radians(max(0.0, min(30.0, elev_deg)))  # 0~30°
    dy = math.cos(phi) * dist
    dz = math.sin(phi) * dist

    cam_obj.location = (center.x, center.y - dy, center.z + dz)
    direction = (center - cam_obj.location).normalized()
    cam_obj.rotation_euler = direction.to_track_quat('-Z', 'Y').to_euler()

    safety = 1.0 + 0.002 * max(0.0, elev_deg - 10.0)
    return {"center": center, "dist": dist * safety, "width": width, "height": height}

info = frame_objects_full_body(cam, objs, margin=1.07, elev_deg=17)
log(f"FRAME {info}")

# -------------------- Lighting --------------------
def look_at(obj, target_vec):
    direction = (target_vec - obj.location).normalized()
    obj.rotation_euler = direction.to_track_quat('-Z', 'Y').to_euler()

# 메인 AREA 라이트
key_data = bpy.data.lights.new(name="KeyLight", type='AREA')
key = bpy.data.objects.new("KeyLight", key_data)
bpy.context.collection.objects.link(key)

if info:
    c = info["center"]; d = info["dist"]; h = info["height"]
    key.location = (c.x, c.y - d * 0.55, c.z + h * 0.05)
else:
    key.location = (0.0, -2.0, 1.6)

key.data.size = 2.2
key.data.energy = 180
look_at(key, info["center"] if info else Vector((0.0, 0.0, 1.5)))

# 보조 AREA 라이트 (좌/우)
for sign in (-1, 1):
    side_data = bpy.data.lights.new(name=f"SideLight_{sign}", type='AREA')
    side = bpy.data.objects.new(f"SideLight_{sign}", side_data)
    bpy.context.collection.objects.link(side)
    if info:
        c = info["center"]; d = info["dist"]; h = info["height"]; w = info["width"]
        side.location = (c.x + sign * (w * 0.55), c.y - d * 0.6, c.z + h * 0.05)
    else:
        side.location = (sign * 1.5, -2.0, 1.6)
    side.data.size = 1.6
    side.data.energy = 40
    look_at(side, info["center"] if info else Vector((0.0, 0.0, 1.5)))

# -------------------- Eevee Render --------------------
log("CONFIGURE EEVEE")
scn.render.engine = 'BLENDER_EEVEE'        # Eevee (GPU)
scn.eevee.taa_samples = 8                   # viewport TAA (참고)
scn.eevee.taa_render_samples = 16           # 렌더 샘플 (속도↑)
scn.eevee.use_bloom = False
scn.eevee.use_ssr = False                   # 반사 트레이싱 끔(속도↑)
scn.eevee.use_ssr_refraction = False
scn.eevee.use_gtao = True                   # 적당히 깊이감
scn.eevee.use_soft_shadows = True

# 투명 배경 + RGBA
scn.render.film_transparent = True
scn.render.image_settings.file_format = 'PNG'
scn.render.image_settings.color_mode = 'RGBA'
scn.render.image_settings.color_depth = '8'

# 컬러 매니지먼트
scn.view_settings.view_transform = 'Filmic'
scn.view_settings.look = 'None'
scn.view_settings.exposure = 0.0
scn.view_settings.gamma = 1.0

# 월드(배경 색은 조명에 영향, 화면에는 투명 처리됨)
if scn.world is None:
    scn.world = bpy.data.worlds.new("World")
scn.world.use_nodes = True
bg = scn.world.node_tree.nodes.get("Background")
if not bg:
    bg = scn.world.node_tree.nodes.new("ShaderNodeBackground")
bg.inputs[0].default_value = (0.12, 0.12, 0.12, 1.0)  # 약한 회색빛
bg.inputs[1].default_value = 0.2

# 출력 경로: *_rgba.png (메인 파이프라인 호환)
root, _ = os.path.splitext(out_png)
tmp_png = root + "_rgba.png"
scn.render.filepath = tmp_png

# -------------------- Render --------------------
log("RENDER BEGIN (Eevee)")
bpy.ops.render.render(write_still=True)
log(f"RENDER DONE -> {tmp_png}")

if not os.path.isfile(tmp_png):
    print(f"[render_preview] Failed: {tmp_png} not created.")
    sys.exit(2)

print(f"[render_preview] Transparent RGBA saved at: {tmp_png}")