scripts/render_protocol.py

"""Render protocol for Zer0pa key-visual cards.

Locked after the XR orientation diagnosis. Every lane goes through this module
so the conventions don't drift.

USAGE (in a per-lane script):
    from render_protocol import (
        clean_scene, load_hbm_object, center_and_orient,
        add_wireframe_material, setup_world, setup_camera, render_2x,
        verify_orientation, OUT_W, OUT_H, W2X, H2X,
    )
"""
import bpy
import math


# ----- canonical output -----
OUT_W, OUT_H = 572, 534
W2X, H2X = OUT_W * 2, OUT_H * 2   # 1144 x 1068

# ----- canonical colors -----
BG = (10/255, 10/255, 10/255, 1.0)       # near-black card background
WIRE_COLOR = (0.86, 0.87, 0.89, 1.0)     # off-white wires (matches v6 palette)
FILL_COLOR = (10/255, 10/255, 10/255, 1.0)  # same as BG; fill is occluder only


# ----- helpers -----
def clean_scene():
    bpy.ops.wm.read_factory_settings(use_empty=True)
    return bpy.context.scene


def load_hbm_collection(bundle_path, collection_name):
    """Load a whole collection (e.g., 'Skeleton - Realistic') from a Blender
    Studio bundle. Returns the linked collection and list of mesh objects."""
    with bpy.data.libraries.load(bundle_path, link=False) as (df, dt):
        if collection_name not in df.collections:
            raise RuntimeError(f"collection '{collection_name}' not in bundle\nAvailable: {df.collections}")
        dt.collections = [collection_name]
    col = dt.collections[0]
    bpy.context.scene.collection.children.link(col)
    mesh_objs = [o for o in col.all_objects if o.type == 'MESH']
    return col, mesh_objs


def collection_world_bbox(mesh_objs):
    """Compute world-space bbox over a list of mesh objects (post-deps eval)."""
    bpy.context.view_layer.update()
    deps = bpy.context.evaluated_depsgraph_get()
    mins = [float('inf')] * 3
    maxs = [float('-inf')] * 3
    for obj in mesh_objs:
        eo = obj.evaluated_get(deps)
        em = eo.to_mesh()
        for v in em.vertices:
            w = eo.matrix_world @ v.co
            for i, c in enumerate((w.x, w.y, w.z)):
                if c < mins[i]: mins[i] = c
                if c > maxs[i]: maxs[i] = c
        eo.to_mesh_clear()
    return tuple((mins[i], maxs[i]) for i in range(3))


def shift_collection(mesh_objs, dx, dy, dz):
    """Shift every mesh object in the collection by the same offset."""
    for o in mesh_objs:
        o.location.x += dx; o.location.y += dy; o.location.z += dz
    bpy.context.view_layer.update()


def load_hbm_object(bundle_path, object_name):
    """Load one object from a Blender Studio asset bundle.
    RESETS its source-bundle transform — bundle objects are pre-placed."""
    with bpy.data.libraries.load(bundle_path, link=False) as (df, dt):
        if object_name not in df.objects:
            raise RuntimeError(f"'{object_name}' not in {bundle_path}\nAvailable: {df.objects}")
        dt.objects = [object_name]
    obj = dt.objects[0]
    bpy.context.scene.collection.objects.link(obj)
    obj.location = (0, 0, 0)
    obj.rotation_euler = (0, 0, 0)
    obj.scale = (1, 1, 1)
    obj.hide_render = False
    obj.hide_viewport = False
    return obj


def center_and_orient(obj, x_flip=False, rotate_euler=(0, 0, 0)):
    """Shift mesh verts so centroid sits at object origin, then apply rotation.
    Returns world-space bbox AFTER the transforms (verified via depsgraph).

    `x_flip`: True for mirror-paired second instance (e.g. left vs right hand).
    `rotate_euler`: degrees, applied around object origin.
    """
    co = [v.co for v in obj.data.vertices]
    cx = (min(c.x for c in co) + max(c.x for c in co)) / 2
    cy = (min(c.y for c in co) + max(c.y for c in co)) / 2
    cz = (min(c.z for c in co) + max(c.z for c in co)) / 2
    for v in obj.data.vertices:
        v.co.x -= cx
        v.co.y -= cy
        v.co.z -= cz
    obj.data.update()

    obj.rotation_euler = tuple(math.radians(d) for d in rotate_euler)
    if x_flip:
        obj.scale = (-1, 1, 1)

    bpy.context.view_layer.update()
    deps = bpy.context.evaluated_depsgraph_get()
    eo = obj.evaluated_get(deps)
    em = eo.to_mesh()
    cw = [eo.matrix_world @ v.co for v in em.vertices]
    bbox = (
        (min(c.x for c in cw), max(c.x for c in cw)),
        (min(c.y for c in cw), max(c.y for c in cw)),
        (min(c.z for c in cw), max(c.z for c in cw)),
    )
    eo.to_mesh_clear()
    return bbox


def add_wireframe(obj, thickness_factor=0.004):
    """Duplicate obj, add Wireframe modifier with white emission. Returns the
    wire object. Inherits obj's world matrix so it works for parented objects."""
    # Force depsgraph update so obj.matrix_world reflects any just-set transform
    bpy.context.view_layer.update()
    wm = obj.data.copy()
    wire = bpy.data.objects.new(obj.name + "_wire", wm)
    bpy.context.scene.collection.objects.link(wire)
    # Mirror full world matrix so parented bones land correctly
    wire.matrix_world = obj.matrix_world.copy()

    # mesh span for thickness
    co = [v.co for v in wm.vertices]
    span = max(
        max(c.x for c in co) - min(c.x for c in co),
        max(c.y for c in co) - min(c.y for c in co),
        max(c.z for c in co) - min(c.z for c in co),
    )
    wf = wire.modifiers.new("WF", 'WIREFRAME')
    wf.thickness = span * thickness_factor
    wf.use_replace = True
    wf.use_even_offset = True
    wf.use_boundary = True
    wf.offset = 1.0   # push outward

    mat = bpy.data.materials.new(obj.name + "_wmat"); mat.use_nodes = True
    nt = mat.node_tree
    for n in list(nt.nodes): nt.nodes.remove(n)
    out = nt.nodes.new("ShaderNodeOutputMaterial")
    emi = nt.nodes.new("ShaderNodeEmission")
    emi.inputs["Color"].default_value = WIRE_COLOR
    emi.inputs["Strength"].default_value = 2.5
    nt.links.new(emi.outputs[0], out.inputs[0])
    wire.data.materials.clear(); wire.data.materials.append(mat)

    return wire


def hide_fill(obj):
    """Hide the fill mesh entirely. Used when wireframe is sufficient
    visual on its own (cleaner, no z-fighting risk)."""
    obj.hide_render = True


def set_fill_as_occluder(obj, shrink=0.985):
    """Configure the original mesh as a dark-fill occluder that hides
    back-of-mesh wireframe edges from showing through the front.

    Scales the fill slightly smaller than the wireframe so it sits just
    inside the wire tubes without z-fighting. shrink=0.985 = 1.5% smaller.
    """
    # Apply shrink as object scale (works regardless of fill's existing scale.x sign for mirror)
    sx, sy, sz = obj.scale.x, obj.scale.y, obj.scale.z
    obj.scale = (sx * shrink, sy * shrink, sz * shrink)

    mat = bpy.data.materials.new(obj.name + "_fmat"); mat.use_nodes = True
    nt = mat.node_tree
    for n in list(nt.nodes): nt.nodes.remove(n)
    out = nt.nodes.new("ShaderNodeOutputMaterial")
    emi = nt.nodes.new("ShaderNodeEmission")
    emi.inputs["Color"].default_value = BG
    emi.inputs["Strength"].default_value = 1.0
    nt.links.new(emi.outputs[0], out.inputs[0])
    obj.data.materials.clear(); obj.data.materials.append(mat)
    obj.hide_render = False
    obj.hide_viewport = False


def setup_world():
    w = bpy.data.worlds.new("CardWorld"); w.use_nodes = True
    nt = w.node_tree
    for n in list(nt.nodes): nt.nodes.remove(n)
    out = nt.nodes.new("ShaderNodeOutputWorld")
    bg = nt.nodes.new("ShaderNodeBackground")
    bg.inputs["Color"].default_value = BG
    bg.inputs["Strength"].default_value = 1.0
    nt.links.new(bg.outputs[0], out.inputs[0])
    bpy.context.scene.world = w


def setup_camera(target_xyz, distance, lens=50):
    scene = bpy.context.scene
    target = bpy.data.objects.new("Target", None)
    target.location = target_xyz
    scene.collection.objects.link(target)

    cam_data = bpy.data.cameras.new("Cam")
    cam_data.lens = lens
    cam_data.clip_start = 0.001
    cam_data.clip_end = 100
    cam = bpy.data.objects.new("Cam", cam_data)
    scene.collection.objects.link(cam)
    cam.location = (target_xyz[0], target_xyz[1] - distance, target_xyz[2])
    trk = cam.constraints.new('TRACK_TO')
    trk.target = target
    trk.track_axis = 'TRACK_NEGATIVE_Z'
    trk.up_axis = 'UP_Y'
    scene.camera = cam
    return cam, target


def frame_distance_for_width(width, lens=50, sensor=36, margin=1.20):
    """Camera Y-distance needed so a horizontal extent of `width` (m) fits in
    frame with `margin` (1.0 = exact fit, 1.20 = 20% margin)."""
    half_fov = math.atan((sensor/2) / lens)
    return (width / 2) / math.tan(half_fov) * margin


def render_2x(out_path):
    scene = bpy.context.scene
    scene.render.engine = 'BLENDER_EEVEE_NEXT'
    scene.render.resolution_x = W2X
    scene.render.resolution_y = H2X
    scene.render.image_settings.file_format = 'PNG'
    scene.render.image_settings.color_mode = 'RGB'
    scene.render.filepath = out_path
    scene.render.film_transparent = False
    scene.view_settings.view_transform = 'Raw'
    scene.view_settings.look = 'None'
    scene.view_settings.exposure = 0.0
    scene.view_settings.gamma = 1.0
    bpy.ops.render.render(write_still=True)