agentvfx 0.0.0-stage → 0.3.4

package/skills/agentvfx/plates/terminalcore/materials.py

@@ -0,0 +1,170 @@
+"""Procedural PBR materials: board-formed concrete, polished floor, plastics, steel, rubber, LEDs, CRT glass+phosphor."""
+import math as pymath
+
+from nodekit import fresh, finish, math, remap, mix, vmath, rgb, principled, node
+
+
+def _ao(nt, dist=0.08):
+    return node(nt, "ShaderNodeAmbientOcclusion", {"Distance": dist}, samples=4).outputs["AO"]
+
+
+def _position_axes(nt):
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    sep = node(nt, "ShaderNodeSeparateXYZ", {"Vector": pos})
+    horiz = math(nt, "ADD", sep.outputs["X"], sep.outputs["Y"])
+    return pos, horiz, sep.outputs["Z"], sep.outputs["X"], sep.outputs["Y"]
+
+
+def concrete(name="concrete", polished=False, tone=0.16):
+    m, nt = fresh(name)
+    pos, h, z, x, y = _position_axes(nt)
+    along = y if polished else h
+    across = x if polished else z
+    patches = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 0.7), "Detail": 8.0, "Roughness": 0.62}).outputs["Fac"]
+    fine = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 70.0), "Detail": 6.0, "Roughness": 0.7}).outputs["Fac"]
+    pores = node(nt, "ShaderNodeTexVoronoi", {"Vector": vmath(nt, "SCALE", pos, 38.0)}, feature="F1").outputs["Distance"]
+    streak_in = node(nt, "ShaderNodeCombineXYZ", {"X": math(nt, "MULTIPLY", along, 6.0), "Y": 0.0, "Z": math(nt, "MULTIPLY", across, 0.5)})
+    streaks = node(nt, "ShaderNodeTexNoise", {"Vector": streak_in.outputs[0], "Detail": 5.0}).outputs["Fac"]
+    board_s = math(nt, "DIVIDE", across, 0.32)
+    board_fr = math(nt, "FRACT", board_s)
+    board_id = math(nt, "FLOOR", board_s)
+    board_rnd = node(nt, "ShaderNodeTexWhiteNoise", {"W": board_id}, noise_dimensions="1D").outputs["Value"]
+    groove = remap(nt, board_fr, 0.0, 0.05, 1.0, 0.0)
+    joint_s = math(nt, "DIVIDE", along, 2.4)
+    joint = remap(nt, math(nt, "FRACT", joint_s), 0.0, 0.01, 1.0, 0.0)
+    if polished:
+        groove = math(nt, "MULTIPLY", groove, 0.0)
+        joint = remap(nt, math(nt, "FRACT", math(nt, "DIVIDE", along, 1.8)), 0.0, 0.004, 1.0, 0.0)
+        joint = math(nt, "MAXIMUM", joint, remap(nt, math(nt, "FRACT", math(nt, "DIVIDE", across, 1.8)), 0.0, 0.004, 1.0, 0.0))
+    grid = node(nt, "ShaderNodeTexVoronoi", {"Vector": node(nt, "ShaderNodeCombineXYZ", {"X": math(nt, "DIVIDE", along, 1.2), "Y": math(nt, "DIVIDE", across, 1.2), "Z": 0.0}).outputs[0], "Randomness": 0.0}, feature="F1").outputs["Distance"]
+    holes = remap(nt, grid, 0.055, 0.04, 0.0, 1.0)
+    if polished:
+        holes = math(nt, "MULTIPLY", holes, 0.0)
+
+    height = math(nt, "ADD", math(nt, "MULTIPLY", fine, 0.5), math(nt, "MULTIPLY", patches, 0.5))
+    height = math(nt, "SUBTRACT", height, math(nt, "MULTIPLY", math(nt, "MAXIMUM", groove, joint), 0.55))
+    height = math(nt, "SUBTRACT", height, math(nt, "MULTIPLY", holes, 1.2))
+    height = math(nt, "ADD", height, math(nt, "MULTIPLY", pores, 0.15))
+    bump = node(nt, "ShaderNodeBump", {"Height": height, "Strength": 0.25 if polished else 0.55, "Distance": 0.012}).outputs["Normal"]
+
+    tone_v = math(nt, "MULTIPLY", remap(nt, patches, 0.3, 0.7, 0.55, 1.35), math(nt, "ADD", 0.82, math(nt, "MULTIPLY", board_rnd, 0.3 if not polished else 0.0)))
+    tone_v = math(nt, "MULTIPLY", tone_v, remap(nt, streaks, 0.35, 0.7, 1.15, 0.6))
+    tone_v = math(nt, "MULTIPLY", tone_v, math(nt, "SUBTRACT", 1.0, math(nt, "MULTIPLY", math(nt, "MAXIMUM", groove, joint), 0.55)))
+    tone_v = math(nt, "MULTIPLY", tone_v, math(nt, "SUBTRACT", 1.0, math(nt, "MULTIPLY", holes, 0.85)))
+    tone_v = math(nt, "MULTIPLY", tone_v, math(nt, "ADD", 0.45, math(nt, "MULTIPLY", _ao(nt, 0.6), 0.55)))
+    base = vmath(nt, "MULTIPLY", rgb(nt, tone * 0.93, tone * 0.97, tone * 1.02), vmath(nt, "SCALE", rgb(nt, 1, 1, 1), tone_v))
+    rough = math(nt, "ADD", 0.55 if not polished else 0.06, math(nt, "MULTIPLY", math(nt, "SUBTRACT", fine, 0.5), 0.5 if not polished else 0.2))
+    if polished:
+        rough = math(nt, "ADD", rough, math(nt, "MULTIPLY", remap(nt, patches, 0.45, 0.7), 0.3))
+    b = principled(nt, Base_Color=base, Roughness=math(nt, "MAXIMUM", rough, 0.05, clamp=True), Normal=bump, Specular_IOR_Level=0.5 if not polished else 0.8)
+    finish(nt, b)
+    return m
+
+
+def plastic(name="plastic", palette=((0.035, 0.037, 0.04), (0.24, 0.225, 0.19), (0.05, 0.06, 0.055))):
+    """Colour picked per object via Object Info random so one material serves many monitors."""
+    m, nt = fresh(name)
+    r = node(nt, "ShaderNodeObjectInfo").outputs["Random"]
+    c0, c1, c2 = (rgb(nt, *c) for c in palette)
+    col = mix(nt, remap(nt, r, 0.5, 0.52, 0.0, 1.0, smooth=False), c0, c1)
+    col = mix(nt, remap(nt, r, 0.82, 0.84, 0.0, 1.0, smooth=False), col, c2)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    grain = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 260.0), "Detail": 3.0}).outputs["Fac"]
+    blot = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 5.0), "Detail": 4.0}).outputs["Fac"]
+    ao = _ao(nt, 0.05)
+    col = vmath(nt, "MULTIPLY", col, vmath(nt, "SCALE", rgb(nt, 1, 1, 1), math(nt, "MULTIPLY", math(nt, "ADD", 0.5, math(nt, "MULTIPLY", ao, 0.5)), remap(nt, blot, 0.3, 0.7, 0.8, 1.15))))
+    bump = node(nt, "ShaderNodeBump", {"Height": grain, "Strength": 0.1, "Distance": 0.0004}).outputs["Normal"]
+    rough = math(nt, "ADD", 0.38, math(nt, "MULTIPLY", blot, 0.25))
+    finish(nt, principled(nt, Base_Color=col, Roughness=rough, Normal=bump, Specular_IOR_Level=0.5))
+    return m
+
+
+def steel(name="steel", tone=0.32):
+    m, nt = fresh(name)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    brushed = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "MULTIPLY", pos, (90.0, 2.0, 2.0)), "Detail": 3.0}).outputs["Fac"]
+    patina = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 3.0), "Detail": 6.0}).outputs["Fac"]
+    col = vmath(nt, "SCALE", rgb(nt, tone, tone * 1.02, tone * 1.06), math(nt, "MULTIPLY", remap(nt, patina, 0.3, 0.7, 0.5, 1.2), math(nt, "ADD", 0.5, math(nt, "MULTIPLY", _ao(nt, 0.1), 0.5))))
+    bump = node(nt, "ShaderNodeBump", {"Height": brushed, "Strength": 0.08, "Distance": 0.0005}).outputs["Normal"]
+    finish(nt, principled(nt, Base_Color=col, Metallic=1.0, Roughness=math(nt, "ADD", 0.28, math(nt, "MULTIPLY", patina, 0.3)), Normal=bump))
+    return m
+
+
+def rubber(name="rubber", tint=(0.012, 0.012, 0.013)):
+    m, nt = fresh(name)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    n1 = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 90.0), "Detail": 3.0}).outputs["Fac"]
+    bump = node(nt, "ShaderNodeBump", {"Height": n1, "Strength": 0.1, "Distance": 0.0006}).outputs["Normal"]
+    finish(nt, principled(nt, Base_Color=tint, Roughness=0.42, Normal=bump, Sheen_Weight=0.2, Sheen_Roughness=0.5, Specular_IOR_Level=0.55))
+    return m
+
+
+def led(name, color, power):
+    m, nt = fresh(name)
+    finish(nt, principled(nt, Base_Color=(0.01, 0.01, 0.01), Emission_Color=color, Emission_Strength=power, Roughness=0.2))
+    return m
+
+
+def led_random(name, power):
+    """Status LED whose colour (green / amber / red / cyan) is chosen per object."""
+    m, nt = fresh(name)
+    r = node(nt, "ShaderNodeObjectInfo").outputs["Random"]
+    col = mix(nt, remap(nt, r, 0.40, 0.41, 0.0, 1.0, smooth=False), rgb(nt, 0.1, 1.0, 0.2), rgb(nt, 1.0, 0.45, 0.05))
+    col = mix(nt, remap(nt, r, 0.75, 0.76, 0.0, 1.0, smooth=False), col, rgb(nt, 1.0, 0.04, 0.03))
+    col = mix(nt, remap(nt, r, 0.92, 0.93, 0.0, 1.0, smooth=False), col, rgb(nt, 0.1, 0.7, 1.0))
+    finish(nt, principled(nt, Base_Color=(0.01, 0.01, 0.01), Emission_Color=col, Emission_Strength=power, Roughness=0.2))
+    return m
+
+
+def vent_black(name="vent_black"):
+    m, nt = fresh(name)
+    finish(nt, principled(nt, Base_Color=(0.004, 0.004, 0.004), Roughness=0.7))
+    return m
+
+
+def screen(name, image, tint, anim, rows_visible=0.5, lines=140.0, strength=5.0, zoom=1.0):
+    """CRT glass over phosphor: emissive scrolling image * scanlines * vignette, glossy dusty glass on top.
+
+    anim: dict of Value nodes the caller keys per frame -> {'scroll': Value node, 'time': Value node}.
+    """
+    m, nt = fresh(name)
+    uv = node(nt, "ShaderNodeUVMap").outputs["UV"]
+    sep = node(nt, "ShaderNodeSeparateXYZ", {"Vector": uv})
+    u, v = sep.outputs["X"], sep.outputs["Y"]
+    rnd = node(nt, "ShaderNodeObjectInfo").outputs["Random"]
+    scroll = node(nt, "ShaderNodeValue")
+    scroll.label = "scroll"
+    tnode = node(nt, "ShaderNodeValue")
+    tnode.label = "time"
+    anim["scroll"], anim["time"] = scroll, tnode
+    off_y = math(nt, "ADD", scroll.outputs[0], math(nt, "MULTIPLY", math(nt, "FLOOR", math(nt, "MULTIPLY", rnd, 64.0)), 1.0 / 64.0))
+    pu = math(nt, "ADD", math(nt, "MULTIPLY", u, 0.94 * zoom), 0.0)
+    pv = math(nt, "ADD", math(nt, "MULTIPLY", v, rows_visible * zoom), off_y)
+    coords = node(nt, "ShaderNodeCombineXYZ", {"X": pu, "Y": pv, "Z": 0.0}).outputs[0]
+    tex = node(nt, "ShaderNodeTexImage", {"Vector": coords}, image=image, interpolation="Linear", extension="REPEAT")
+    lum = tex.outputs["Color"]
+    lum = node(nt, "ShaderNodeSeparateColor", {"Color": lum}).outputs["Red"]
+
+    scan = math(nt, "ADD", 0.62, math(nt, "MULTIPLY", math(nt, "SINE", math(nt, "MULTIPLY", v, lines * 2.0 * pymath.pi)), 0.38))
+    du, dv = math(nt, "SUBTRACT", u, 0.5), math(nt, "SUBTRACT", v, 0.5)
+    r2 = math(nt, "ADD", math(nt, "MULTIPLY", du, du), math(nt, "MULTIPLY", dv, dv))
+    vign = remap(nt, r2, 0.62, 0.05, 0.25, 1.0)
+    edge = math(nt, "MULTIPLY", remap(nt, math(nt, "MINIMUM", u, math(nt, "SUBTRACT", 1.0, u)), 0.0, 0.035), remap(nt, math(nt, "MINIMUM", v, math(nt, "SUBTRACT", 1.0, v)), 0.0, 0.035))
+
+    t = tnode.outputs[0]
+    phase = math(nt, "MULTIPLY", rnd, 6.2832)
+    flick = math(nt, "ADD", 1.0, math(nt, "MULTIPLY", math(nt, "ADD", math(nt, "SINE", math(nt, "ADD", math(nt, "MULTIPLY", t, 53.0), phase)), math(nt, "SINE", math(nt, "ADD", math(nt, "MULTIPLY", t, 17.3), math(nt, "MULTIPLY", phase, 2.3)))), 0.035))
+    bar_pos = math(nt, "FRACT", math(nt, "ADD", math(nt, "MULTIPLY", t, 0.19), rnd))
+    d = math(nt, "ABSOLUTE", math(nt, "SUBTRACT", math(nt, "FRACT", math(nt, "ADD", math(nt, "SUBTRACT", v, bar_pos), 0.5)), 0.5))
+    bar = math(nt, "ADD", 1.0, remap(nt, d, 0.14, 0.0, 0.0, 0.35))
+
+    raster = math(nt, "ADD", 0.03,math(nt, "MULTIPLY", lum, 1.0))
+    lit = math(nt, "MULTIPLY", math(nt, "MULTIPLY", raster, scan), math(nt, "MULTIPLY", math(nt, "MULTIPLY", vign, edge), math(nt, "MULTIPLY", flick, bar)))
+    emit = vmath(nt, "MULTIPLY", rgb(nt, *tint), vmath(nt, "SCALE", rgb(nt, 1, 1, 1), lit))
+
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    dust = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 22.0), "Detail": 5.0}).outputs["Fac"]
+    smudge = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 6.0), "Detail": 3.0}).outputs["Fac"]
+    rough = math(nt, "ADD", 0.035, math(nt, "MULTIPLY", math(nt, "MULTIPLY", remap(nt, smudge, 0.4, 0.75), remap(nt, dust, 0.4, 0.8)), 0.16))
+    finish(nt, principled(nt, Base_Color=(0.004, 0.005, 0.004), Roughness=rough, IOR=1.52, Specular_IOR_Level=0.7, Emission_Color=emit, Emission_Strength=strength))
+    return m

package/skills/agentvfx/plates/terminalcore/nodekit.py

@@ -0,0 +1,87 @@
+"""Tiny shader-node helpers: build node graphs as expressions (sockets or plain numbers in, sockets out)."""
+import bpy
+
+
+def fresh(name):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = True
+    nt = m.node_tree
+    nt.nodes.clear()
+    return m, nt
+
+
+def _set(sock, v):
+    if isinstance(v, bpy.types.NodeSocket):
+        sock.node.id_data.links.new(v, sock)
+    elif sock.type == "RGBA" and not isinstance(v, (int, float)) and len(v) == 3:
+        sock.default_value = (*v, 1.0)
+    else:
+        sock.default_value = v
+
+
+def node(nt, idname, ins=None, **props):
+    n = nt.nodes.new(idname)
+    for k, v in props.items():
+        setattr(n, k, v)
+    for k, v in (ins or {}).items():
+        _set(n.inputs[k], v)
+    return n
+
+
+def math(nt, op, a, b=None, c=None, clamp=False):
+    n = nt.nodes.new("ShaderNodeMath")
+    n.operation = op
+    n.use_clamp = clamp
+    for i, v in enumerate((a, b, c)):
+        if v is not None:
+            _set(n.inputs[i], v)
+    return n.outputs[0]
+
+
+def remap(nt, v, lo, hi, out_lo=0.0, out_hi=1.0, smooth=True):
+    n = nt.nodes.new("ShaderNodeMapRange")
+    n.interpolation_type = "SMOOTHSTEP" if smooth else "LINEAR"
+    n.clamp = True
+    for k, x in (("Value", v), ("From Min", lo), ("From Max", hi), ("To Min", out_lo), ("To Max", out_hi)):
+        _set(n.inputs[k], x)
+    return n.outputs["Result"]
+
+
+def mix(nt, fac, a, b):
+    n = nt.nodes.new("ShaderNodeMix")
+    n.data_type = "RGBA"
+    on = lambda name: next(i for i in n.inputs if i.name == name and i.type == "RGBA")
+    _set(n.inputs[0], fac)
+    _set(on("A"), a)
+    _set(on("B"), b)
+    return next(o for o in n.outputs if o.type == "RGBA")
+
+
+def vmath(nt, op, a, b=None):
+    n = nt.nodes.new("ShaderNodeVectorMath")
+    n.operation = op
+    _set(n.inputs[0], a)
+    if b is not None:
+        _set(n.inputs["Scale"] if op == "SCALE" else n.inputs[1], b)
+    return n.outputs[0] if op not in ("DOT_PRODUCT", "LENGTH", "DISTANCE") else n.outputs["Value"]
+
+
+def rgb(nt, r, g, b):
+    n = nt.nodes.new("ShaderNodeRGB")
+    n.outputs[0].default_value = (r, g, b, 1.0)
+    return n.outputs[0]
+
+
+def principled(nt, **ins):
+    n = nt.nodes.new("ShaderNodeBsdfPrincipled")
+    for k, v in ins.items():
+        _set(n.inputs[k.replace("_", " ")], v)
+    return n
+
+
+def finish(nt, shader, volume=None):
+    out = nt.nodes.new("ShaderNodeOutputMaterial")
+    out.target = "CYCLES"
+    nt.links.new(shader.outputs[0], out.inputs["Surface"])
+    if volume is not None:
+        nt.links.new(volume, out.inputs["Volume"])

package/skills/agentvfx/plates/terminalcore/room.py

@@ -0,0 +1,82 @@
+"""Brutalist room shell, haze world, and the single cold key light (slit window on the left wall)."""
+import math
+
+import bmesh
+import bpy
+from mathutils import Matrix, Vector
+
+from nodekit import fresh, finish, math as nmath, remap, node, rgb, vmath
+
+# Room: x -5.5..5.5, y -12..0.62 (wall niche back at y=0.62), z 0..4.6
+BACK_Y = 0.62
+CEIL_Z = 4.6
+
+
+def add_box(coll, name, center, size, mat, bevel=0.0):
+    bm = bmesh.new()
+    bmesh.ops.create_cube(bm, size=1.0, matrix=Matrix.Translation(center) @ Matrix.Diagonal((*size, 1.0)))
+    if bevel:
+        bmesh.ops.bevel(bm, geom=list(bm.edges), offset=bevel, segments=2, affect="EDGES")
+    me = bpy.data.meshes.new(name)
+    bm.to_mesh(me)
+    bm.free()
+    me.materials.append(mat)
+    ob = bpy.data.objects.new(name, me)
+    coll.objects.link(ob)
+    return ob
+
+
+def build_room(coll, mats):
+    conc, floor = mats["concrete"], mats["floor"]
+    add_box(coll, "floor", (0, -5.69, -0.25), (11.2, 12.62, 0.5), floor)
+    add_box(coll, "ceiling", (0, -5.69, CEIL_Z + 0.4), (11.2, 12.62, 0.8), conc)
+    add_box(coll, "back_wall", (0, BACK_Y + 0.4, CEIL_Z / 2), (11.2, 0.8, CEIL_Z + 1.0), conc)
+    add_box(coll, "right_wall", (5.5 + 0.4, -5.69, CEIL_Z / 2), (0.8, 12.62, CEIL_Z + 1.0), conc)
+    add_box(coll, "front_wall", (0, -12.4, CEIL_Z / 2), (11.2, 0.8, CEIL_Z + 1.0), conc)
+    # left wall with a full-height slit window at y = -5.0
+    add_box(coll, "left_wall_a", (-5.9, -8.75, CEIL_Z / 2), (0.8, 6.5, CEIL_Z + 1.0), conc)
+    add_box(coll, "left_wall_b", (-5.9, -1.69, CEIL_Z / 2), (0.8, 6.22, CEIL_Z + 1.0), conc)
+    for i, (x, z, w) in enumerate(((-2.3, 2.2, 6.0), (1.5, 0.55, 3.0), (-4.9, 1.6, 0.06))):
+        add_box(coll, f"strip_{i}", (x, -11.96, z), (w, 0.05, 0.07 if w > 1 else 2.2), mats["strip"])
+    # brutalist piers + lintel framing the monitor niche
+    for sx in (-1, 1):
+        add_box(coll, f"pier_{sx}", (sx * 3.35, -0.35, CEIL_Z / 2), (1.0, 1.95, CEIL_Z), conc, 0.012)
+    add_box(coll, "lintel", (0, -0.35, 3.55), (5.7, 1.95, 0.9), conc, 0.012)
+    add_box(coll, "plinth", (0, -0.3, 0.12), (5.7, 1.8, 0.24), conc, 0.01)
+
+
+def build_world_and_light(scene, coll, strength=1.0, haze=1.0, shot="wall"):
+    world = bpy.data.worlds.new("haze")
+    scene.world = world
+    world.use_nodes = True
+    nt = world.node_tree
+    nt.nodes.clear()
+    bg = node(nt, "ShaderNodeBackground", {"Color": (0.002, 0.003, 0.006, 1.0), "Strength": 1.0})
+    out = node(nt, "ShaderNodeOutputWorld")
+    nt.links.new(bg.outputs[0], out.inputs["Surface"])
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    wisp = node(nt, "ShaderNodeTexNoise", {"Vector": vmath(nt, "SCALE", pos, 0.35), "Detail": 3.0}).outputs["Fac"]
+    dens = nmath(nt, "MULTIPLY", remap(nt, wisp, 0.25, 0.75, 0.5, 1.5), 0.008 * haze)
+    vol = node(nt, "ShaderNodeVolumeScatter", {"Density": dens, "Anisotropy": 0.3, "Color": (0.8, 0.88, 1.0, 1.0)})
+    nt.links.new(vol.outputs[0], out.inputs["Volume"])
+
+    key = bpy.data.lights.new("key", "AREA")
+    key.shape = "RECTANGLE"
+    key.size, key.size_y = 3.6, 0.6
+    key.color = (0.55, 0.72, 1.0)
+    key.energy = 1500.0 * strength
+    key.spread = math.radians(35)
+    ko = bpy.data.objects.new("key", key)
+    ko.location = (-7.1, -5.55, 2.2)
+    ko.rotation_euler = (0.0, math.radians(-90), math.radians(18))
+    coll.objects.link(ko)
+    if shot == "closeup":
+        spot = bpy.data.lights.new("key_close", "SPOT")
+        spot.color, spot.energy = (0.6, 0.78, 1.0), 420.0 * strength
+        spot.spot_size, spot.spot_blend, spot.shadow_soft_size = math.radians(30), 0.7, 0.08
+        so = bpy.data.objects.new("key_close", spot)
+        so.location = (1.6, -2.2, 3.0)
+        direction = Vector((0.0, -0.05, 1.55)) - Vector(so.location)
+        so.rotation_euler = direction.to_track_quat("-Z", "Y").to_euler()
+        coll.objects.link(so)
+    return ko

package/skills/agentvfx/plates/terminalcore/scene.py

@@ -0,0 +1,219 @@
+"""Terminalcore plate: procedural CRT-wall brutalist room rendered with Cycles (Metal GPU, OIDN).
+
+Run:  blender -b --factory-startup --python scene.py -- --shot wall --out DIR [--width 640 --height 360
+      --seconds 4 --fps 30 --samples 48 --frame N --exposure 0 --bloom 1]
+Use scripts/plate.mjs for the full render + H.264 encode.
+"""
+import argparse
+import math
+import os
+import random
+import sys
+import time
+
+import bpy
+from mathutils import Quaternion
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import gallery  # noqa: E402
+import materials as M  # noqa: E402
+import room  # noqa: E402
+import shots  # noqa: E402
+import textures  # noqa: E402
+import wall  # noqa: E402
+
+
+def parse():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--shot", default="wall")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--width", type=int, default=640)
+    ap.add_argument("--height", type=int, default=360)
+    ap.add_argument("--seconds", type=float, default=4.0)
+    ap.add_argument("--fps", type=int, default=30)
+    ap.add_argument("--samples", type=int, default=40)
+    ap.add_argument("--quality", choices=("preview", "final"), default="preview", help="final: tight adaptive threshold, accurate denoise, camera motion blur")
+    ap.add_argument("--frame", type=int, default=0, help="render only this 1-based frame to still_<n>.png")
+    ap.add_argument("--exposure", type=float, default=None)
+    ap.add_argument("--bloom", type=float, default=None)
+    ap.add_argument("--key", type=float, default=1.0, help="key light strength multiplier")
+    ap.add_argument("--haze", type=float, default=None, help="volumetric haze density multiplier")
+    a = ap.parse_args(sys.argv[sys.argv.index("--") + 1:])
+    gallery = a.shot == "gallery"
+    for name, wall_default, gallery_default in (("exposure", -0.3, 0.15), ("bloom", 1.0, 0.5), ("haze", 1.4, 1.8)):
+        if getattr(a, name) is None:
+            setattr(a, name, gallery_default if gallery else wall_default)
+    return a
+
+
+def setup_render(scene, a):
+    scene.render.engine = "CYCLES"
+    cy = scene.cycles
+    prefs = bpy.context.preferences.addons["cycles"].preferences
+    prefs.compute_device_type = "METAL"
+    prefs.get_devices()
+    for d in prefs.devices:
+        d.use = d.type == "METAL"
+    cy.device = "GPU"
+    cy.samples = a.samples
+    final = a.quality == "final"
+    cy.use_adaptive_sampling = True
+    cy.adaptive_threshold = 0.01 if final else 0.03
+    cy.use_denoising = True
+    cy.denoiser = "OPENIMAGEDENOISE"
+    cy.denoising_use_gpu = True
+    if final:
+        cy.denoising_prefilter = "ACCURATE"
+        cy.denoising_quality = "HIGH"
+        scene.render.use_motion_blur = True
+        scene.render.motion_blur_shutter = 0.5
+        scene.render.motion_blur_position = "CENTER"
+    cy.max_bounces, cy.diffuse_bounces, cy.glossy_bounces = 6, 3, 4
+    cy.transmission_bounces, cy.volume_bounces, cy.transparent_max_bounces = 2, 1, 4
+    cy.sample_clamp_indirect = 8.0
+    cy.sample_clamp_direct = 0.0
+    cy.blur_glossy = 0.3
+    cy.volume_step_rate = 1.5
+    cy.volume_max_steps = 256
+    scene.render.use_persistent_data = True
+    scene.render.resolution_x, scene.render.resolution_y = a.width, a.height
+    scene.render.resolution_percentage = 100
+    scene.render.fps = a.fps
+    scene.render.image_settings.file_format = "PNG"
+    scene.render.image_settings.color_mode = "RGB"
+    scene.view_settings.view_transform = "AgX"
+    for look in ("AgX - High Contrast", "AgX - Punchy"):
+        try:
+            scene.view_settings.look = look
+            break
+        except TypeError:
+            continue
+    scene.view_settings.exposure = a.exposure
+    scene.frame_start, scene.frame_end = 1, max(1, round(a.seconds * a.fps))
+
+
+def setup_bloom(scene, strength):
+    ng = bpy.data.node_groups.new("plate_comp", "CompositorNodeTree")
+    scene.compositing_node_group = ng
+    ng.interface.new_socket("Image", in_out="OUTPUT", socket_type="NodeSocketColor")
+    rl = ng.nodes.new("CompositorNodeRLayers")
+    gl = ng.nodes.new("CompositorNodeGlare")
+    out = ng.nodes.new("NodeGroupOutput")
+    gl.inputs["Type"].default_value = "Bloom"
+    gl.inputs["Threshold"].default_value = 0.9
+    gl.inputs["Strength"].default_value = 0.8 * strength
+    gl.inputs["Size"].default_value = 0.6
+    ng.links.new(rl.outputs["Image"], gl.inputs["Image"])
+    ng.links.new(gl.outputs["Image"], out.inputs[0])
+
+
+def make_camera(scene, coll):
+    cam = bpy.data.cameras.new("cam")
+    cam.sensor_width = 36.0
+    cam.dof.use_dof = True
+    ob = bpy.data.objects.new("cam", cam)
+    coll.objects.link(ob)
+    scene.camera = ob
+    return ob
+
+
+def build(scene, coll, a):
+    if a.shot == "gallery":
+        return gallery.build(scene, coll, a)
+    rng = random.Random(1987)
+    mats = {
+        "concrete": M.concrete("concrete"), "floor": M.concrete("floor", polished=True, tone=0.11),
+        "plastic": M.plastic(), "steel": M.steel(), "rubber": M.rubber(), "led": M.led_random("led", 12.0),
+        "vent": M.vent_black(), "strip": M.led("strip", (0.55, 0.78, 1.0), 14.0), "glass_off": M.screen("glass_off", textures.make_image("off", 5), (0.0, 0.0, 0.0), {}, strength=0.0),
+    }
+    mats["glass_base"] = mats["glass_off"]
+    lines = 150.0 if a.shot == "closeup" else 90.0
+    screens, anims = {}, {}
+    for key, (seed, tint, strength, rate) in wall.VARIANTS.items():
+        anims[key] = {}
+        screens[key] = M.screen(f"screen_{key}", textures.make_image(f"term_{key}", seed), tint, anims[key], lines=lines, strength=strength, zoom=1.0 if a.shot == "closeup" else 0.5)
+    room.build_room(coll, mats)
+    room.build_world_and_light(scene, coll, a.key, a.haze, a.shot)
+    wall.build_rack(coll, mats)
+    wall.build_monitors(coll, mats, screens, rng)
+    wall.build_tray_and_cables(coll, mats, rng)
+    wall.build_status_array(coll, mats, rng)
+    return anims
+
+
+def apply_pose(cam, p):
+    cam.location = p["loc"]
+    cam.rotation_mode = "QUATERNION"
+    cam.rotation_quaternion = p["quat"] @ Quaternion((0.0, 0.0, 1.0), p["roll"])
+    cam.data.lens = p["lens"]
+    cam.data.shift_y = p.get("shift_y", 0.0)
+    cam.data.dof.aperture_fstop = p["fstop"]
+    cam.data.dof.focus_distance = p["focus"]
+
+
+def bake_camera(scene, cam, a):
+    """Keyframe the camera on every frame: Cycles motion blur only sees fcurves, not a frame-change handler."""
+    total = scene.frame_end
+    for f in range(1, total + 1):
+        apply_pose(cam, shots.pose(a.shot, (f - 1) / max(total - 1, 1), f))
+        for ob, paths in ((cam, ("location", "rotation_quaternion")), (cam.data, ("lens", "shift_y", "dof.aperture_fstop", "dof.focus_distance"))):
+            for path in paths:
+                ob.keyframe_insert(path, frame=f)
+    scene.frame_set(2)
+    y_whole = cam.matrix_world.translation.y
+    scene.frame_set(2, subframe=0.5)
+    print(f"TIMING camera keyed on {total} frames, subframe dy={cam.matrix_world.translation.y - y_whole:.5f} m, motion_blur={scene.render.use_motion_blur} shutter={scene.render.motion_blur_shutter}", flush=True)
+
+
+def install_animation(scene, cam, anims, a):
+    total = scene.frame_end
+    row = 18 / 1152
+    baked = a.quality == "final"
+
+    def on_frame(scn):
+        f = scn.frame_current
+        t = (f - 1) / max(total - 1, 1)
+        secs = (f - 1) / a.fps
+        for key, anim in anims.items():
+            rate = wall.VARIANTS[key][3] * {"closeup": 1.6, "gallery": 0.55}.get(a.shot, 0.8)
+            anim["scroll"].outputs[0].default_value = math.floor(secs * rate) * row
+            anim["time"].outputs[0].default_value = secs
+        if not baked:
+            apply_pose(cam, shots.pose(a.shot, t, f))
+
+    if baked:
+        bake_camera(scene, cam, a)
+    bpy.app.handlers.frame_change_pre.append(on_frame)
+    return on_frame
+
+
+def main():
+    a = parse()
+    scene = bpy.context.scene
+    for ob in list(bpy.data.objects):
+        bpy.data.objects.remove(ob)
+    coll = scene.collection
+    setup_render(scene, a)
+    if a.bloom > 0:
+        setup_bloom(scene, a.bloom)
+    t0 = time.time()
+    cam = make_camera(scene, coll)
+    anims = build(scene, coll, a)
+    print(f"TIMING build {time.time() - t0:.1f}s look={scene.view_settings.look}", flush=True)
+    on_frame = install_animation(scene, cam, anims, a)
+    os.makedirs(a.out, exist_ok=True)
+    t1 = time.time()
+    if a.frame:
+        scene.frame_set(a.frame)
+        on_frame(scene)
+        scene.render.filepath = os.path.join(a.out, f"still_{a.frame:03d}.png")
+        bpy.ops.render.render(write_still=True)
+    else:
+        os.makedirs(os.path.join(a.out, "frames"), exist_ok=True)
+        scene.render.filepath = os.path.join(a.out, "frames", "f_")
+        bpy.ops.render.render(animation=True)
+    print(f"TIMING render {time.time() - t1:.1f}s", flush=True)
+
+
+main()

package/skills/agentvfx/plates/terminalcore/shots.py

@@ -0,0 +1,48 @@
+"""Camera moves: slow cinematic push / slide with a little handheld wander. pose(shot, t, frame) -> dict."""
+import math
+
+from mathutils import Vector
+
+import wall
+
+
+def _lerp(a, b, t):
+    return tuple(x + (y - x) * t for x, y in zip(a, b))
+
+
+def _ease(t):
+    return t * t * (3.0 - 2.0 * t)
+
+
+def _hand(f, amp):
+    """Smooth pseudo-random wander (sum of incommensurate sines)."""
+    s = lambda k, p: math.sin(f * k + p)
+    return (amp * (s(0.11, 0.3) + 0.5 * s(0.29, 1.7)), amp * (s(0.13, 2.1) + 0.5 * s(0.31, 0.2)), amp * (s(0.09, 4.0) + 0.5 * s(0.23, 3.1)))
+
+
+def pose(shot, t, frame):
+    hx, hy, hz = wall.monitor_position(*wall.HERO)
+    if shot == "closeup":
+        e = _ease(t)
+        loc = _lerp((0.66, -1.34, 1.57), (0.34, -1.14, 1.50), e)
+        target = _lerp((0.02, -0.02, hz + 0.03), (-0.02, -0.02, hz + 0.0), e)
+        lens, fstop, amp = 62.0, 2.0, 0.0035
+    elif shot == "wall":
+        e = _ease(t)
+        loc = _lerp((3.5, -8.4, 1.3), (1.6, -6.4, 1.38), e)
+        target = _lerp((-0.5, 0.0, 1.7), (-1.0, 0.0, 1.62), e)
+        lens, fstop, amp = 28.0, 1.6, 0.012
+    elif shot == "gallery":
+        e = 0.35 * _ease(t) + 0.65 * t
+        loc = (0.0, -9.8 + 1.4 * e, 1.3)  # 1.4 m dolly: bench base stays clear of the bottom edge on the last frame
+        return {"loc": loc, "quat": Vector((0.0, 1.0, 0.0)).to_track_quat("-Z", "Y"), "roll": 0.0, "lens": 26.0, "fstop": 11.0,
+                "focus": -0.05 - loc[1], "shift_y": 0.06}
+    else:
+        raise SystemExit(f"unknown shot: {shot}")
+    hx_, hy_, hz_ = _hand(frame, amp)
+    loc = (loc[0] + hx_, loc[1] + hy_ * 0.5, loc[2] + hz_)
+    target = (target[0] + hz_ * 0.6, target[1], target[2] + hx_ * 0.6)
+    dist = (Vector(target) - Vector(loc)).length
+    quat = (Vector(target) - Vector(loc)).to_track_quat("-Z", "Y")
+    roll = math.radians(0.25) * math.sin(frame * 0.07 + 1.0) * (0.4 if shot == "closeup" else 1.0)
+    return {"loc": loc, "quat": quat, "roll": roll, "lens": lens, "fstop": fstop, "focus": dist}