AOV
Manager

# All three files sit in the same folder — import is always local.
import aov_config as cfg

# Presets, pass lists, and generator functions all come from cfg.
preset    = cfg.PRESETS["ocean"]
pipelines = cfg.PIPELINES     # ["Houdini / Mantra", "Houdini / Karma", "Unreal Engine 5"]
script    = cfg.generate_houdini_script(
    pipeline_idx    = 0,        # 0 = Mantra, 1 = Karma
    preset_key      = "ocean",
    project         = "HERO",
    layer           = "hero_layer",
    version         = 1,
    root            = "/renders",
    film_mode       = True,
    standard_states = {"beauty": True, "zdepth": True},
    custom_states   = {"caustics": True, "fog_vol": True},
)

# The shelf searches two locations — shared install first, then $HIP fallback.
import sys, os, importlib

search_paths = [
    os.path.join(hou.getenv("HOUDINI_USER_PREF_DIR"), "scripts", "python"),
    hou.getenv("HIP"),    # per-shot override: drop aov_config.py next to your .hip
]

cfg = None
for path in search_paths:
    candidate = os.path.join(path or "", "aov_config.py")
    if os.path.exists(candidate):
        if path not in sys.path:
            sys.path.insert(0, path)
        cfg = importlib.import_module("aov_config")
        break

if cfg is None:
    hou.ui.displayMessage(
        "aov_config.py not found.\n"
        "Place it in $HOUDINI_USER_PREF_DIR/scripts/python/ or next to your .hip file."
    )

# Every pass is a dict with renderer-specific technical data.
# One source of truth — both apps read from this at runtime.

{
    "id":         "zdepth",
    "label":      "Z-Depth",
    "default_on": True,
    "mantra": {
        "vm_variable": "Pz",          # VEX export to sample
        "vm_channel":  "zdepth",      # AOV output channel name
        "vm_vextype":  "float",
        "vm_pfilter":  "minmax min", # never blur depth
        "vm_quantize": "float32",    # full precision for depth
        "extra":       {},
        "custom_var":  False,
    },
    "karma": {
        "lpe":        "",             # no LPE — shader variable export
        "variable":   "z",
        "type":       "float",
        "light_group":"",             # set to e.g. "rim" once lights named
        "custom_var": False,
    },
    "ue5": {
        "pass_class":    "MoviePipelineImagePassBase",
        "deferred_only": True,
        "notes":         "Enable SceneDepth in Buffer Visualization.",
    },
}

# ── Z-Depth ──────────────────────────────────
aov_zdepth = rop.createNode('aov')
aov_zdepth.parm('vm_variable').set('Pz')
aov_zdepth.parm('vm_channel').set('zdepth')
aov_zdepth.parm('vm_vextype').set('float')
aov_zdepth.parm('vm_pfilter').set('minmax min')
aov_zdepth.parm('vm_quantize').set('float32')
aov_zdepth.parm('vm_filename').set(r'/renders/HERO/ocean/hero_layer/zdepth/HERO_hero_layer_ocean_zdepth_v001.$F4.exr')

# ── Caustics Pass ──────────────────────────────────
# ⚠ CUSTOM SHADER EXPORT: vm_variable='caustics' — replace with your actual VEX export name if different
aov_caustics = rop.createNode('aov')
aov_caustics.parm('vm_variable').set('caustics')
aov_caustics.parm('vm_channel').set('caustics')
aov_caustics.parm('vm_vextype').set('vector')
aov_caustics.parm('vm_pfilter').set('minmax median')
aov_caustics.parm('vm_quantize').set('float16')
aov_caustics.parm('vm_usecaustics').set(1)
aov_caustics.parm('vm_filename').set(r'/renders/HERO/ocean/hero_layer/caustics/HERO_hero_layer_ocean_caustics_v001.$F4.exr')

; ══ AOV Manager — UE5 Movie Render Queue ═════════════
; Preset    : 🌊 Ocean Mode
; Colorspace: ACES_ACEScg

[RenderPasses]
; Format: PassID=True  |  MRQ Class  |  Rendering mode
EnablePass_BEAUTY=True             ; MoviePipelineDeferredPassBase    |  ✓ Any mode
EnablePass_ZDEPTH=True             ; MoviePipelineImagePassBase       |  ⚠ Deferred only
EnablePass_CAUSTICS=True           ; MoviePipelineImagePassBase       |  ⚠ Deferred only
EnablePass_EMISSION2=True          ; MoviePipelineImagePassBase       |  ⚠ Deferred only

[PassSetupNotes]
; CAUSTICS:   No native caustics pass in UE5 MRQ. Use CustomDepthStencil on caustics decal actors.
; EMISSION2:  Enable Emissive in Buffer Visualization. Separate biolum actors onto a stencil layer.

; ⚠ DEFERRED RENDERING REQUIRED for some passes above.
; In MRQ: Add a 'Deferred Rendering' setting block.

# Collects all enabled pass dicts in order: standard first, then preset custom passes.
# standard_states / custom_states are {pass_id: bool} dicts from the UI card state.
def build_active_passes(preset_key, standard_states, custom_states):
    active = []
    for p in STANDARD_PASSES:
        if standard_states.get(p["id"], False):
            active.append(p)
    for p in PRESETS[preset_key]["passes"]:
        if custom_states.get(p["id"], True):
            active.append(p)
    return active   # list of full pass dicts — each has mantra / karma / ue5 blocks

# Called once per active pass. Returns a list of lines to append to the script.
# The custom_var flag adds a visible warning comment so the artist knows
# which vm_variable to swap for their own shader export.
def _gen_mantra_aov(p, folder, filename):
    m         = p["mantra"]
    pid       = p["id"]
    full_path = "{}/{}.$F4.exr".format(folder, filename)
    lines     = ["", "# -- {} --".format(p["label"])]

    if m["custom_var"]:
        lines.append(
            "# ⚠ CUSTOM SHADER EXPORT: vm_variable='{}' — replace with your actual VEX export"
            .format(m["vm_variable"])
        )

    lines += [
        "aov_{0} = rop.createNode('aov')".format(pid),
        "aov_{0}.parm('vm_variable').set('{1}')".format(pid, m["vm_variable"]),
        "aov_{0}.parm('vm_channel').set('{1}')" .format(pid, m["vm_channel"]),
        "aov_{0}.parm('vm_vextype').set('{1}')" .format(pid, m["vm_vextype"]),
        "aov_{0}.parm('vm_pfilter').set('{1}')" .format(pid, m["vm_pfilter"]),
        "aov_{0}.parm('vm_quantize').set('{1}')".format(pid, m["vm_quantize"]),
        "aov_{0}.parm('vm_filename').set(r'{1}')".format(pid, full_path),
    ]
    for parm, val in m["extra"].items():   # e.g. vm_usecaustics=1, vm_occlusionsamples=16
        lines.append("aov_{0}.parm('{1}').set({2})".format(pid, parm, val))
    return lines

# Tokens are resolved by simple string replacement — no regex, no templating engine.
# {frame} is the only token that varies by renderer.
def resolve_name(template, project, layer, pass_id, version, pipeline_idx=0):
    frame_token = "$F4" if pipeline_idx < 2 else "{frame_number}"
    return (template
        .replace("{project}", project)
        .replace("{layer}",   layer)
        .replace("{pass}",    pass_id)
        .replace("{version}", str(version).zfill(3))
        .replace("{date}",    datetime.date.today().strftime("%Y_%m_%d"))
        .replace("{frame}",   frame_token))

# Example resolution — Ocean preset, Mantra pipeline:
# "{project}_{layer}_ocean_{pass}_v{version}"
# → "HERO_hero_layer_ocean_caustics_v001"   (then appended with .$F4.exr)

{project}_{layer}_ocean_{pass}_v{version}
→ HERO_PROJECT_hero_layer_ocean_caustics_v001