agentvfx 0.0.0-stage → 0.3.4

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

@@ -0,0 +1,143 @@
+"""CRT monitor mesh: bevelled bezel, loft housing, curved glass, vents, knobs, LED. Front faces -Y, origin = front centre."""
+import math
+import random
+
+import bmesh
+import bpy
+from mathutils import Matrix, Vector
+
+SLOT_PLASTIC, SLOT_GLASS, SLOT_VENT, SLOT_STEEL, SLOT_LED = range(5)
+
+
+def _new(bm, before):
+    """Faces created since the snapshot, by identity (BMesh reuses freed slots, so index slicing is unsafe)."""
+    return [f for f in bm.faces if f not in before]
+
+
+def _tag(bm, before, slot):
+    for f in _new(bm, before):
+        f.material_index = slot
+
+
+def _bevel(bm, before, width, segs=2):
+    edges = {e for f in _new(bm, before) for e in f.edges}
+    bmesh.ops.bevel(bm, geom=list(edges), offset=width, segments=segs, affect="EDGES")
+
+
+def box(bm, center, size, slot, bevel=0.004):
+    start = set(bm.faces)
+    bmesh.ops.create_cube(bm, size=1.0, matrix=Matrix.Translation(center) @ Matrix.Diagonal((*size, 1.0)))
+    if bevel:
+        _bevel(bm, start, bevel)
+    _tag(bm, start, slot)
+
+
+def loft(bm, rings, slot, bevel=0.005):
+    """rings: [(y, half_w, half_h, z_off)] -> closed rectangular tube with end caps."""
+    start = set(bm.faces)
+    loops = []
+    for y, hw, hh, zo in rings:
+        loops.append([bm.verts.new(p) for p in ((-hw, y, zo - hh), (hw, y, zo - hh), (hw, y, zo + hh), (-hw, y, zo + hh))])
+    for a, b in zip(loops, loops[1:]):
+        for i in range(4):
+            j = (i + 1) % 4
+            bm.faces.new((a[i], a[j], b[j], b[i]))
+    bm.faces.new(loops[0][::-1])
+    bm.faces.new(loops[-1])
+    bmesh.ops.recalc_face_normals(bm, faces=_new(bm, start))
+    if bevel:
+        _bevel(bm, start, bevel)
+    _tag(bm, start, slot)
+
+
+def cylinder(bm, center, radius, depth, slot, axis_y=True, seg=14):
+    start = set(bm.faces)
+    rot = Matrix.Rotation(math.pi / 2, 4, "X") if axis_y else Matrix.Identity(4)
+    bmesh.ops.create_cone(bm, cap_ends=True, segments=seg, radius1=radius, radius2=radius, depth=depth, matrix=Matrix.Translation(center) @ rot)
+    _tag(bm, start, slot)
+
+
+def glass(bm, half_w, half_h, z_off, bulge, nx=22, ny=16):
+    """Curved CRT faceplate (spherical-ish bulge toward -Y) with 0..1 UVs; flat-ish corners."""
+    start = set(bm.faces)
+    grid = [[None] * (nx + 1) for _ in range(ny + 1)]
+    for j in range(ny + 1):
+        for i in range(nx + 1):
+            u, v = i / nx, j / ny
+            x, z = (u - 0.5) * 2.0, (v - 0.5) * 2.0
+            y = -bulge * (1.0 - 0.5 * (x * x + z * z)) + bulge * 0.0
+            grid[j][i] = bm.verts.new((x * half_w, y, z_off + z * half_h))
+    for j in range(ny):
+        for i in range(nx):
+            bm.faces.new((grid[j][i], grid[j][i + 1], grid[j + 1][i + 1], grid[j + 1][i]))
+    uvl = bm.loops.layers.uv.verify()
+    faces = _new(bm, start)
+    for f in faces:
+        for lp in f.loops:
+            c = lp.vert.co
+            lp[uvl].uv = ((c.x / half_w) * 0.5 + 0.5, ((c.z - z_off) / half_h) * 0.5 + 0.5)
+    bmesh.ops.reverse_faces(bm, faces=faces)
+    _tag(bm, start, SLOT_GLASS)
+
+
+def build_crt_mesh(name="crt"):
+    bm = bmesh.new()
+    sw, sh, zc = 0.36, 0.26, 0.02
+    ow, oh = 0.50, 0.42
+    # bezel: four bars around the screen opening, bottom bar deeper for controls
+    box(bm, (-(sw / 2 + 0.035), 0.035, 0.02), (0.07, 0.07, oh - 0.16), SLOT_PLASTIC, 0.006)
+    box(bm, ((sw / 2 + 0.035), 0.035, 0.02), (0.07, 0.07, oh - 0.16), SLOT_PLASTIC, 0.006)
+    # black gasket ring hugging the glass
+    for sx in (-1, 1):
+        box(bm, (sx * (sw / 2 + 0.006), 0.012, zc), (0.012, 0.03, sh + 0.024), SLOT_VENT, 0.003)
+    for sz in (-1, 1):
+        box(bm, (0.0, 0.012, zc + sz * (sh / 2 + 0.006)), (sw, 0.03, 0.012), SLOT_VENT, 0.003)
+    box(bm, (0.0, 0.035, oh / 2 - 0.03), (sw + 0.14, 0.07, 0.06), SLOT_PLASTIC, 0.006)
+    box(bm, (0.0, 0.035, -oh / 2 + 0.05), (sw + 0.14, 0.07, 0.10), SLOT_PLASTIC, 0.006)
+    # dark inner skirt behind the glass edge so no light leaks around it
+    box(bm, (0.0, 0.07, zc), (sw + 0.005, 0.08, sh + 0.005), SLOT_VENT, 0.0)
+    loft(bm, [(0.07, 0.235, 0.205, 0.0), (0.2, 0.225, 0.195, 0.0), (0.3, 0.17, 0.15, 0.0)], SLOT_PLASTIC, 0.008)
+    loft(bm, [(0.3, 0.1, 0.09, 0.0), (0.5, 0.075, 0.07, 0.0)], SLOT_PLASTIC, 0.004)
+    # glass sits just behind the bezel plane; bulge pokes forward past it
+    glass(bm, sw / 2 - 0.002, sh / 2 - 0.002, zc, 0.022)
+    # vent slots on the top shell
+    for i in range(9):
+        box(bm, (-0.12 + i * 0.03, 0.2, 0.2), (0.012, 0.09, 0.006), SLOT_VENT, 0.0)
+    for i in range(6):
+        box(bm, (0.17, 0.12 + i * 0.03, 0.0), (0.006, 0.014, 0.18), SLOT_VENT, 0.0)
+    # controls on the lower bar
+    cylinder(bm, (0.12, -0.012, -oh / 2 + 0.05), 0.014, 0.03, SLOT_PLASTIC)
+    cylinder(bm, (0.17, -0.012, -oh / 2 + 0.05), 0.014, 0.03, SLOT_PLASTIC)
+    box(bm, (-0.15, -0.002, -oh / 2 + 0.05), (0.05, 0.012, 0.018), SLOT_STEEL, 0.002)
+    box(bm, (0.065, -0.003, -oh / 2 + 0.05), (0.03, 0.01, 0.014), SLOT_PLASTIC, 0.002)
+    for i in range(5):
+        box(bm, (-0.075 - i * 0.012, 0.0, -oh / 2 + 0.075), (0.006, 0.008, 0.02), SLOT_VENT, 0.0)
+    cylinder(bm, (0.205, -0.004, -oh / 2 + 0.05), 0.0045, 0.008, SLOT_LED, seg=8)
+    me = bpy.data.meshes.new(name)
+    bm.to_mesh(me)
+    bm.free()
+    for p in me.polygons:
+        p.use_smooth = True
+    return me, (sw, sh)
+
+
+def add_cable(name, pts, radius, material, collection, seed=0, sag=0.0):
+    """NURBS tube through pts (list of xyz) with optional parabolic sag between ends."""
+    rng = random.Random(seed)
+    cu = bpy.data.curves.new(name, "CURVE")
+    cu.dimensions = "3D"
+    cu.bevel_depth = radius
+    cu.bevel_resolution = 3
+    cu.resolution_u = 10
+    sp = cu.splines.new("NURBS")
+    sp.points.add(len(pts) - 1)
+    n = len(pts) - 1
+    for i, p in enumerate(pts):
+        t = i / max(n, 1)
+        sp.points[i].co = (p[0] + rng.uniform(-0.01, 0.01), p[1] + rng.uniform(-0.01, 0.01), p[2] - sag * 4 * t * (1 - t), 1.0)
+    sp.order_u = 4
+    sp.use_endpoint_u = True
+    ob = bpy.data.objects.new(name, cu)
+    ob.data.materials.append(material)
+    collection.objects.link(ob)
+    return ob

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

@@ -0,0 +1,80 @@
+"""Hand-drawn 5x7 bitmap font (original glyph shapes, no font files) used for the CRT terminal text."""
+
+_G = {
+    "A": ".###.|#...#|#...#|#####|#...#|#...#|#...#",
+    "B": "####.|#...#|#...#|####.|#...#|#...#|####.",
+    "C": ".####|#....|#....|#....|#....|#....|.####",
+    "D": "####.|#...#|#...#|#...#|#...#|#...#|####.",
+    "E": "#####|#....|#....|####.|#....|#....|#####",
+    "F": "#####|#....|#....|####.|#....|#....|#....",
+    "G": ".####|#....|#....|#..##|#...#|#...#|.####",
+    "H": "#...#|#...#|#...#|#####|#...#|#...#|#...#",
+    "I": "#####|..#..|..#..|..#..|..#..|..#..|#####",
+    "J": "..###|...#.|...#.|...#.|...#.|#..#.|.##..",
+    "K": "#...#|#..#.|#.#..|##...|#.#..|#..#.|#...#",
+    "L": "#....|#....|#....|#....|#....|#....|#####",
+    "M": "#...#|##.##|#.#.#|#.#.#|#...#|#...#|#...#",
+    "N": "#...#|##..#|#.#.#|#..##|#...#|#...#|#...#",
+    "O": ".###.|#...#|#...#|#...#|#...#|#...#|.###.",
+    "P": "####.|#...#|#...#|####.|#....|#....|#....",
+    "Q": ".###.|#...#|#...#|#...#|#.#.#|#..#.|.##.#",
+    "R": "####.|#...#|#...#|####.|#.#..|#..#.|#...#",
+    "S": ".####|#....|#....|.###.|....#|....#|####.",
+    "T": "#####|..#..|..#..|..#..|..#..|..#..|..#..",
+    "U": "#...#|#...#|#...#|#...#|#...#|#...#|.###.",
+    "V": "#...#|#...#|#...#|#...#|#...#|.#.#.|..#..",
+    "W": "#...#|#...#|#...#|#.#.#|#.#.#|##.##|#...#",
+    "X": "#...#|#...#|.#.#.|..#..|.#.#.|#...#|#...#",
+    "Y": "#...#|#...#|.#.#.|..#..|..#..|..#..|..#..",
+    "Z": "#####|....#|...#.|..#..|.#...|#....|#####",
+    "0": ".###.|#..##|#.#.#|#.#.#|#.#.#|##..#|.###.",
+    "1": "..#..|.##..|..#..|..#..|..#..|..#..|.###.",
+    "2": ".###.|#...#|....#|...#.|..#..|.#...|#####",
+    "3": "####.|....#|....#|.###.|....#|....#|####.",
+    "4": "...#.|..##.|.#.#.|#..#.|#####|...#.|...#.",
+    "5": "#####|#....|####.|....#|....#|#...#|.###.",
+    "6": ".###.|#....|#....|####.|#...#|#...#|.###.",
+    "7": "#####|....#|...#.|..#..|.#...|.#...|.#...",
+    "8": ".###.|#...#|#...#|.###.|#...#|#...#|.###.",
+    "9": ".###.|#...#|#...#|.####|....#|....#|.###.",
+    ".": ".....|.....|.....|.....|.....|.##..|.##..",
+    ",": ".....|.....|.....|.....|.##..|..#..|.#...",
+    ":": ".....|.##..|.##..|.....|.##..|.##..|.....",
+    ";": ".....|.##..|.##..|.....|.##..|..#..|.#...",
+    "-": ".....|.....|.....|#####|.....|.....|.....",
+    "_": ".....|.....|.....|.....|.....|.....|#####",
+    "=": ".....|.....|#####|.....|#####|.....|.....",
+    "+": ".....|..#..|..#..|#####|..#..|..#..|.....",
+    "*": ".....|#.#.#|.###.|#####|.###.|#.#.#|.....",
+    "/": "....#|....#|...#.|..#..|.#...|#....|#....",
+    "\\": "#....|#....|.#...|..#..|...#.|....#|....#",
+    ">": "#....|.#...|..#..|...#.|..#..|.#...|#....",
+    "<": "....#|...#.|..#..|.#...|..#..|...#.|....#",
+    "[": ".###.|.#...|.#...|.#...|.#...|.#...|.###.",
+    "]": ".###.|...#.|...#.|...#.|...#.|...#.|.###.",
+    "(": "..#..|.#...|#....|#....|#....|.#...|..#..",
+    ")": "..#..|...#.|....#|....#|....#|...#.|..#..",
+    "#": ".#.#.|.#.#.|#####|.#.#.|#####|.#.#.|.#.#.",
+    "%": "##..#|##.#.|...#.|..#..|.#...|#.##.|#..##",
+    "!": "..#..|..#..|..#..|..#..|..#..|.....|..#..",
+    "?": ".###.|#...#|....#|...#.|..#..|.....|..#..",
+    "'": ".##..|..#..|.#...|.....|.....|.....|.....",
+    '"': ".#.#.|.#.#.|.....|.....|.....|.....|.....",
+    "@": ".###.|#...#|#.###|#.#.#|#.###|#....|.####",
+    "$": "..#..|.####|#.#..|.###.|..#.#|####.|..#..",
+    "&": ".##..|#..#.|#.#..|.#...|#.#.#|#..#.|.##.#",
+    "|": "..#..|..#..|..#..|..#..|..#..|..#..|..#..",
+    "~": ".....|.....|.#...|#.#.#|...#.|.....|.....",
+    "^": "..#..|.#.#.|#...#|.....|.....|.....|.....",
+    "{": "..##.|.#...|.#...|#....|.#...|.#...|..##.",
+    "}": ".##..|...#.|...#.|....#|...#.|...#.|.##..",
+    " ": ".....|.....|.....|.....|.....|.....|.....",
+    "BLOCK": "#####|#####|#####|#####|#####|#####|#####",
+    "CURSOR": "#####|#####|#####|#####|#####|#####|#####",
+}
+
+
+def glyph(ch):
+    """Return a 7x5 tuple-of-tuples (1 = lit) for ch; unknown characters render as blank."""
+    rows = _G.get(ch.upper(), _G[" "]).split("|")
+    return tuple(tuple(1 if c == "#" else 0 for c in r) for r in rows)

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

@@ -0,0 +1,61 @@
+"""Gallery variant: the CRT wall shown as a gallery installation (precise grid, powder-coat frame, concrete plinth, one bench)."""
+import bpy
+
+import crt
+import gallery_mats as G
+import gallery_room as GR
+import materials as M
+import textures
+import wall
+from crt import SLOT_GLASS
+
+# Screen content per tube, bottom row first, columns 0..4 mirrored to 9. a amber, g green, h green-b, c cold, . dark
+LAYOUT = ("g.aaa", "hgaaa", "gaaca", "hgaa.", "g.aaa")
+KEYS = {"a": "amber", "g": "green_a", "h": "green_b", "c": "cold"}
+
+
+def _screen_key(r, c):
+    ch = LAYOUT[r][min(c, wall.COLS - 1 - c)]
+    return KEYS.get(ch)
+
+
+def build_installation(coll, mats, screens):
+    mesh, _ = crt.build_crt_mesh()
+    for m in (mats["plastic"], mats["glass_base"], mats["vent"], mats["steel"], mats["pilot"]):
+        mesh.materials.append(m)
+    for r in range(wall.ROWS):
+        for c in range(wall.COLS):
+            ob = bpy.data.objects.new(f"crt_{r}_{c}", mesh)
+            x, y, _ = wall.monitor_position(r, c)
+            ob.location = (x, y, wall.BASE_Z + r * wall.PITCH + 0.22)
+            coll.objects.link(ob)
+            key = _screen_key(r, c)
+            slot = ob.material_slots[SLOT_GLASS]
+            slot.link = "OBJECT"
+            slot.material = screens[key] if key else mats["glass_off"]
+    GR.block(coll, "plinth", (5.7, 1.8, 0.24), (0, -0.3, 0.12), mats["plinth"], bevel=0.004)
+    GR.block(coll, "bench", (2.2, 0.44, 0.42), (0, -3.3, 0.21), mats["stone"], bevel=0.013)
+
+
+def build(scene, coll, a):
+    """Build the whole gallery and return the per-variant animation value nodes (scroll / time)."""
+    mats = {
+        "concrete": G.concrete_panel("g_wall"), "ceiling": G.concrete_panel("g_ceiling", holes=False, tone=0.36),
+        "floor": G.polished_floor(), "plinth": G.polished_floor("g_plinth", tone=0.07, joints=False),
+        "powder": G.powdercoat(), "reveal": G.reveal(), "stone": G.honed_stone(tone=0.42),
+        "slot": G.emitter("g_slot", (1.0, 0.96, 0.9), 14.0 * a.key),
+        "plastic": M.plastic(palette=((0.10, 0.104, 0.11),) * 3), "steel": M.steel(), "vent": M.vent_black(),
+        "pilot": M.led("pilot", (1.0, 0.55, 0.18), 5.0),
+        "glass_off": G.glass_off(),
+    }
+    mats["glass_base"] = mats["glass_off"]
+    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=90.0, strength=strength, zoom=0.5)
+    GR.build_world(scene, a.haze)
+    GR.build_shell(coll, mats)
+    GR.build_lights(coll, mats, a.key)
+    wall.build_rack(coll, {**mats, "steel": mats["powder"]})
+    build_installation(coll, mats, screens)
+    return anims

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

@@ -0,0 +1,144 @@
+"""Gallery-variant materials: architectural cast concrete panels, polished concrete floor, powder-coat, honed stone, emitters.
+
+Concrete panels read the panel's own object-space coordinates (X across, Z up) so tie holes land on every panel the same way;
+noise detail reads world position so the surface never repeats between neighbours.
+"""
+from nodekit import fresh, finish, math, remap, mix, vmath, rgb, principled, node
+
+
+def _noise(nt, vec, scale, detail=4.0, rough=0.55):
+    return node(nt, "ShaderNodeTexNoise", {"Vector": vec, "Scale": scale, "Detail": detail, "Roughness": rough}).outputs["Fac"]
+
+
+def _pores(nt, vec, scale, keep, r_lo, r_hi):
+    """Sparse little air-bubble dimples: a Voronoi cell hosts a pore only when its random value passes `keep`."""
+    v = node(nt, "ShaderNodeTexVoronoi", {"Vector": vec, "Scale": scale, "Randomness": 1.0}, feature="F1")
+    rgb_ = node(nt, "ShaderNodeSeparateColor", {"Color": v.outputs["Color"]})
+    sel = remap(nt, rgb_.outputs["Red"], keep, keep + 0.02, 0.0, 1.0, smooth=False)
+    radius = math(nt, "ADD", r_lo, math(nt, "MULTIPLY", rgb_.outputs["Green"], r_hi - r_lo))
+    shape = remap(nt, v.outputs["Distance"], math(nt, "MULTIPLY", radius, 0.25), radius, 1.0, 0.0)
+    return math(nt, "MULTIPLY", sel, shape)
+
+
+def _tie_holes(nt, local):
+    """Round form-tie recesses: 2 columns x 3 rows per 1.2 x 2.35 panel (Ando-style), in panel-local coordinates."""
+    sep = node(nt, "ShaderNodeSeparateXYZ", {"Vector": local})
+    u, v = sep.outputs["X"], sep.outputs["Z"]
+    dx = math(nt, "ABSOLUTE", math(nt, "SUBTRACT", math(nt, "ABSOLUTE", u), 0.3))
+    dz = math(nt, "MINIMUM", math(nt, "ABSOLUTE", v), math(nt, "ABSOLUTE", math(nt, "SUBTRACT", math(nt, "ABSOLUTE", v), 0.783)))
+    d = vmath(nt, "LENGTH", node(nt, "ShaderNodeCombineXYZ", {"X": dx, "Y": dz, "Z": 0.0}).outputs[0])
+    return remap(nt, d, 0.019, 0.029, 1.0, 0.0)
+
+
+def concrete_panel(name="g_concrete", holes=True, tone=0.30):
+    m, nt = fresh(name)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    local = node(nt, "ShaderNodeTexCoord").outputs["Object"]
+    rnd = node(nt, "ShaderNodeObjectInfo").outputs["Random"]
+    cloud = _noise(nt, pos, 0.45, 6.0, 0.6)
+    mottle = _noise(nt, pos, 4.0, 5.0, 0.6)
+    streaks = _noise(nt, vmath(nt, "MULTIPLY", pos, (9.0, 9.0, 0.8)), 1.0, 4.0, 0.5)
+    fine = _noise(nt, pos, 55.0, 5.0, 0.65)
+    grain = _noise(nt, pos, 240.0, 3.0, 0.7)
+    p1 = _pores(nt, pos, 70.0, 0.80, 0.10, 0.34)
+    p2 = _pores(nt, pos, 210.0, 0.86, 0.12, 0.40)
+    tie = _tie_holes(nt, local) if holes else 0.0
+
+    h = math(nt, "ADD", math(nt, "MULTIPLY", fine, 0.55), math(nt, "ADD", math(nt, "MULTIPLY", grain, 0.18), math(nt, "MULTIPLY", mottle, 0.3)))
+    h = math(nt, "SUBTRACT", h, math(nt, "ADD", math(nt, "MULTIPLY", p1, 1.1), math(nt, "MULTIPLY", p2, 0.6)))
+    if holes:
+        h = math(nt, "SUBTRACT", h, math(nt, "MULTIPLY", tie, 3.0))
+    bump = node(nt, "ShaderNodeBump", {"Height": h, "Strength": 0.38, "Distance": 0.004}).outputs["Normal"]
+
+    t = remap(nt, cloud, 0.3, 0.7, 0.80, 1.16)
+    t = math(nt, "MULTIPLY", t, remap(nt, mottle, 0.35, 0.65, 0.93, 1.07))
+    t = math(nt, "MULTIPLY", t, remap(nt, streaks, 0.35, 0.65, 0.93, 1.07))
+    t = math(nt, "MULTIPLY", t, math(nt, "ADD", 0.9, math(nt, "MULTIPLY", rnd, 0.2)))
+    t = math(nt, "MULTIPLY", t, math(nt, "SUBTRACT", 1.0, math(nt, "ADD", math(nt, "MULTIPLY", p1, 0.5), math(nt, "MULTIPLY", p2, 0.3))))
+    if holes:
+        t = math(nt, "MULTIPLY", t, math(nt, "SUBTRACT", 1.0, math(nt, "MULTIPLY", tie, 0.55)))
+    base = vmath(nt, "MULTIPLY", rgb(nt, tone, tone * 0.992, tone * 0.975), vmath(nt, "SCALE", rgb(nt, 1, 1, 1), t))
+    rough = math(nt, "ADD", 0.5, math(nt, "ADD", math(nt, "MULTIPLY", math(nt, "SUBTRACT", mottle, 0.5), 0.3), math(nt, "MULTIPLY", math(nt, "SUBTRACT", rnd, 0.5), 0.1)))
+    finish(nt, principled(nt, Base_Color=base, Roughness=rough, Normal=bump, Specular_IOR_Level=0.45))
+    return m
+
+
+def polished_floor(name="g_floor", tone=0.13, joints=True):
+    """Ground-and-sealed concrete: soft cloudy gloss, fine aggregate flecks, hairline saw-cut joints on a 2.4 m grid."""
+    m, nt = fresh(name)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    sep = node(nt, "ShaderNodeSeparateXYZ", {"Vector": pos})
+    cloud = _noise(nt, pos, 0.32, 6.0, 0.6)
+    swirl = _noise(nt, vmath(nt, "MULTIPLY", pos, (1.0, 1.0, 0.05)), 1.8, 3.0, 0.5)
+    fleck_l = _pores(nt, pos, 150.0, 0.90, 0.14, 0.30)
+    fleck_d = _pores(nt, pos, 110.0, 0.92, 0.16, 0.34)
+    gx = math(nt, "FRACT", math(nt, "DIVIDE", math(nt, "ADD", sep.outputs["X"], 1.2), 2.4))
+    gy = math(nt, "FRACT", math(nt, "DIVIDE", sep.outputs["Y"], 2.4))
+    jx = math(nt, "ADD", remap(nt, gx, 0.0, 0.0014, 1.0, 0.0), remap(nt, gx, 0.9986, 1.0, 0.0, 1.0))
+    jy = math(nt, "ADD", remap(nt, gy, 0.0, 0.0014, 1.0, 0.0), remap(nt, gy, 0.9986, 1.0, 0.0, 1.0))
+    joint = math(nt, "MULTIPLY", math(nt, "MAXIMUM", jx, jy), 1.0 if joints else 0.0)
+
+    t = math(nt, "MULTIPLY", remap(nt, cloud, 0.3, 0.7, 0.8, 1.15), remap(nt, swirl, 0.3, 0.7, 0.92, 1.08))
+    t = math(nt, "MULTIPLY", t, math(nt, "SUBTRACT", math(nt, "ADD", 1.0, math(nt, "MULTIPLY", fleck_l, 0.7)), math(nt, "MULTIPLY", fleck_d, 0.5)))
+    t = math(nt, "MULTIPLY", t, math(nt, "SUBTRACT", 1.0, math(nt, "MULTIPLY", joint, 0.75)))
+    base = vmath(nt, "MULTIPLY", rgb(nt, tone, tone * 0.99, tone * 0.97), vmath(nt, "SCALE", rgb(nt, 1, 1, 1), t))
+    rough = math(nt, "ADD", 0.05, math(nt, "ADD", math(nt, "MULTIPLY", remap(nt, cloud, 0.4, 0.7), 0.12), math(nt, "MULTIPLY", remap(nt, swirl, 0.4, 0.65), 0.08)))
+    rough = math(nt, "MAXIMUM", rough, math(nt, "MULTIPLY", joint, 0.6))
+    h = math(nt, "SUBTRACT", math(nt, "MULTIPLY", _noise(nt, pos, 70.0, 3.0, 0.6), 0.2), math(nt, "MULTIPLY", joint, 1.0))
+    bump = node(nt, "ShaderNodeBump", {"Height": h, "Strength": 0.12, "Distance": 0.003}).outputs["Normal"]
+    finish(nt, principled(nt, Base_Color=base, Roughness=rough, Normal=bump, Specular_IOR_Level=0.7, Coat_Weight=0.25, Coat_Roughness=0.06))
+    return m
+
+
+def powdercoat(name="g_powder", tone=0.028, rough=0.42):
+    m, nt = fresh(name)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    peel = _noise(nt, pos, 700.0, 2.0, 0.5)
+    bump = node(nt, "ShaderNodeBump", {"Height": peel, "Strength": 0.05, "Distance": 0.0003}).outputs["Normal"]
+    finish(nt, principled(nt, Base_Color=(tone, tone, tone * 1.04), Roughness=rough, Normal=bump, Specular_IOR_Level=0.55))
+    return m
+
+
+def reveal(name="g_reveal"):
+    """Near-black backing seen only through joints and shadow gaps."""
+    m, nt = fresh(name)
+    finish(nt, principled(nt, Base_Color=(0.012, 0.012, 0.013), Roughness=0.85))
+    return m
+
+
+def honed_stone(name="g_stone", tone=0.035):
+    """Honed limestone: soft cloudy tone, thin sedimentary veins along the length, fine hone grain, per-region gloss."""
+    m, nt = fresh(name)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    cloud = _noise(nt, pos, 1.4, 4.0, 0.5)
+    big = _noise(nt, pos, 0.55, 3.0, 0.5)
+    fleck = _pores(nt, pos, 260.0, 0.80, 0.12, 0.3)
+    strata = _noise(nt, vmath(nt, "MULTIPLY", pos, (0.35, 5.0, 2.5)), 1.0, 5.0, 0.55)
+    vein = remap(nt, math(nt, "ABSOLUTE", math(nt, "SUBTRACT", strata, 0.5)), 0.0, 0.035, 1.0, 0.0)
+    hone = _noise(nt, pos, 420.0, 3.0, 0.6)
+    t = math(nt, "MULTIPLY", remap(nt, cloud, 0.3, 0.7, 0.88, 1.12), remap(nt, big, 0.3, 0.7, 0.84, 1.14))
+    t = math(nt, "MULTIPLY", t, math(nt, "SUBTRACT", 1.0, math(nt, "ADD", math(nt, "MULTIPLY", fleck, 0.22), math(nt, "MULTIPLY", vein, 0.16))))
+    warm = remap(nt, big, 0.35, 0.65, 0.0, 1.0)
+    base = vmath(nt, "SCALE", mix(nt, warm, rgb(nt, tone * 0.97, tone, tone * 1.06), rgb(nt, tone * 1.05, tone * 1.0, tone * 0.93)), t)
+    rough = math(nt, "ADD", 0.22, math(nt, "ADD", math(nt, "MULTIPLY", math(nt, "SUBTRACT", cloud, 0.5), 0.3), math(nt, "MULTIPLY", vein, 0.08)))
+    bump = node(nt, "ShaderNodeBump", {"Height": math(nt, "SUBTRACT", hone, math(nt, "MULTIPLY", fleck, 1.2)), "Strength": 0.10, "Distance": 0.0006}).outputs["Normal"]
+    finish(nt, principled(nt, Base_Color=base, Roughness=rough, Normal=bump, Specular_IOR_Level=0.6, Coat_Weight=0.2, Coat_Roughness=0.1))
+    return m
+
+
+def glass_off(name="g_glass_off"):
+    """Powered-down CRT faceplate: dark tinted glass, a soft low-gloss reflection (dust and smudge keep it from mirroring the ceiling slots)."""
+    m, nt = fresh(name)
+    pos = node(nt, "ShaderNodeNewGeometry").outputs["Position"]
+    dust = _noise(nt, pos, 22.0, 5.0, 0.6)
+    smudge = _noise(nt, pos, 6.0, 3.0, 0.5)
+    rough = math(nt, "ADD", 0.2, math(nt, "MULTIPLY", math(nt, "MULTIPLY", remap(nt, smudge, 0.4, 0.75), remap(nt, dust, 0.4, 0.8)), 0.14))
+    finish(nt, principled(nt, Base_Color=(0.003, 0.0035, 0.0035), Roughness=rough, IOR=1.52, Specular_IOR_Level=0.3, Emission_Color=(0.02, 0.03, 0.025, 1.0), Emission_Strength=0.02))
+    return m
+
+
+def emitter(name, color, strength):
+    m, nt = fresh(name)
+    e = node(nt, "ShaderNodeEmission", {"Color": color, "Strength": strength})
+    finish(nt, e)
+    return m

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

@@ -0,0 +1,126 @@
+"""Gallery shell: board-panel concrete walls with reveal gaps, recessed-slot ceiling, polished floor, lights, haze."""
+import math
+
+import bmesh
+import bpy
+from mathutils import Matrix, Vector
+
+from nodekit import node
+
+HALF_W, Y_BACK, DEPTH, HEIGHT = 4.2, 0.62, 14.4, 4.8
+Y_FRONT = Y_BACK - DEPTH
+PW, PH, GAP, PT, Z0 = 1.2, 2.35, 0.005, 0.03, 0.05
+SLOTS_X = (-2.1, 0.0, 2.1)
+SLOT_W = 0.12
+_MESHES = {}
+
+
+def block(coll, name, size, loc, mat, rot=(0.0, 0.0, 0.0), bevel=0.002):
+    """Box mesh centred on its own origin (front face = local -Y), placed by the object transform."""
+    key = (tuple(round(s, 4) for s in size), bevel, mat.name)
+    me = _MESHES.get(key)
+    if me is None:
+        bm = bmesh.new()
+        bmesh.ops.create_cube(bm, size=1.0, matrix=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)
+        _MESHES[key] = me
+    ob = bpy.data.objects.new(name, me)
+    ob.location, ob.rotation_euler = loc, rot
+    coll.objects.link(ob)
+    return ob
+
+
+def _wall(coll, mats, name, centre_of, rot, count):
+    """Two rows of 1.2 m panels; centre_of(i) -> (x, y) of panel i's centre line, panel faces -> room."""
+    for i in range(count):
+        x, y = centre_of(i)
+        for r in range(2):
+            z = Z0 + PH / 2 + r * PH
+            block(coll, f"{name}_{i}_{r}", (PW - GAP, PT, PH - GAP), (x, y, z), mats["concrete"], rot)
+
+
+def build_shell(coll, mats):
+    conc, rev = mats["concrete"], mats["reveal"]
+    L = DEPTH + 1.0
+    block(coll, "floor", (2 * HALF_W + 1.6, L, 0.5), (0, Y_BACK - DEPTH / 2, -0.25), mats["floor"], bevel=0.0)
+    block(coll, "back_rev", (2 * HALF_W + 1.0, 0.3, HEIGHT + 0.4), (0, Y_BACK + PT + 0.15, HEIGHT / 2), rev, bevel=0.0)
+    block(coll, "front_wall", (2 * HALF_W + 1.0, 0.3, HEIGHT + 0.4), (0, Y_FRONT - 0.15, HEIGHT / 2), conc, bevel=0.0)
+    for sx in (-1, 1):
+        block(coll, f"side_rev_{sx}", (0.3, L, HEIGHT + 0.4), (sx * (HALF_W + PT + 0.15), Y_BACK - DEPTH / 2, HEIGHT / 2), rev, bevel=0.0)
+    block(coll, "roof_rev", (2 * HALF_W + 1.0, L, 0.3), (0, Y_BACK - DEPTH / 2, HEIGHT + PT + 0.15), rev, bevel=0.0)
+    nb, ns = int(2 * HALF_W / PW + 0.5), int(DEPTH / PW + 0.5)
+    _wall(coll, mats, "back", lambda i: (-HALF_W + PW / 2 + i * PW, Y_BACK + PT / 2), (0, 0, 0), nb)
+    _wall(coll, mats, "right", lambda i: (HALF_W + PT / 2, Y_BACK - PW / 2 - i * PW), (0, 0, math.radians(-90)), ns)
+    _wall(coll, mats, "left", lambda i: (-HALF_W - PT / 2, Y_BACK - PW / 2 - i * PW), (0, 0, math.radians(90)), ns)
+    build_ceiling(coll, mats)
+
+
+def build_ceiling(coll, mats):
+    """Concrete soffit panels with three flush linear light slots running toward the installation."""
+    edges = [-HALF_W - 0.05]
+    for sx in SLOTS_X:
+        edges += [sx - SLOT_W / 2, sx + SLOT_W / 2]
+    edges.append(HALF_W + 0.05)
+    nchunk = int(DEPTH / 2.4 + 0.5)
+    for k in range(0, len(edges), 2):
+        x0, x1 = edges[k], edges[k + 1]
+        for j in range(nchunk):
+            y = Y_BACK - 1.2 - j * 2.4
+            block(coll, f"ceil_{k}_{j}", (x1 - x0 - GAP, PT, 2.4 - GAP), ((x0 + x1) / 2, y, HEIGHT + PT / 2), mats["ceiling"], (math.radians(90), 0, 0))
+    for i, sx in enumerate(SLOTS_X):
+        block(coll, f"slot_{i}", (SLOT_W - 0.01, DEPTH, 0.02), (sx, Y_BACK - DEPTH / 2, HEIGHT + 0.015), mats["slot"], bevel=0.0)
+
+
+def _aim(ob, target):
+    ob.rotation_euler = (Vector(target) - Vector(ob.location)).to_track_quat("-Z", "Y").to_euler()
+
+
+def _spot(coll, mats, name, loc, target, energy, cone=26.0):
+    """Track spot with a visible black barrel; the beam is aimed at `target` (grazing the concrete)."""
+    sp = bpy.data.lights.new(name, "SPOT")
+    sp.color, sp.energy = (1.0, 0.95, 0.88), energy
+    sp.spot_size, sp.spot_blend, sp.shadow_soft_size = math.radians(cone), 0.85, 0.045
+    so = bpy.data.objects.new(name, sp)
+    so.location = loc
+    _aim(so, target)
+    so.visible_camera = False
+    coll.objects.link(so)
+    back = so.rotation_euler.to_matrix() @ Vector((0.0, 0.0, 0.095))
+    block(coll, f"head_{name}", (0.085, 0.085, 0.17), Vector(loc) + back, mats["powder"], tuple(so.rotation_euler), bevel=0.01)
+
+
+def build_lights(coll, mats, key=1.0):
+    wash = bpy.data.lights.new("wash", "AREA")
+    wash.shape, wash.size, wash.size_y, wash.spread = "RECTANGLE", 2 * HALF_W - 0.4, 0.12, math.radians(75)
+    wash.color, wash.energy = (1.0, 0.97, 0.92), 300.0 * key
+    wo = bpy.data.objects.new("wash", wash)
+    wo.location = (0, Y_BACK - 0.34, HEIGHT - 0.08)
+    wo.visible_camera = False
+    coll.objects.link(wo)
+    z = HEIGHT - 0.12
+    for sx in (-1, 1):
+        block(coll, f"rail_{sx}", (0.035, DEPTH - 0.4, 0.03), (sx * (HALF_W - 0.5), Y_BACK - DEPTH / 2, HEIGHT - 0.015), mats["powder"], bevel=0.003)
+        for k in range(6):
+            y = Y_BACK - 1.0 - k * 1.8
+            _spot(coll, mats, f"side_{sx}_{k}", (sx * (HALF_W - 0.5), y, z), (sx * HALF_W, y - 0.05, 1.1), 520.0 * key)
+    block(coll, "rail_back", (2 * HALF_W - 0.6, 0.035, 0.03), (0, Y_BACK - 0.5, HEIGHT - 0.015), mats["powder"], bevel=0.003)
+    for sx, tx, tz in ((-1, 3.4, 0.9), (1, 3.4, 0.9), (-1, 1.15, 3.1), (1, 1.15, 3.1)):
+        _spot(coll, mats, f"back_{sx}_{tx}", (sx * tx, Y_BACK - 0.5, z), (sx * tx, Y_BACK, tz), 420.0 * key, cone=24.0)
+
+
+def build_world(scene, haze=1.0):
+    world = bpy.data.worlds.new("gallery")
+    scene.world = world
+    world.use_nodes = True
+    nt = world.node_tree
+    nt.nodes.clear()
+    bg = node(nt, "ShaderNodeBackground", {"Color": (0.0, 0.0, 0.0, 1.0), "Strength": 0.0})
+    out = node(nt, "ShaderNodeOutputWorld")
+    nt.links.new(bg.outputs[0], out.inputs["Surface"])
+    vol = node(nt, "ShaderNodeVolumeScatter", {"Density": 0.0011 * haze, "Anisotropy": 0.35, "Color": (1.0, 1.0, 1.0, 1.0)})
+    nt.links.new(vol.outputs[0], out.inputs["Volume"])