agent

+2:39
reasoning

Initial setup confirms system resources and required tools are present: CPU, RAM, Blender, FFmpeg, Node, and Playwright are all available. The pathing for Blender appears correctly configured, based on both the system environment and project package information.

  • read_file{"EndLine":140,"Path":"~/work/sortie/kit/frame_std.py","StartLine":1}

    input

    {
      "EndLine": 140,
      "Path": "~/work/sortie/kit/frame_std.py",
      "StartLine": 1
    }

    result, 141 lines

    Showing lines 1-140 of 435
    1: """The standard class inner frame (17.6 m), shared by every maker (docs/visual-language.md).
    2: 
    3: Dark roles only: frame for bones and blocks, joint for housings, cables and pistons, metal for the
    4: mount pad locks, the cockpit socket rim and the ankle pins, trim for the ring on every mount pad.
    5: Joint names and positions are the striker's (mech.joints), so poses, muzzles and harken mounts carry
    6: over. bend_knees stands the knees forward and the feet apart after the plates are on. Plates come
    7: from a maker family (kit/makers) and ride the same joints.
    8: 
    9: The frame shows at the sides and back of the neck, waist, shoulders, elbows, wrists, knees and ankles
    10: under every grade. The foot is a ball ankle in the shin's yoke, an arched sole and a hinged toe.
    11: Pistons at the hips, shoulders, elbows, knees and ankles, a cable run down every long bone. The chest
    12: carries the cockpit socket in front and the reactor drum behind it, visible through the open sides.
    13: Mount pads (one shape, `pad`) at the forearms, shoulders, backpack and hips, each with a mount.* empty.
    14: 
    15: Geometry is authored on the left (+X) in world rest pose coordinates and mirrored.
    16: """
    17: import math
    18: 
    19: import bpy
    20: from mathutils import Matrix, Vector
    21: 
    22: from lib import circle, cylinder, empty, loft, merge, mirror_x, octo, piston, rot, solid, transform, two_view
    23: from mech import gltf_dir, joints as striker_joints
    24: 
    25: HEIGHT = 17.6
    26: BEVEL = .04
    27: PAD = .72  # mount pad edge
    28: PAD_T = .08
    29: ROOF = 15.13  # the shoulder pad sits on the pauldron roof, the same height for every grade
    30: 
    31: 
    32: def box(x0, x1, y0, y1, z0, z1):
    33:     r = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
    34:     return loft([(z0, r), (z1, r)])
    35: 
    36: 
    37: def rod(p0, p1, r, n=6):
    38:     """A plain cylinder from p0 to p1."""
    39:     p0, p1 = Vector(p0), Vector(p1)
    40:     a = p1 - p0
    41:     m = Matrix.Translation(p0) @ Vector((0, 0, 1)).rotation_difference(a.normalized()).to_matrix().to_4x4()
    42:     return transform(loft([(0, circle(r, n)), (a.length, circle(r, n))]), m)
    43: 
    44: 
    45: def basis(at, normal, up):
    46:     """A matrix whose local +Z is `normal` and local +Y is `up`, placed at `at`."""
    47:     z = Vector(normal).normalized()
    48:     y = Vector(up)
    49:     y = (y - z * y.dot(z)).normalized()
    50:     x = y.cross(z)
    51:     m = Matrix((x, y, z)).transposed().to_4x4()
    52:     m.translation = Vector(at)
    53:     return m
    54: 
    55: 
    56: def joints(tag="frame_std"):
    57:     """The striker's 22 joint rig, exact names and positions, tagged with this frame's name."""
    58:     J = striker_joints()
    59:     J["frame"]["frame"] = tag
    60:     J["frame"]["height"] = HEIGHT
    61:     return J
    62: 
    63: 
    64: def lr(J, part):
    65:     return J[part, "L"], J[part, "R"]
    66: 
    67: 
    68: def pair(name, bm_left, role, jl, jr, **kw):
    69:     bm_right = mirror_x(bm_left)
    70:     return solid(f"{name}.L", bm_left, role, jl, **kw), solid(f"{name}.R", bm_right, role, jr, **kw)
    71: 
    72: 
    73: def cable(name, pts, parent_l, parent_r=None, r=.055):
    74:     """A cable run along a bone, inside a square duct through the points, a clamp at every inner point.
    75:     Seen from behind it reads as a covered run, not a loose hose."""
    76:     duct = merge(*[rod(a, b, r * 1.6, n=4) for a, b in zip(pts, pts[1:])])
    77:     clamps = merge(*[box(p[0] - .1, p[0] + .1, p[1] - .1, p[1] + .1, p[2] - .06, p[2] + .06) for p in pts[1:-1]]) if len(pts) > 2 else None
    78:     if parent_r is None:
    79:         solid(f"{name}", duct, "frame", parent_l, .01)
    80:         if clamps:
    81:             solid(f"{name}_clamp", clamps, "joint", parent_l)
    82:     else:
    83:         pair(name, duct, "frame", parent_l, parent_r, bevel=.01)
    84:         if clamps:
    85:             pair(f"{name}_clamp", clamps, "joint", parent_l, parent_r)
    86: 
    87: 
    88: def tube(name, rings, at, parents, collars=(), n=10):
    89:     """A long bone: a faceted tube through (height, radius) rings, a joint collar at each height in
    90:     `collars`."""
    91:     pair(name, loft([(z, circle(r, n, *at)) for z, r in rings]), "frame", *parents, bevel=.03)
    92:     radius = lambda z: next(r0 + (r1 - r0) * (z - z0) / (z1 - z0) for (z0, r0), (z1, r1) in zip(rings, rings[1:]) if z0 <= z <= z1)
    93:     if collars:
    94:         cs = [loft([(z - .08, circle(radius(z) + .06, n, *at)), (z + .08, circle(radius(z) + .06, n, *at))]) for z in collars]
    95:         pair(f"{name}_collar", merge(*cs), "joint", *parents, bevel=.015)
    96: 
    97: 
    98: def pad(name, parent, at, normal, up=(0, 0, 1)):
    99:     """The common pattern mount pad: a square plate with clipped corners, four bolt bosses and a lock
    100:     ring in the middle. Every maker builds to it, so it always reads the same. `at` is the centre of
    101:     the pad's back, `normal` the way it faces. A mount.<name> empty marks the face."""
    102:     m = basis(at, normal, up)
    103:     h = PAD / 2
    104:     plate = loft([(0, octo(PAD, PAD, .12)), (PAD_T, octo(PAD, PAD, .12))])
    105:     rim = loft([(PAD_T, octo(PAD * .62, PAD * .62, .06)), (PAD_T + .025, octo(PAD * .62, PAD * .62, .06))])
    106:     lock = merge(loft([(PAD_T, circle(.15, 10)), (PAD_T + .07, circle(.15, 10))]),
    107:                  loft([(PAD_T + .07, circle(.07, 8)), (PAD_T + .1, circle(.07, 8))]))
    108:     k = h - .1
    109:     bosses = merge(*[box(x - .045, x + .045, y - .045, y + .045, PAD_T, PAD_T + .05) for x in (-k, k) for y in (-k, k)])
    110:     solid(f"pad_{name}", transform(plate, m), "frame", parent, .015)
    111:     solid(f"pad_{name}_rim", transform(rim, m), "trim", parent)
    112:     solid(f"pad_{name}_lock", transform(lock, m), "metal", parent, .01)
    113:     solid(f"pad_{name}_bolts", transform(bosses, m), "joint", parent)
    114:     face = Vector(at) + Vector(normal).normalized() * (PAD_T + .1)
    115:     empty(f"mount.{name}", face, parent, dir=gltf_dir(normal), size=PAD)
    116: 
    117: 
    118: def mirror(p):
    119:     return (-p[0], p[1], p[2])
    120: 
    121: 
    122: # Pad sites on the left, mirrored on the right: (joint, centre of the pad back, normal, up).
    123: PADS = {
    124:     "forearm": ("forearm", (3.08, 0, 10.42), (1, 0, 0), (0, 0, 1)),
    125:     "shoulder": ("shoulder", (2.42, .12, ROOF), (0, 0, 1), (0, -1, 0)),
    126:     "hip": ("pelvis", (2.04, 0, 10.92), (1, 0, 0), (0, 0, 1)),
    127: }
    128: BACK_PAD = ((0, 1.56, 13.8), (0, 1, 0), (0, 0, 1))
    129: 
    130: 
    131: def build_pelvis(J):
    132:     P = J["pelvis"]
    133:     solid("pelvis_block", loft([(9.85, octo(1.1, .95, .25)), (10.35, octo(1.6, 1.25, .3)), (10.98, octo(1.5, 1.2, .3))]),
    134:           "frame", P, BEVEL)
    135:     # hip arms reach out over the thighs and carry the holster pads
    136:     pair("hip_arm", box(.6, 1.98, -.32, .32, 10.62, 11.04), "frame", P, P, bevel=BEVEL)
    137:     pair("hip_arm_web", box(.6, 1.0, -.25, .25, 10.2, 10.62), "frame", P, P, bevel=.02)
    138:     pair("hip_socket", cylinder(.5, .55, .8, 12, axis="x", at=(0, 10.55)), "joint", P, P, smooth=True)
    139:     for s, sx in (("L", 1), ("R", -1)):
    140:         j, at, nm, up = PADS["hip"]
  • read_file{"EndLine":140,"Path":"~/work/sortie/kit/lab/knightkit.py","StartLine":1}

    input

    {
      "EndLine": 140,
      "Path": "~/work/sortie/kit/lab/knightkit.py",
      "StartLine": 1
    }

    result, 141 lines

    Showing lines 1-140 of 535
    1: """Sheets with compound curvature for the atelier direction board (kit/lab/atelier_board.py).
    2: 
    3: Round 1's plates are cones and cylinders of even thickness: shell() intersects two flat outlines, so
    4: it can only make flat and single curved faces. Knightly armour reads through domes, a curved profile
    5: down every plate, raised ridges, flutes and rolled rims. These helpers make them:
    6: 
    7:   Sheet     a plate t thick over a surface f(u, v): the outer face, the inner face set back along the
    8:             normals, closed round its edges. `disp` pushes the outer face out (ridges, flutes).
    9:   revolve   a surface of revolution round a vertical axis, elliptical in plan, through a profile of
    10:             (radius, z) points: the profile curves, so the plate is domed, not a cone
    11:   bead      a tube along a line of points: a rolled rim on a plate's edge, roped with `rope`
    12:   ridge, flutes   displacement profiles across u
    13: 
    14: Angles are degrees in plan, 0 is +X (outboard on the left), -90 the front (-Y), 90 the back.
    15: """
    16: import math
    17: 
    18: import bmesh
    19: from mathutils import Vector
    20: 
    21: 
    22: def lin(a, b, n):
    23:     """n + 1 values from a to b."""
    24:     return [a + (b - a) * i / n for i in range(n + 1)]
    25: 
    26: 
    27: def spline(pts):
    28:     """A Catmull-Rom curve through points (tuples), as a function of t in [0, 1]."""
    29:     P = [Vector(p) for p in pts]
    30:     n = len(P) - 1
    31: 
    32:     def at(t):
    33:         x = min(max(t, 0.0), 1.0) * n
    34:         i = min(int(x), n - 1)
    35:         s = x - i
    36:         p0, p1, p2, p3 = P[max(i - 1, 0)], P[i], P[i + 1], P[min(i + 2, n)]
    37:         return .5 * ((2 * p1) + (-p0 + p2) * s + (2 * p0 - 5 * p1 + 4 * p2 - p3) * s * s + (-p0 + 3 * p1 - 3 * p2 + p3) * s ** 3)
    38:     return at
    39: 
    40: 
    41: class Sheet:
    42:     """A plate t thick over f(u, v) on the grid us x vs. `inside` is a point on the plate's inner side
    43:     (default: the centroid of the surface, right for domes and shells round a body). `disp(u, v)`
    44:     moves the outer face out along the normal. `wrap` closes the sheet round u."""
    45: 
    46:     def __init__(self, f, us, vs, t, disp=None, inside=None, wrap=False):
    47:         self.us, self.vs, self.t, self.wrap = list(us), list(vs), t, wrap
    48:         nu, nv = len(self.us), len(self.vs)
    49:         S = [[Vector(f(u, v)) for v in self.vs] for u in self.us]
    50: 
    51:         def nrm(i, j):
    52:             if wrap:
    53:                 a, b = S[(i + 1) % nu][j], S[(i - 1) % nu][j]
    54:             else:
    55:                 a, b = S[min(i + 1, nu - 1)][j], S[max(i - 1, 0)][j]
    56:             c, d = S[i][min(j + 1, nv - 1)], S[i][max(j - 1, 0)]
    57:             n = (a - b).cross(c - d)
    58:             return n.normalized() if n.length > 1e-9 else None
    59:         N = [[nrm(i, j) for j in range(nv)] for i in range(nu)]
    60:         # a pole (a cap drawn from v = 0) has no normal of its own: it takes the mean of the next row's
    61:         for j in range(nv):
    62:             if any(N[i][j] is None for i in range(nu)):
    63:                 k = j + 1 if j + 1 < nv else j - 1
    64:                 m = sum((n for n in (N[i][k] for i in range(nu)) if n is not None), Vector())
    65:                 m = m.normalized() if m.length > 1e-9 else Vector((0, 0, 1))
    66:                 for i in range(nu):
    67:                     if N[i][j] is None:
    68:                         N[i][j] = m
    69:         c = Vector(inside) if inside is not None else sum((p for row in S for p in row), Vector()) / (nu * nv)
    70:         if sum(N[i][j].dot(S[i][j] - c) for i in range(nu) for j in range(nv)) < 0:
    71:             N = [[-n for n in row] for row in N]
    72:         if disp is not None:
    73:             S = [[S[i][j] + N[i][j] * disp(self.us[i], self.vs[j]) for j in range(nv)] for i in range(nu)]
    74:         self.O, self.N = S, N
    75:         self.I = [[S[i][j] - N[i][j] * t for j in range(nv)] for i in range(nu)]
    76: 
    77:     def bm(self):
    78:         bm = bmesh.new()
    79:         nu, nv = len(self.us), len(self.vs)
    80:         O = [[bm.verts.new(p) for p in row] for row in self.O]
    81:         I = [[bm.verts.new(p) for p in row] for row in self.I]
    82:         iu = range(nu) if self.wrap else range(nu - 1)
    83:         for i in iu:
    84:             k = (i + 1) % nu
    85:             for j in range(nv - 1):
    86:                 bm.faces.new((O[i][j], O[k][j], O[k][j + 1], O[i][j + 1]))
    87:                 bm.faces.new((I[i][j + 1], I[k][j + 1], I[k][j], I[i][j]))
    88:             bm.faces.new((O[i][0], I[i][0], I[k][0], O[k][0]))
    89:             bm.faces.new((O[k][-1], I[k][-1], I[i][-1], O[i][-1]))
    90:         if not self.wrap:
    91:             for j in range(nv - 1):
    92:                 bm.faces.new((O[0][j + 1], I[0][j + 1], I[0][j], O[0][j]))
    93:                 bm.faces.new((O[-1][j], I[-1][j], I[-1][j + 1], O[-1][j + 1]))
    94:         bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-6)  # closes a pole
    95:         bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
    96:         return bm
    97: 
    98:     def edge(self, side, at=.5, out=0.0):
    99:         """Points along one edge (u0, u1, v0, v1), `at` of the way through the thickness, pushed `out`
    100:         along the normal."""
    101:         nu, nv = len(self.us), len(self.vs)
    102:         idx = {"u0": [(0, j) for j in range(nv)], "u1": [(nu - 1, j) for j in range(nv)],
    103:                "v0": [(i, 0) for i in range(nu)], "v1": [(i, nv - 1) for i in range(nu)]}[side]
    104:         return [self.O[i][j] - self.N[i][j] * (self.t * at - out) for i, j in idx]
    105: 
    106:     def point(self, i, j, out=0.0):
    107:         return self.O[i][j] + self.N[i][j] * out
    108: 
    109: 
    110: def revolve(c, profile, kx=1.0, ky=1.0, steps=40):
    111:     """f(u, v) for a surface round a vertical axis through c = (x, y): u the plan angle in degrees, v in
    112:     [0, 1] along the profile, a list of (radius, z) points (or a function of v). kx and ky stretch the
    113:     plan into an ellipse. A profile that curves makes the plate domed."""
    114:     prof = profile if callable(profile) else spline(profile)
    115: 
    116:     def f(u, v):
    117:         r, z = prof(v)[:2]
    118:         a = math.radians(u)
    119:         return (c[0] + r * kx * math.cos(a), c[1] + r * ky * math.sin(a), z)
    120:     return f
    121: 
    122: 
    123: def tent(x, x0, w):
    124:     """1 at x0, falling linearly to 0 at x0 +- w: a ridge with a crease on its crest."""
    125:     return max(0.0, 1.0 - abs(x - x0) / w)
    126: 
    127: 
    128: def flutes(x, x0, x1, n, w=.5):
    129:     """n rounded flutes between x0 and x1, each `w` of its pitch wide, 0 between them."""
    130:     if not (x0 <= x <= x1):
    131:         return 0.0
    132:     s = (x - x0) / (x1 - x0) * n
    133:     f = s - math.floor(s)
    134:     d = abs(f - .5) / (w / 2)
    135:     return math.cos(min(d, 1.0) * math.pi / 2) ** 2 if d < 1 else 0.0
    136: 
    137: 
    138: def smooth(x, a, b):
    139:     """0 below a, 1 above b, smooth between."""
    140:     t = min(max((x - a) / (b - a), 0.0), 1.0)
  • read_file{"EndLine":140,"Path":"~/work/sortie/kit/light.py","StartLine":1}

    input

    {
      "EndLine": 140,
      "Path": "~/work/sortie/kit/light.py",
      "StartLine": 1
    }

    result, 141 lines

    Showing lines 1-140 of 908
    1: """Light frames: 6 m machines in the knightmare class (docs/sizes.md, docs/light-frames.md). Same joint
    2: names as the striker (src/render/mech.ts JOINTS) plus their own: core (the ejectable cockpit block,
    3: with the cockpit seat inside, parent of the backpack and the harkens), harken.L/R (wire anchor
    4: launchers at the muzzles) and spinner.L/R (heel wheel axles).
    5: 
    6: Proportions from the knightmare study: hip at 54% of the height, a small head with the crest
    7: reaching the full height, long arms (hands hang at about 0.42), a narrow waist. The core block is a
    8: quarter of the height tall, as wide as the chest and tops out behind the head. At this size the
    9: armour is fewer, larger plates: sculpted shells (two_view cages smoothed with creases) split by real
    10: seams, over a dark inner frame with the hip, knee and elbow mechanics showing.
    11: 
    12: Variants:
    13:   knight   the lead frame: armet helm with one visor slit and a raked crest, upswept pauldrons with
    14:            three lames, long pointed tassets, fenders over the heel wheels, broad float blades
    15:   line     the mass-produced grunt in the accent colour: rounded factsphere helm (domed lids that
    16:            swing open on hinges), slab chest and pauldrons with louvres, a wide boxy block, stub blades
    17:   lancer   the fast assault frame: swept wedge helm with a long blade crest, prow chest, calf
    18:            thrusters, folding forearm blades, a long block and swept delta blades
    19: 
    20: Left is +X, the model faces -Y, z up, authored in world rest-pose coordinates.
    21: """
    22: from mathutils import Matrix, Vector
    23: 
    24: import bpy
    25: from lib import (attach, boolean, circle, clip, copy, cylinder, empty, halves, loft, merge, mirror_x, nozzle, octo, panels, piston, prism, rot,
    26:                  solid,
    27:                  subd, transform, two_view)
    28: from figure import pilot
    29: from mech import gltf_dir, nozzle_pair, place
    30: 
    31: H = 6.0
    32: 
    33: 
    34: # ---- helpers ----------------------------------------------------------------------------------------------
    35: def sc(front, side, top=None, sharp=40, levels=2):
    36:     """A sculpted shell: a two_view cage, smoothed, creased where its faces meet sharper than `sharp`."""
    37:     return subd(two_view(front, side, top), levels, sharp)
    38: 
    39: 
    40: SWAP = {}  # role remap for the frame being built: the grunt wears the accent as its body colour
    41: 
    42: 
    43: def put(name, bm, role, j, **kw):
    44:     kw.setdefault("smooth", True)
    45:     return solid(name, bm, SWAP.get(role, role), j, **kw)
    46: 
    47: 
    48: def two(name, bm, role, jl, jr, **kw):
    49:     """The left part and its mirror on the right."""
    50:     kw.setdefault("smooth", True)
    51:     r = mirror_x(bm)
    52:     role = SWAP.get(role, role)
    53:     return solid(f"{name}.L", bm, role, jl, **kw), solid(f"{name}.R", r, role, jr, **kw)
    54: 
    55: 
    56: def centre(bm):
    57:     return sum((v.co for v in bm.verts), Vector()) / max(len(bm.verts), 1)
    58: 
    59: 
    60: def split(bm, cuts, gap=.025):
    61:     return panels(bm, [(Vector(c), Vector(n)) for c, n in cuts], gap)
    62: 
    63: 
    64: def box(x0, x1, y0, y1, z0, z1):
    65:     rect = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
    66:     return loft([(z0, rect), (z1, rect)])
    67: 
    68: 
    69: def sphere(r, at, n=16, rings=8):
    70:     import math
    71:     pts = []
    72:     for i in range(1, rings):
    73:         a = math.pi * i / rings
    74:         pts.append((at[2] - r * math.cos(a), circle(r * math.sin(a), n, at[0], at[1])))
    75:     return subd(loft(pts), 1, 90)
    76: 
    77: 
    78: def lr(J, part):
    79:     return J[part, "L"], J[part, "R"]
    80: 
    81: 
    82: def mat(at, rx=0.0, ry=0.0, rz=0.0):
    83:     return Matrix.Translation(Vector(at)) @ rot("Z", rz) @ rot("Y", ry) @ rot("X", rx)
    84: 
    85: 
    86: # ---- skeleton ---------------------------------------------------------------------------------------------
    87: def joints(variant):
    88:     J = {"frame": empty("frame", (0, 0, 0), frame=f"light_{variant}", height=H)}
    89:     J["pelvis"] = empty("pelvis", (0, 0, 3.3), J["frame"])
    90:     J["waist"] = empty("waist", (0, 0, 3.48), J["pelvis"])
    91:     J["torso"] = empty("torso", (0, 0, 3.78), J["waist"])
    92:     J["neck"] = empty("neck", (0, 0, 5.02), J["torso"])
    93:     J["head"] = empty("head", (0, 0, 5.2), J["neck"])
    94:     back = CORE[variant]["back"]
    95:     J["core"] = empty("core", (0, .65, 5.05), J["torso"], ejectable=True)
    96:     J["cockpit"] = empty("cockpit", (0, .62, 5.05), J["core"])
    97:     J["backpack"] = empty("backpack", (0, back + .1, 5.35), J["core"])
    98:     for s, sx in (("L", 1), ("R", -1)):
    99:         J["shoulder", s] = empty(f"shoulder.{s}", (.62 * sx, 0, 4.8), J["torso"])
    100:         J["upperarm", s] = empty(f"upperarm.{s}", (.82 * sx, 0, 4.74), J["shoulder", s])
    101:         J["forearm", s] = empty(f"forearm.{s}", (.84 * sx, 0, 3.92), J["upperarm", s])
    102:         J["hand", s] = empty(f"hand.{s}", (.85 * sx, 0, 3.04), J["forearm", s])
    103:         J["grip", s] = empty(f"grip.{s}", (.83 * sx, -.01, 2.86), J["hand", s])
    104:         J["thigh", s] = empty(f"thigh.{s}", (.36 * sx, 0, 3.24), J["pelvis"])
    105:         J["shin", s] = empty(f"shin.{s}", (.4 * sx, 0, 1.78), J["thigh", s])
    106:         J["foot", s] = empty(f"foot.{s}", (.4 * sx, .03, .4), J["shin", s])
    107:         J["spinner", s] = empty(f"spinner.{s}", (.4 * sx, .42, .31), J["foot", s])
    108:         J["binder", s] = empty(f"binder.{s}", (.42 * sx, back + .14, 5.52), J["backpack"])
    109:     return J
    110: 
    111: 
    112: # ---- the dark inner frame, shared --------------------------------------------------------------------------
    113: def inner(J, n):
    114:     P, W, T, N = J["pelvis"], J["waist"], J["torso"], J["neck"]
    115:     put(f"{n}_pelvis_core", loft([(2.98, octo(.4, .38, .1)), (3.2, octo(.64, .48, .14)), (3.46, octo(.56, .44, .12))]), "frame", P,
    116:         smooth=False, bevel=.015)
    117:     two(f"{n}_hip_ball", cylinder(.13, .18, .5, 12, axis="x", at=(0, 3.24)), "joint", *lr(J, "thigh"))
    118:     put(f"{n}_abdomen", loft([(3.36, octo(.42, .36, .1)), (3.6, octo(.36, .32, .09)), (3.92, octo(.46, .4, .11))]), "joint", W,
    119:         smooth=False, bevel=.012)
    120:     put(f"{n}_chest_core", loft([(3.8, octo(.5, .42, .12, y=.02)), (4.1, octo(.8, .56, .16)), (4.55, octo(1.0, .64, .18)),
    121:                                  (4.92, octo(.92, .58, .16)), (5.06, octo(.46, .36, .1))]), "frame", T, smooth=False, bevel=.015)
    122:     put(f"{n}_neck_core", cylinder(.085, 4.96, 5.34, 10), "joint", N)
    123:     put(f"{n}_neck_ring", loft([(5.04, octo(.26, .26, .07)), (5.1, octo(.24, .24, .06))]), "frame", N, smooth=False)
    124:     # arms
    125:     two(f"{n}_shoulder_block", loft([(.42, octo(.3, .3, .08, y=4.8)), (.74, octo(.28, .28, .08, y=4.8))], axis="x"), "frame",
    126:         *lr(J, "shoulder"), smooth=False, bevel=.012)
    127:     two(f"{n}_trunnion", cylinder(.12, .7, .9, 12, axis="x", at=(0, 4.76)), "joint", *lr(J, "shoulder"))
    128:     two(f"{n}_upperarm_core", loft([(4.0, octo(.18, .2, .05, x=.83)), (4.66, octo(.2, .22, .055, x=.82))]), "joint",
    129:         *lr(J, "upperarm"), smooth=False, bevel=.01)
    130:     two(f"{n}_elbow", cylinder(.11, .73, .93, 12, axis="x", at=(0, 3.92)), "joint", *lr(J, "upperarm"))
    131:     two(f"{n}_forearm_core", loft([(3.08, octo(.15, .17, .04, x=.85)), (3.86, octo(.18, .2, .05, x=.84))]), "frame",
    132:         *lr(J, "forearm"), smooth=False, bevel=.01)
    133:     two(f"{n}_wrist", cylinder(.065, 2.96, 3.1, 10, at=(.85, 0)), "joint", *lr(J, "hand"))
    134:     # legs
    135:     two(f"{n}_thigh_core", loft([(1.94, octo(.2, .24, .06, x=.4)), (2.75, octo(.27, .3, .08, x=.4)), (3.12, octo(.25, .27, .07, x=.38))]),
    136:         "frame", *lr(J, "thigh"), smooth=False, bevel=.012)
    137:     two(f"{n}_knee", cylinder(.125, .3, .5, 12, axis="x", at=(0, 1.78)), "joint", *lr(J, "shin"))
    138:     two(f"{n}_shin_core", loft([(.45, octo(.17, .2, .05, x=.4, y=.03)), (1.7, octo(.21, .25, .06, x=.4))]), "frame",
    139:         *lr(J, "shin"), smooth=False, bevel=.01)
    140:     two(f"{n}_ankle", cylinder(.09, .33, .47, 10, axis="x", at=(.03, .4)), "joint", *lr(J, "foot"))
  • read_file{"Path":"~/work/sortie/src/main.ts"}

    input

    {
      "Path": "~/work/sortie/src/main.ts"
    }

    result, 46 lines

    Showing lines 1-45 of 45
    1: import '@fontsource/chakra-petch/400.css';
    2: import '@fontsource/chakra-petch/600.css';
    3: import '@fontsource/share-tech-mono/400.css';
    4: import './hud/hud.css';
    5: import { startViewer } from './view/viewer';
    6: import { installHelp } from './hud/help';
    7: 
    8: const canvas = document.getElementById('view') as HTMLCanvasElement;
    9: const q = new URLSearchParams(location.search);
    10: 
    11: if (window.matchMedia?.('(pointer: coarse)').matches && !window.matchMedia('(pointer: fine)').matches) {
    12:   const note = document.createElement('div');
    13:   note.className = 'touch-note';
    14:   note.textContent = 'Sortie needs a keyboard and mouse.';
    15:   document.body.appendChild(note);
    16: }
    17: 
    18: if (q.has('sheet')) {
    19:   import('./view/sheet').then(({ startSheet }) => startSheet(canvas, q));
    20: } else if (q.get('view') === 'thrusters') {
    21:   import('./view/thrusters').then(({ startThrusterBench }) => startThrusterBench(canvas, q));
    22: } else if (q.get('view') === 'clip') {
    23:   import('./view/clip').then(({ startClip }) => startClip(canvas, q));
    24: } else if (q.has('view')) {
    25:   startViewer(canvas, q);
    26: } else {
    27:   // F1 or H: the controls, over the picker and the game
    28:   installHelp();
    29:   // On an artifact page, published updates reload the page; the viewer's hot hook hands back what
    30:   // the last version saved, so a republish doesn't throw the pilot back into the hangar.
    31:   const hot = (window as unknown as { claude?: { hot?: HotHook } }).claude?.hot;
    32:   // a republish hands back a saved game: skip the picker then, the save knows its frame
    33:   const start = (data: unknown) =>
    34:     import('./game/picker').then(({ pickFrame, restoreFrame }) => (data ? restoreFrame(q) : pickFrame(q)))
    35:       .then(() => import('./game/game'))
    36:       .then(({ startGame }) => startGame(canvas, document.getElementById('hud')!, q, data, hot));
    37:   if (hot?.ready) hot.ready(start);
    38:   else start(hot?.data ?? null);
    39: }
    40: 
    41: export interface HotHook {
    42:   ready?: (start: (data: unknown) => void) => void;
    43:   data?: unknown;
    44:   snapshot?: (save: () => unknown) => void;
    45: }
  • read_file{"Path":"~/work/sortie/src/render/assets.ts"}

    input

    {
      "Path": "~/work/sortie/src/render/assets.ts"
    }

    result, 229 lines

    Showing lines 1-228 of 228
    1: import * as THREE from 'three';
    2: import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
    3: import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
    4: import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
    5: import { PALETTES, type PaletteName } from './palette';
    6: import { DETAIL_LAYER } from './pipeline';
    7: import { BARE, isRole, material } from './materials';
    8: 
    9: const loader = new GLTFLoader();
    10: loader.setMeshoptDecoder(MeshoptDecoder);
    11: const sources = new Map<string, Promise<THREE.Object3D>>();
    12: 
    13: /** Every model the kit builds (kit/build.py). */
    14: export type ModelName = 'alien_acicular' | 'alien_druse' | 'alien_druse_mimic' | 'alien_geode'
    15:   | 'striker' | 'striker_a' | 'striker_b' | 'light' | 'light_line' | 'light_lancer' | 'heavy' | 'heavy_B' | 'heavy_C'
    16:   | 'auto_tally' | 'auto_tick' | 'auto_ledger' | 'rifle' | 'cannon' | 'drone' | 'cockpit' | 'cockpit_light' | 'ship' | 'station'
    17:   | 'wreck_field' | 'salvage_pod' | 'escape_pod' | 'raider_grunt' | 'raider_brawler' | 'raider_boss';
    18: 
    19: /**
    20:  * Models ship as .glb. Artifact pages serve neither .glb nor fetches of data: URLs, so the artifact
    21:  * build wraps each model as base64 in JSON (VITE_MODEL_EXT=glb.json) and the page decodes it here.
    22:  * Those are squeezed (tools/squeeze.mjs): meshopt compressed, plus a quantized-only copy
    23:  * (.q.glb.json) for a page that can't run the WebAssembly decoder.
    24:  */
    25: const EXT: string = import.meta.env.VITE_MODEL_EXT ?? 'glb';
    26: const meshopt: Promise<boolean> = EXT === 'glb' ? Promise.resolve(true) : MeshoptDecoder.ready.then(() => true, () => false);
    27: 
    28: async function fetchGlb(url: string): Promise<ArrayBuffer> {
    29:   const res = await fetch(url);
    30:   if (!res.ok) throw new Error(`${url}: ${res.status}`);
    31:   if (!url.endsWith('.json')) return res.arrayBuffer();
    32:   const b64 = (await res.json()).glb as string;
    33:   const bin = atob(b64);
    34:   const out = new Uint8Array(bin.length);
    35:   for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
    36:   return out.buffer;
    37: }
    38: 
    39: /** Models loading now and loaded so far, for a loading indicator. */
    40: export const loading = { pending: 0, done: 0, listeners: new Set<() => void>() };
    41: function track<T>(p: Promise<T>): Promise<T> {
    42:   loading.pending++;
    43:   const tell = () => {
    44:     for (const f of loading.listeners) f();
    45:   };
    46:   tell();
    47:   const end = () => {
    48:     loading.pending--;
    49:     loading.done++;
    50:     tell();
    51:   };
    52:   p.then(end, end);
    53:   return p;
    54: }
    55: 
    56: function source(name: ModelName, merge = true): Promise<THREE.Object3D> {
    57:   const key = merge ? name : `${name}:parts`;
    58:   let p = sources.get(key);
    59:   if (!p) {
    60:     const url = (ok: boolean) => `${import.meta.env.BASE_URL}assets/${name}.${ok ? EXT : `q.${EXT}`}`;
    61:     p = track(meshopt.then((ok) => fetchGlb(url(ok))).then((glb) => parseModel(glb, merge)));
    62:     sources.set(key, p);
    63:   }
    64:   return p;
    65: }
    66: 
    67: /** A model's scene from GLB bytes, plain or squeezed. `merge` false keeps every part its own mesh. */
    68: export async function parseModel(glb: ArrayBuffer, merge = true): Promise<THREE.Object3D> {
    69:   const root = unquantize((await loader.parseAsync(glb, '')).scene);
    70:   return merge ? mergeParts(root) : root;
    71: }
    72: 
    73: /** Start loading models now, side by side, so later awaits find them ready. */
    74: export function preload(names: Iterable<ModelName>) {
    75:   for (const n of names) source(n).catch((e) => console.error(e));
    76: }
    77: 
    78: /** A fresh copy of a model, painted with a palette and tagged for ink lines. `merge` false keeps every
    79:  *  part its own mesh, for models whose parts move apart (the aliens). */
    80: export async function model(name: ModelName, palette: PaletteName = 'merc', merge = true): Promise<THREE.Object3D> {
    81:   const root = (await source(name, merge)).clone(true);
    82:   paint(root, palette);
    83:   return root;
    84: }
    85: 
    86: export function paint(root: THREE.Object3D, palette: PaletteName) {
    87:   const pal = PALETTES[palette];
    88:   // the plumes (render/mech.ts) take their colour from the same palette
    89:   root.userData.palette = palette;
    90:   root.traverse((o) => {
    91:     const mesh = o as THREE.Mesh;
    92:     if (!mesh.isMesh) return;
    93:     const src = mesh.userData.role ?? (mesh.material as THREE.Material).name;
    94:     mesh.userData.role = src;
    95:     if (isRole(src)) mesh.material = material(pal, src, palette);
    96:     const glows = (mesh.material as THREE.MeshBasicMaterial).isMeshBasicMaterial;
    97:     mesh.castShadow = !glows;
    98:     mesh.receiveShadow = !glows;
    99:     if (glows || BARE.has(src)) mesh.layers.disable(DETAIL_LAYER);
    100:     else mesh.layers.enable(DETAIL_LAYER);
    101:   });
    102: }
    103: 
    104: /** Named nodes of a model, for joints and markers. */
    105: export function nodes(root: THREE.Object3D): Map<string, THREE.Object3D> {
    106:   const out = new Map<string, THREE.Object3D>();
    107:   root.traverse((o) => {
    108:     if (o.name) out.set(o.name, o);
    109:   });
    110:   return out;
    111: }
    112: 
    113: /** glTF node names lose dots (three.js sanitises them to underscores); look up either form. */
    114: export function find(map: Map<string, THREE.Object3D>, name: string): THREE.Object3D | undefined {
    115:   return map.get(name) ?? map.get(name.replace(/\./g, '_')) ?? map.get(name.replace(/\./g, ''));
    116: }
    117: 
    118: /**
    119:  * Rigid parts that share a joint and a material become one mesh: a frame is ~150 parts but only a
    120:  * few dozen joint/material pairs, and every mesh is a draw call (twice, with shadows).
    121:  */
    122: function mergeParts(root: THREE.Object3D): THREE.Object3D {
    123:   const groups = new Map<THREE.Object3D, Map<THREE.Material, THREE.Mesh[]>>();
    124:   root.traverse((o) => {
    125:     const m = o as THREE.Mesh;
    126:     if (!m.isMesh || m.children.length || !m.parent || Array.isArray(m.material)) return;
    127:     let byMat = groups.get(m.parent);
    128:     if (!byMat) groups.set(m.parent, (byMat = new Map()));
    129:     const list = byMat.get(m.material) ?? [];
    130:     list.push(m);
    131:     byMat.set(m.material, list);
    132:   });
    133:   for (const [parent, byMat] of groups) {
    134:     for (const [mat, meshes] of byMat) {
    135:       if (meshes.length < 2) continue;
    136:       const geoms = meshes.map((m) => {
    137:         m.updateMatrix();
    138:         const g = m.geometry.clone();
    139:         for (const k of Object.keys(g.attributes)) if (k !== 'position' && k !== 'normal') g.deleteAttribute(k);
    140:         return g.applyMatrix4(m.matrix);
    141:       });
    142:       const merged = mergeGeometries(geoms, false);
    143:       if (!merged) continue;
    144:       const mesh = new THREE.Mesh(merged, mat);
    145:       mesh.name = `${parent.name}:${mat.name}`;
    146:       mesh.userData = { ...meshes[0].userData };
    147:       for (const m of meshes) m.removeFromParent();
    148:       parent.add(mesh);
    149:     }
    150:   }
    151:   return root;
    152: }
    153: 
    154: /** tools/squeeze.mjs puts each mesh on a child node of this name, holding its dequantizing transform. */
    155: const QUANT_NODE = 'q__';
    156: 
    157: /** A float copy of a (possibly quantized) vec3 attribute, as unit vectors if `unit`. */
    158: function toFloat(a: THREE.BufferAttribute | THREE.InterleavedBufferAttribute, unit = false) {
    159:   const out = new THREE.Float32BufferAttribute(a.count * 3, 3);
    160:   for (let i = 0; i < a.count; i++) {
    161:     _v.fromBufferAttribute(a, i);
    162:     if (unit) _v.normalize();
    163:     out.setXYZ(i, _v.x, _v.y, _v.z);
    164:   }
    165:   return out;
    166: }
    167: const _v = new THREE.Vector3();
    168: 
    169: /**
    170:  * Fold squeezed meshes back into the nodes the kit built: bake each quantized mesh's transform into
    171:  * float vertices and put the mesh where its node was, with the node's name, transform, extras and
    172:  * children. A plain GLB passes through untouched.
    173:  */
    174: function unquantize(root: THREE.Object3D): THREE.Object3D {
    175:   const found: THREE.Object3D[] = [];
    176:   root.traverse((o) => {
    177:     if (o.name.startsWith(QUANT_NODE)) found.push(o);
    178:   });
    179:   // a mesh used by several nodes shares its geometry: each gets its own before any is baked
    180:   const seen = new Set<THREE.BufferGeometry>();
    181:   for (const q of found) {
    182:     q.traverse((o) => {
    183:       const m = o as THREE.Mesh;
    184:       if (!m.isMesh) return;
    185:       if (seen.has(m.geometry)) m.geometry = m.geometry.clone();
    186:       seen.add(m.geometry);
    187:     });
    188:   }
    189:   const bake = (m: THREE.Mesh, matrix: THREE.Matrix4) => {
    190:     const g = m.geometry;
    191:     g.setAttribute('position', toFloat(g.attributes.position).applyMatrix4(matrix));
    192:     if (g.attributes.normal) g.setAttribute('normal', toFloat(g.attributes.normal, true));
    193:     g.boundingBox = null;
    194:     g.computeBoundingSphere();
    195:   };
    196:   for (const q of found) {
    197:     const node = q.parent!;
    198:     q.updateMatrix();
    199:     if (!(q as THREE.Mesh).isMesh) {
    200:       // a mesh of several primitives: its parts go straight under the node
    201:       for (const c of [...q.children] as THREE.Mesh[]) {
    202:         c.updateMatrix();
    203:         bake(c, q.matrix.clone().multiply(c.matrix));
    204:         c.position.set(0, 0, 0);
    205:         c.quaternion.identity();
    206:         c.scale.set(1, 1, 1);
    207:         node.add(c);
    208:       }
    209:       q.removeFromParent();
    210:       continue;
    211:     }
    212:     // the mesh takes its node's place
    213:     const mesh = q as THREE.Mesh;
    214:     bake(mesh, mesh.matrix);
    215:     mesh.name = node.name;
    216:     mesh.userData = { ...mesh.userData, ...node.userData };
    217:     mesh.position.copy(node.position);
    218:     mesh.quaternion.copy(node.quaternion);
    219:     mesh.scale.copy(node.scale);
    220:     mesh.visible = node.visible;
    221:     for (const c of [...node.children]) if (c !== mesh) mesh.add(c);
    222:     const parent = node.parent!;
    223:     parent.children[parent.children.indexOf(node)] = mesh;
    224:     mesh.parent = parent;
    225:     node.parent = null;
    226:   }
    227:   return root;
    228: }
  • read_file{"Path":"~/work/sortie/src/render/decals.ts"}

    input

    {
      "Path": "~/work/sortie/src/render/decals.ts"
    }

    result, 139 lines

    Showing lines 1-138 of 138
    1: import * as THREE from 'three';
    2: import { DecalGeometry } from 'three/addons/geometries/DecalGeometry.js';
    3: 
    4: // Markings projected onto armour: unit numbers, designations, caution stencils, hazard bands and the
    5: // company emblem. Each decal is found by casting a ray at the rest pose, projected onto the mesh it
    6: // hits, and parented to that mesh so it moves with its joint.
    7: 
    8: export type DecalKind = 'number' | 'stencil' | 'hazard' | 'emblem';
    9: 
    10: export interface DecalSpec {
    11:   kind: DecalKind;
    12:   text?: string;
    13:   /** A point just off the surface, model space (three.js axes: +X the frame's left, +Z forward). */
    14:   at: [number, number, number];
    15:   /** Direction into the surface. */
    16:   dir: [number, number, number];
    17:   /** Width and height in metres. */
    18:   size: [number, number];
    19:   /** Roll around the surface normal, degrees. */
    20:   roll?: number;
    21:   color?: string;
    22: }
    23: 
    24: const textures = new Map<string, THREE.CanvasTexture>();
    25: 
    26: function texture(spec: DecalSpec): THREE.CanvasTexture {
    27:   const key = `${spec.kind}:${spec.text ?? ''}:${spec.color ?? ''}:${spec.size.join('x')}`;
    28:   const hit = textures.get(key);
    29:   if (hit) return hit;
    30:   const W = 512, H = Math.max(32, Math.round((512 * spec.size[1]) / spec.size[0]));
    31:   const c = document.createElement('canvas');
    32:   c.width = W;
    33:   c.height = H;
    34:   const g = c.getContext('2d')!;
    35:   const ink = spec.color ?? '#20242a';
    36:   g.fillStyle = ink;
    37:   g.strokeStyle = ink;
    38:   g.textAlign = 'center';
    39:   g.textBaseline = 'middle';
    40:   if (spec.kind === 'hazard') {
    41:     g.fillStyle = '#e2b42a';
    42:     g.fillRect(0, 0, W, H);
    43:     g.fillStyle = '#15171a';
    44:     for (let x = -H; x < W + H; x += H * 1.4) {
    45:       g.beginPath();
    46:       g.moveTo(x, H); g.lineTo(x + H * 0.7, H); g.lineTo(x + H * 1.4, 0); g.lineTo(x + H * 0.7, 0);
    47:       g.fill();
    48:     }
    49:   } else if (spec.kind === 'emblem') {
    50:     const r = Math.min(W, H) * 0.42;
    51:     g.lineWidth = r * 0.12;
    52:     g.beginPath();
    53:     g.arc(W / 2, H / 2, r, 0, Math.PI * 2);
    54:     g.stroke();
    55:     g.beginPath();
    56:     g.moveTo(W / 2 - r * 0.55, H / 2 - r * 0.25);
    57:     g.lineTo(W / 2, H / 2 + r * 0.45);
    58:     g.lineTo(W / 2 + r * 0.55, H / 2 - r * 0.25);
    59:     g.lineTo(W / 2 + r * 0.3, H / 2 - r * 0.25);
    60:     g.lineTo(W / 2, H / 2 + r * 0.05);
    61:     g.lineTo(W / 2 - r * 0.3, H / 2 - r * 0.25);
    62:     g.closePath();
    63:     g.fill();
    64:   } else {
    65:     const size = spec.kind === 'number' ? H * 0.92 : H * 0.62;
    66:     g.font = `600 ${size}px "Chakra Petch", "Arial Narrow", sans-serif`;
    67:     g.fillText(spec.text ?? '', W / 2, H / 2 + size * 0.04, W * 0.96);
    68:     if (spec.kind === 'stencil') {
    69:       // stencil bridges: thin vertical breaks through the letters
    70:       g.globalCompositeOperation = 'destination-out';
    71:       for (let x = W * 0.08; x < W; x += W / Math.max(4, (spec.text ?? '').length)) g.fillRect(x, 0, W * 0.006, H);
    72:       g.globalCompositeOperation = 'source-over';
    73:     }
    74:   }
    75:   // wear: knock speckles out of the paint
    76:   g.globalCompositeOperation = 'destination-out';
    77:   let s = key.length * 9973;
    78:   const rnd = () => ((s = (s * 16807) % 2147483647) / 2147483647);
    79:   for (let i = 0; i < (W * H) / 900; i++) {
    80:     g.globalAlpha = 0.3 + rnd() * 0.7;
    81:     g.fillRect(rnd() * W, rnd() * H, 1 + rnd() * 3, 1 + rnd() * 2);
    82:   }
    83:   g.globalAlpha = 1;
    84:   g.globalCompositeOperation = 'source-over';
    85:   const t = new THREE.CanvasTexture(c);
    86:   t.colorSpace = THREE.SRGBColorSpace;
    87:   t.anisotropy = 8;
    88:   textures.set(key, t);
    89:   return t;
    90: }
    91: 
    92: const ray = new THREE.Raycaster();
    93: const helper = new THREE.Object3D();
    94: 
    95: export function applyDecals(root: THREE.Object3D, specs: DecalSpec[]) {
    96:   root.updateMatrixWorld(true);
    97:   const meshes: THREE.Mesh[] = [];
    98:   root.traverse((o) => {
    99:     const m = o as THREE.Mesh;
    100:     if (m.isMesh && !(m.material as THREE.MeshBasicMaterial).isMeshBasicMaterial && !m.userData.decal) meshes.push(m);
    101:   });
    102:   for (const spec of specs) {
    103:     const dir = new THREE.Vector3(...spec.dir).normalize();
    104:     const at = new THREE.Vector3(...spec.at).applyMatrix4(root.matrixWorld);
    105:     ray.set(at.clone().addScaledVector(dir, -3), dir.clone().transformDirection(root.matrixWorld));
    106:     const hit = ray.intersectObjects(meshes, false)[0];
    107:     if (!hit?.face) continue;
    108:     const mesh = hit.object as THREE.Mesh;
    109:     const normal = hit.face.normal.clone().transformDirection(mesh.matrixWorld);
    110:     helper.position.copy(hit.point);
    111:     helper.lookAt(hit.point.clone().add(normal));
    112:     helper.rotateZ(THREE.MathUtils.degToRad(spec.roll ?? 0));
    113:     const geo = new DecalGeometry(mesh, hit.point, helper.rotation, new THREE.Vector3(spec.size[0], spec.size[1], 0.6));
    114:     geo.applyMatrix4(mesh.matrixWorld.clone().invert());
    115:     const mat = new THREE.MeshStandardMaterial({
    116:       map: texture(spec), transparent: true, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4,
    117:       roughness: 0.55, metalness: 0,
    118:     });
    119:     const decal = new THREE.Mesh(geo, mat);
    120:     decal.userData.decal = true;
    121:     decal.receiveShadow = true;
    122:     mesh.add(decal);
    123:   }
    124: }
    125: 
    126: /** The striker's markings: unit number on the shoulders and leg, designation, stencils, hazard bands. */
    127: export const STRIKER_DECALS: DecalSpec[] = [
    128:   { kind: 'number', text: '07', at: [4.8, 15.15, 0], dir: [-1, 0, 0], size: [0.95, 0.7], color: '#e9edf0' },
    129:   { kind: 'emblem', at: [-4.8, 15.15, 0], dir: [1, 0, 0], size: [0.8, 0.8], color: '#e9edf0' },
    130:   { kind: 'number', text: '07', at: [2.6, 3.6, 0.15], dir: [-1, 0, 0], size: [0.55, 0.42], color: '#e9edf0' },
    131:   { kind: 'stencil', text: 'MF-07', at: [1.15, 9.25, 3], dir: [0, 0, -1], size: [0.7, 0.2] },
    132:   { kind: 'stencil', text: 'NO STEP', at: [1.3, 10.05, 3], dir: [0, 0, -1], size: [0.6, 0.15], roll: -20 },
    133:   { kind: 'stencil', text: 'NO STEP', at: [-1.3, 10.05, 3], dir: [0, 0, -1], size: [0.6, 0.15], roll: 20 },
    134:   { kind: 'hazard', at: [1.2, 6.55, 3], dir: [0, 0, -1], size: [0.6, 0.12] },
    135:   { kind: 'hazard', at: [-1.2, 6.55, 3], dir: [0, 0, -1], size: [0.6, 0.12] },
    136:   { kind: 'stencil', text: 'DANGER EXHAUST', at: [0, 12.9, -4], dir: [0, 0, 1], size: [1.1, 0.16] },
    137:   { kind: 'stencil', text: 'STRIKER', at: [-2.6, 3.4, 0.15], dir: [1, 0, 0], size: [0.9, 0.2], roll: 90, color: '#e9edf0' },
    138: ];

agent

+2:49
reasoning

I'm thinking through how to approach this.

Initial observation: current render states for striker_a, light, heavy, ship, sketch, kit, service, and field are visible. Reviewing the rules in brief-sortie-full.md for browser rendering constraints is essential before proceeding.

Reviewing the rules, browser rendering must use headless Chromium only via Playwright, and page-side code requires plain .js due to the potential for __name is not defined errors when using tsx for compilation. Other crucial rules: no Windows programs are permitted, targeted checks are preferred over full test runs, no installations are permitted, nothing runs on the C1 machine, no uploads, and editing is limited to the worktree and output folder.

  • run_command{"CommandLine":"node -e '\nimport(\"./node_modules/vite/dist/node/index.js\").then(async ({ createServer }) => {\n const { chromium } = await import(\"playwright\");\n const fs = await import(\"node:fs\");\n const out = \"~/.gemini/antigravity-cli/brain/cea9ec26-a0ce-4401-a5d2-36df51bb07b3/scratch/survey\";\n fs.mkdirSync(out, { recursive: true });\n const server = await createServer({ server: { host: \"127.0.0.1\", port: 5235, strictPort: false }, logLevel: \"error\" });\n await server.listen();\n const base = server.resolvedUrls.local[0];\n const browser = await chromium.launch({ args: [\"--use-angle=swiftshader\", \"--enable-unsafe-swiftshader\", \"--ignore-gpu-blocklist\"] });\n try {\n const page = await browser.newPage({ viewport: { width: 720, height: 480 } });\n const shots = [\n [\"striker_a_kit\", \"?view=striker_a&look=kit&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=26\"],\n [\"striker_a_sketch\", \"?view=striker_a&look=sketch&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=26\"],\n [\"light_knight\", \"?view=light&look=kit&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=11\"],\n [\"light_back\", \"?view=light&look=kit&pose=flight&yaw=155&pitch=10&dist=11\"],\n [\"heavy_a\", \"?view=heavy&look=service&pose=launch_heavy&weapon=cannon&yaw=35&pitch=8&dist=34\"],\n [\"ship_hangar\", \"?view=ship&bays=light,heavy&frame=standard&yaw=25&pitch=14&dist=48\"]\n ];\n for (const [name, q] of shots) {\n const t0 = Date.now();\n await page.goto(base + q);\n await page.waitForFunction(\"window.__ready === true\", null, { timeout: 120000 });\n await page.evaluate(\"new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))\");\n await page.screenshot({ path: out + \"/\" + name + \".jpg\", type: \"jpeg\", quality: 88 });\n console.log(name, (Date.now() - t0) + \"ms\");\n }\n } finally {\n await browser.close();\n await server.close();\n }\n});\n'","WaitMsBeforeAsync":10000,"toolSummary":"Render quick survey shots of existing models"}

    input

    {
      "CommandLine": "node -e '\nimport(\"./node_modules/vite/dist/node/index.js\").then(async ({ createServer }) => {\n  const { chromium } = await import(\"playwright\");\n  const fs = await import(\"node:fs\");\n  const out = \"~/.gemini/antigravity-cli/brain/cea9ec26-a0ce-4401-a5d2-36df51bb07b3/scratch/survey\";\n  fs.mkdirSync(out, { recursive: true });\n  const server = await createServer({ server: { host: \"127.0.0.1\", port: 5235, strictPort: false }, logLevel: \"error\" });\n  await server.listen();\n  const base = server.resolvedUrls.local[0];\n  const browser = await chromium.launch({ args: [\"--use-angle=swiftshader\", \"--enable-unsafe-swiftshader\", \"--ignore-gpu-blocklist\"] });\n  try {\n    const page = await browser.newPage({ viewport: { width: 720, height: 480 } });\n    const shots = [\n      [\"striker_a_kit\", \"?view=striker_a&look=kit&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=26\"],\n      [\"striker_a_sketch\", \"?view=striker_a&look=sketch&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=26\"],\n      [\"light_knight\", \"?view=light&look=kit&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=11\"],\n      [\"light_back\", \"?view=light&look=kit&pose=flight&yaw=155&pitch=10&dist=11\"],\n      [\"heavy_a\", \"?view=heavy&look=service&pose=launch_heavy&weapon=cannon&yaw=35&pitch=8&dist=34\"],\n      [\"ship_hangar\", \"?view=ship&bays=light,heavy&frame=standard&yaw=25&pitch=14&dist=48\"]\n    ];\n    for (const [name, q] of shots) {\n      const t0 = Date.now();\n      await page.goto(base + q);\n      await page.waitForFunction(\"window.__ready === true\", null, { timeout: 120000 });\n      await page.evaluate(\"new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))\");\n      await page.screenshot({ path: out + \"/\" + name + \".jpg\", type: \"jpeg\", quality: 88 });\n      console.log(name, (Date.now() - t0) + \"ms\");\n    }\n  } finally {\n    await browser.close();\n    await server.close();\n  }\n});\n'",
      "WaitMsBeforeAsync": 10000,
      "toolSummary": "Render quick survey shots of existing models"
    }

    result, 42 lines

    Tool is running as a background task with task id: cea9ec26-a0ce-4401-a5d2-36df51bb07b3/task-67
    Task Description: node -e '
    import("./node_modules/vite/dist/node/index.js").then(async ({ createServer }) => {
      const { chromium } = await import("playwright");
      const fs = await import("node:fs");
      const out = "~/.gemini/antigravity-cli/brain/cea9ec26-a0ce-4401-a5d2-36df51bb07b3/scratch/survey";
      fs.mkdirSync(out, { recursive: true });
      const server = await createServer({ server: { host: "127.0.0.1", port: 5235, strictPort: false }, logLevel: "error" });
      await server.listen();
      const base = server.resolvedUrls.local[0];
      const browser = await chromium.launch({ args: ["--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-gpu-blocklist"] });
      try {
        const page = await browser.newPage({ viewport: { width: 720, height: 480 } });
        const shots = [
          ["striker_a_kit", "?view=striker_a&look=kit&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=26"],
          ["striker_a_sketch", "?view=striker_a&look=sketch&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=26"],
          ["light_knight", "?view=light&look=kit&pose=flight&weapon=rifle&yaw=35&pitch=8&dist=11"],
          ["light_back", "?view=light&look=kit&pose=flight&yaw=155&pitch=10&dist=11"],
          ["heavy_a", "?view=heavy&look=service&pose=launch_heavy&weapon=cannon&yaw=35&pitch=8&dist=34"],
          ["ship_hangar", "?view=ship&bays=light,heavy&frame=standard&yaw=25&pitch=14&dist=48"]
        ];
        for (const [name, q] of shots) {
          const t0 = Date.now();
          await page.goto(base + q);
          await page.waitForFunction("window.__ready === true", null, { timeout: 120000 });
          await page.evaluate("new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))");
          await page.screenshot({ path: out + "/" + name + ".jpg", type: "jpeg", quality: 88 });
          console.log(name, (Date.now() - t0) + "ms");
        }
      } finally {
        await browser.close();
        await server.close();
      }
    });
    '
    Task logs are available at: file://~/.gemini/antigravity-cli/brain/cea9ec26-a0ce-4401-a5d2-36df51bb07b3/.system_generated/tasks/task-67.log
    Log output:
    striker_a_kit 5525ms
    
    YOU MUST TAKE ONE OF THE FOLLOWING TWO ACTIONS: A) either proceed to other relevant work (if any) or, B) simply update the user with a short message (that you have launched the command and will wait for it to finish) and end the turn.
     DO NOTHING ELSE.
     When updating the user, always respond in the language of the user (defaulting to English). Never mix two or more languages in the same response.