@funpixel/tools 0.0.0-stage → 0.1.0

package/bench/handlers/inspect.py

@@ -0,0 +1,212 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`inspect` — describe what is ACTUALLY in a model. Read-only.
+
+Every field here exists because something shipped broken without it. The four
+scripts in `funpixel-harness-games` are the requirements document:
+
+  * `creatures.py`      — alpha 0 on every material: "it loads without error,
+                          reports five visible skinned meshes, and draws nothing
+                          at all." Also: an all-black base colour renders as a
+                          flat silhouette.
+  * `blender-fit-rig.py`— bone heat "gives up on a generated mesh (it is not a
+                          closed manifold)", leaving vertices unweighted
+                          SILENTLY, so the mesh renders in bind pose.
+  * `animate-creature.py` — "'rigged' means bones exist, not that anyone posed
+                          them"; match bones by NAME PREFIX because an
+                          index-based rig "breaks silently"; 65 leftover
+                          object-level actions made a 42 MB GLB animating
+                          nothing.
+  * `blender-fix-leg.py`— an auto-rigger finds only what it can see; a long coat
+                          hid a knee and foot and the character dragged a leg.
+
+NOT MEASURED IS -1, NEVER 0. A fraction that was never computed must not read as
+a confident zero; that is what makes an added check silently optional.
+"""
+import os
+
+import bpy
+
+from . import scene
+
+
+def _deform_bone_names(arm_obj):
+    """Bone names that actually MOVE the mesh.
+
+    `bones` and `deform_bones` differ, and only the deform set matters — a rig
+    can carry control bones that no vertex is ever weighted to.
+
+    MEASURED, and do not re-chase it: **glTF/GLB does not carry `use_deform`.**
+    Round-tripping a rig whose control bone had `use_deform = False` brings every
+    bone back `True` (verified against our own fixture, 2026-09-16). So on a GLB
+    this set is all bones and `deform_bones == bones`; the two numbers only
+    diverge for a format that preserves the flag, such as FBX or .blend.
+
+    That is not a bug here and it is not worth "fixing" by inferring deform-ness
+    from vertex groups — a bone with no weights today may be weighted by a repair
+    verb tomorrow, so inferring it would make the field lie in the other
+    direction. Report what the format actually says.
+    """
+    return {b.name for b in arm_obj.data.bones if b.use_deform}
+
+
+def _describe_mesh(obj, deform_names):
+    """One mesh, with the binding question answered rather than assumed."""
+    obj.data.calc_loop_triangles()
+    verts = len(obj.data.vertices)
+
+    # Is this mesh actually BOUND, or does it merely sit near an armature?
+    # Both an Armature modifier and vertex groups naming real deform bones are
+    # required: either alone is a rig that does not move anything.
+    has_modifier = any(m.type == "ARMATURE" for m in obj.modifiers)
+    group_index_to_name = {g.index: g.name for g in obj.vertex_groups}
+    deform_group_indices = {
+        i for i, n in group_index_to_name.items() if n in deform_names
+    }
+    skinned = bool(has_modifier and deform_group_indices)
+
+    unweighted = 0
+    unweighted_fraction = -1.0
+    if skinned:
+        # Count vertices with NO weight to any DEFORM bone. Weight to a control
+        # bone does not move a vertex, so counting "has any group" would report
+        # a bound mesh where there is none — the failure bone heat produces.
+        for v in obj.data.vertices:
+            if not any(
+                g.group in deform_group_indices and g.weight > 0.0 for g in v.groups
+            ):
+                unweighted += 1
+        unweighted_fraction = (unweighted / verts) if verts else -1.0
+
+    return {
+        "name": obj.name,
+        "vertices": verts,
+        "triangles": len(obj.data.loop_triangles),
+        "unweighted_vertices": unweighted,
+        "unweighted_fraction": unweighted_fraction,
+        "skinned": skinned,
+    }
+
+
+def _describe_material(mat):
+    """Alpha and base colour, read from the Principled BSDF when there is one.
+
+    THE TRAP (`creatures.py`): a pack whose materials all carry alpha 0 exports
+    to a completely invisible model that reports every mesh as present.
+    """
+    out = {
+        "name": mat.name,
+        "alpha": -1.0,
+        "base_color": [-1.0, -1.0, -1.0],
+        "base_color_linked": False,
+        "blend_method": getattr(mat, "blend_method", "") or "",
+    }
+    if not mat.use_nodes:
+        return out
+    bsdf = next(
+        (n for n in mat.node_tree.nodes if n.type == "BSDF_PRINCIPLED"), None
+    )
+    if bsdf is None:
+        return out
+
+    alpha_in = bsdf.inputs.get("Alpha")
+    if alpha_in is not None and not alpha_in.is_linked:
+        out["alpha"] = float(alpha_in.default_value)
+
+    base = bsdf.inputs.get("Base Color")
+    if base is not None:
+        if base.is_linked:
+            # A linked colour means the three floats describe nothing; say so
+            # rather than reporting a default that looks like a measurement.
+            out["base_color_linked"] = True
+        else:
+            c = base.default_value
+            out["base_color"] = [float(c[0]), float(c[1]), float(c[2])]
+    return out
+
+
+def _describe_clips(arm_obj):
+    """Every action, and whether it drives the ARMATURE or is leftover.
+
+    `animate-creature.py` had to drop 65 object-level actions that "the exporter
+    happily writes out — 42 MB of GLB, none of it animating the rig."
+    """
+    bone_names = set()
+    if arm_obj is not None:
+        bone_names = {b.name for b in arm_obj.data.bones}
+
+    clips = []
+    for action in bpy.data.actions:
+        start, end = action.frame_range
+        # An armature action addresses bones via pose.bones["Name"]; an
+        # object-level one does not. Checking the data paths is what separates
+        # a real clip from payload.
+        drives = any(
+            'pose.bones["' in fc.data_path
+            and fc.data_path.split('"')[1] in bone_names
+            for fc in action.fcurves
+            if '"' in fc.data_path
+        )
+        clips.append(
+            {
+                "name": action.name,
+                "frame_start": float(start),
+                "frame_end": float(end),
+                "fcurves": len(action.fcurves),
+                "drives_armature": bool(drives),
+            }
+        )
+    return clips
+
+
+def run(args):
+    path = args.get("model_path") or ""
+    if not path or not os.path.isfile(path):
+        raise ValueError("model_path does not exist")
+
+    scene.import_model(path, args.get("format") or "")
+
+    meshes = scene.mesh_objects()
+    if not meshes:
+        raise ValueError("the file imported but contains no mesh")
+
+    arm_obj = scene.armature_object()
+    deform_names = _deform_bone_names(arm_obj) if arm_obj else set()
+
+    armature = None
+    if arm_obj is not None:
+        bones = arm_obj.data.bones
+        armature = {
+            "name": arm_obj.name,
+            "bones": len(bones),
+            "deform_bones": len(deform_names),
+            # Names ride along so a caller can match by PREFIX. Index-based
+            # matching "breaks silently on the second model by rotating whatever
+            # bone happens to sit at that slot" (animate-creature.py).
+            "bone_names": [b.name for b in bones],
+        }
+
+    bounds = scene.world_bounds(meshes)
+
+    # Which axis the longest extent lies along, and how tall the model is
+    # relative to its footprint. REPORTED, NEVER JUDGED: a car, a platform and a
+    # ball are all legitimately wider than tall. Only a named humanoid makes
+    # this a defect, and that is the caller's call.
+    up_axis = ""
+    upright_ratio = -1.0
+    if bounds is not None:
+        size = [bounds["max"][i] - bounds["min"][i] for i in range(3)]
+        up_axis = "xyz"[size.index(max(size))]
+        ground = max(size[0], size[1])
+        if ground > 1e-6:
+            upright_ratio = size[2] / ground
+
+    return {
+        "meshes": [_describe_mesh(o, deform_names) for o in meshes],
+        "armature": armature,
+        "materials": [_describe_material(m) for m in bpy.data.materials],
+        "clips": _describe_clips(arm_obj),
+        "bounds": bounds,
+        "up_axis": up_axis,
+        "upright_ratio": upright_ratio,
+        "total_vertices": sum(len(o.data.vertices) for o in meshes),
+    }

package/bench/handlers/level_check.py

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""The bench's own check of a level spec, before anything is built.
+
+The full rule set lives in ONE place — funpixel-core `level_spec` — and the
+service runs it before this process starts. This is the backstop for a spec
+that reaches the entrypoint another way (`funtools model --local level`, a
+test): the shapes, counts, names and number ranges that keep the build bounded
+and the node names safe. It refuses; it never repairs.
+"""
+import math
+import re
+
+NAME = re.compile(r"^[a-z][a-z0-9_]{0,31}$")
+COLOR = re.compile(r"^#[0-9a-fA-F]{6}$")
+LIMITS = {"areas": 64, "walls": 128, "ramps": 64, "platforms": 128, "props": 512, "markers": 256}
+REACH = 200.0
+
+
+def _num(v, field, lo, hi):
+    if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or not lo <= v <= hi:
+        raise ValueError("%s: must be a number %s–%s" % (field, lo, hi))
+    return float(v)
+
+
+def _name(v, field):
+    if not isinstance(v, str) or not NAME.match(v):
+        raise ValueError("%s: not a name (1–32 of a-z, 0-9, _; a letter first)" % field)
+    return v
+
+
+def check(spec):
+    if not isinstance(spec, dict):
+        raise ValueError("the level spec must be a JSON object")
+    _name(spec.get("name"), "name")
+    names = set()
+    for key, cap in LIMITS.items():
+        items = spec.get(key) or []
+        if not isinstance(items, list) or len(items) > cap:
+            raise ValueError("%s: a list of at most %d" % (key, cap))
+        for i, item in enumerate(items):
+            f = "%s[%d]" % (key, i)
+            if not isinstance(item, dict):
+                raise ValueError("%s: must be an object" % f)
+            n = _name(item.get("name"), f + ".name")
+            if n in names:
+                raise ValueError("%s: the name %r is used twice" % (f, n))
+            names.add(n)
+            for k in ("x", "z", "w", "d"):
+                if k in item:
+                    _num(item[k], "%s.%s" % (f, k), -REACH, REACH)
+            for k in ("y", "floor_y", "from_y", "to_y", "height", "thickness"):
+                if k in item:
+                    _num(item[k], "%s.%s" % (f, k), -50.0, 100.0)
+            for k in ("at", "from", "to"):
+                if k in item and isinstance(item[k], list):
+                    for j, v in enumerate(item[k]):
+                        _num(v, "%s.%s[%d]" % (f, k, j), -REACH, REACH)
+            if len(item.get("openings") or []) > 16:
+                raise ValueError("%s.openings: at most 16" % f)
+            if "steps" in item:
+                _num(item["steps"], f + ".steps", 0, 64)
+            if "scale" in item:
+                _num(item["scale"], f + ".scale", 0.25, 4.0)
+    for role, c in ((spec.get("style") or {}).get("palette") or {}).items():
+        if not isinstance(c, str) or not COLOR.match(c):
+            raise ValueError("style.palette.%s: a colour is #rrggbb" % role)
+    if not any(m.get("kind") == "spawn" for m in spec.get("markers") or []):
+        raise ValueError("markers: a level needs a spawn marker")

package/bench/handlers/level_geo.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Geometry for `build_level`: boxes, wedges, cylinders and the ink hull.
+
+Everything is built in the SPEC's space — glTF's: metres, +Y up, the ground
+plane X/Z — and turned into Blender's Z-up once, when a mesh becomes an object
+(`to_object`). A rotation of +90 degrees about X maps (x, y, z) to (x, -z, y),
+which is exactly what the glTF exporter undoes with `export_yup`, so a number
+in the spec comes out of the GLB unchanged. Building in Blender's axes instead
+would put a sign flip in every recipe, and one missed flip is a level that
+exports mirrored.
+
+A `Piece` gathers faces with a palette ROLE each; the level's materials are
+one per role, so every piece of every room shares the same look.
+"""
+import math
+
+import bmesh
+import bpy
+from mathutils import Matrix, Vector
+
+# Spec space -> Blender space.
+TO_BLENDER = Matrix.Rotation(math.radians(90.0), 4, "X")
+
+
+class Piece:
+    """One mesh under construction: its vertices, and faces tagged by role."""
+
+    def __init__(self):
+        self.bm = bmesh.new()
+        self.roles = []  # role per face, in face order
+
+    def _face(self, verts, role):
+        f = self.bm.faces.new(verts)
+        self.roles.append(role)
+        return f
+
+    def box(self, lo, hi, role):
+        """An axis-aligned box from corner `lo` to corner `hi`."""
+        x0, y0, z0 = lo
+        x1, y1, z1 = hi
+        if x1 - x0 <= 1e-5 or y1 - y0 <= 1e-5 or z1 - z0 <= 1e-5:
+            return
+        v = [self.bm.verts.new(p) for p in (
+            (x0, y0, z0), (x1, y0, z0), (x1, y0, z1), (x0, y0, z1),
+            (x0, y1, z0), (x1, y1, z0), (x1, y1, z1), (x0, y1, z1),
+        )]
+        # Outward winding (counter-clockwise seen from outside).
+        for idx in ((0, 1, 2, 3), (7, 6, 5, 4), (0, 4, 5, 1),
+                    (1, 5, 6, 2), (2, 6, 7, 3), (3, 7, 4, 0)):
+            self._face([v[i] for i in idx], role)
+
+    def wedge(self, x0, z0, x1, z1, y_base, y_low, y_high, rises_to, role):
+        """A solid ramp over [x0,x1]x[z0,z1], top sloping from `y_low` to
+        `y_high` toward side `rises_to` ('n' = -Z, 's' = +Z, 'e' = +X, 'w' = -X)."""
+        def top(x, z):
+            t = {"n": (z1 - z) / (z1 - z0), "s": (z - z0) / (z1 - z0),
+                 "e": (x - x0) / (x1 - x0), "w": (x1 - x) / (x1 - x0)}[rises_to]
+            return y_low + (y_high - y_low) * t
+        corners = ((x0, z0), (x1, z0), (x1, z1), (x0, z1))
+        b = [self.bm.verts.new((x, y_base, z)) for x, z in corners]
+        t = [self.bm.verts.new((x, top(x, z), z)) for x, z in corners]
+        self._face([b[0], b[1], b[2], b[3]], role)
+        self._face([t[3], t[2], t[1], t[0]], role)
+        for i in range(4):
+            j = (i + 1) % 4
+            self._face([b[j], b[i], t[i], t[j]], role)
+
+    def cylinder(self, centre, r0, r1, height, role, segments=8):
+        """A capped cylinder (a cone frustum when r0 != r1) standing on `centre`."""
+        cx, cy, cz = centre
+        ring = lambda y, r: [self.bm.verts.new(
+            (cx + r * math.cos(2 * math.pi * i / segments), y,
+             cz + r * math.sin(2 * math.pi * i / segments))) for i in range(segments)]
+        lo, hi = ring(cy, r0), ring(cy + height, max(r1, 1e-4))
+        self._face(hi[::-1], role)
+        self._face(lo, role)
+        for i in range(segments):
+            j = (i + 1) % segments
+            self._face([lo[j], lo[i], hi[i], hi[j]], role)
+
+    def blob(self, centre, radius, squash, role, jitter=0.0, seed=0):
+        """A low-poly icosphere: foliage, a rock. `jitter` roughens it, the
+        same way every time for the same `seed`."""
+        tmp = bmesh.new()
+        bmesh.ops.create_icosphere(tmp, subdivisions=1, radius=1.0)
+        offset = len(self.bm.verts)
+        verts = []
+        for i, v in enumerate(tmp.verts):
+            n = v.co.copy()
+            if jitter:
+                k = math.sin((i + 1) * 12.9898 + seed * 78.233) * 43758.5453
+                n *= 1.0 + jitter * ((k - math.floor(k)) - 0.5)
+            verts.append(self.bm.verts.new((
+                centre[0] + n.x * radius,
+                centre[1] + n.z * radius * squash,
+                centre[2] + n.y * radius)))
+        for f in tmp.faces:
+            # Y and Z swapped above flips handedness: reverse to stay outward.
+            self._face([verts[v.index] for v in reversed(f.verts)], role)
+        tmp.free()
+        return offset
+
+    def transformed(self, matrix):
+        """Apply `matrix` (spec space) to everything built so far."""
+        bmesh.ops.transform(self.bm, matrix=matrix, verts=self.bm.verts)
+
+    def triangles(self):
+        return sum(len(f.verts) - 2 for f in self.bm.faces)
+
+    def empty(self):
+        return len(self.bm.faces) == 0
+
+
+def add_ink_hull(piece, width, ink_role):
+    """Append an inverted hull: every face again, pushed out along the vertex
+    normals by `width` and turned inside out, in the ink role. With back faces
+    culled, only the rim of it shows — an outline that needs no post-process
+    and draws in any glTF viewer."""
+    bm = piece.bm
+    bm.normal_update()
+    originals = list(bm.faces)
+    mapping = {}
+    for v in list(bm.verts):
+        mapping[v] = bm.verts.new(v.co + v.normal * width)
+    for f in originals:
+        piece._face([mapping[v] for v in reversed(f.verts)], ink_role)
+
+
+def to_object(name, piece, role_slots, parent):
+    """Make `piece` a Blender object named `name`, its faces on the material
+    slots of their roles, parented under `parent`. Frees the piece."""
+    mesh = bpy.data.meshes.new(name)
+    piece.bm.to_mesh(mesh)
+    piece.bm.free()
+    used = sorted(set(piece.roles), key=list(role_slots).index)
+    for role in used:
+        mesh.materials.append(role_slots[role])
+    slot = {role: i for i, role in enumerate(used)}
+    mesh.polygons.foreach_set("material_index", [slot[r] for r in piece.roles])
+    mesh.transform(TO_BLENDER)
+    mesh.update()
+    obj = bpy.data.objects.new(name, mesh)
+    bpy.context.collection.objects.link(obj)
+    obj.parent = parent
+    return obj
+
+
+def spec_point(at):
+    """A spec-space point in Blender space."""
+    return TO_BLENDER @ Vector((at[0], at[1], at[2]))

package/bench/handlers/level_proof.py

@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""The proof pictures of a built level: a plan from straight above, and a view
+from a raised corner.
+
+Rendered AFTER the export, so nothing added here reaches the GLB: the markers
+become coloured pins you can find at a glance (spawns green, exits red,
+pickups gold, enemies magenta, the rest blue), and the colliders are hidden —
+the picture shows the art, and the pins show where the game's points are.
+A pin with a red ring stands on nothing (the audit's finding, drawn).
+"""
+import math
+import os
+
+import bpy
+from mathutils import Vector
+
+from . import scene
+from .level_geo import spec_point
+
+PIN = {"spawn": (0.1, 0.85, 0.2), "exit": (0.95, 0.15, 0.1), "pickup": (1.0, 0.8, 0.1),
+       "enemy": (0.9, 0.1, 0.8)}
+OTHER = (0.2, 0.5, 1.0)
+
+
+def _emissive(name, rgb):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = True
+    nodes = m.node_tree.nodes
+    nodes.clear()
+    em = nodes.new("ShaderNodeEmission")
+    em.inputs["Color"].default_value = (*rgb, 1.0)
+    em.inputs["Strength"].default_value = 2.0
+    out = nodes.new("ShaderNodeOutputMaterial")
+    m.node_tree.links.new(em.outputs["Emission"], out.inputs["Surface"])
+    return m
+
+
+def _pin(marker, radius):
+    rgb = PIN.get(marker["kind"], OTHER)
+    bpy.ops.mesh.primitive_cone_add(vertices=8, radius1=radius, radius2=0.0, depth=radius * 2.5)
+    cone = bpy.context.active_object
+    cone.location = spec_point(marker["at"]) + Vector((0, 0, radius * 1.25))
+    cone.rotation_euler = (math.pi, 0, 0)
+    cone.data.materials.append(_emissive("pin_" + marker["name"], rgb))
+    if not marker["supported"] and marker["kind"] in ("spawn", "exit", "checkpoint"):
+        bpy.ops.mesh.primitive_torus_add(major_radius=radius * 1.6, minor_radius=radius * 0.25)
+        ring = bpy.context.active_object
+        ring.location = spec_point(marker["at"])
+        ring.data.materials.append(_emissive("ring_" + marker["name"], (1.0, 0.0, 0.0)))
+
+
+def _stage():
+    world = bpy.data.worlds.new("LevelStage")
+    world.use_nodes = True
+    bg = world.node_tree.nodes.get("Background")
+    bg.inputs["Color"].default_value = (0.55, 0.6, 0.68, 1.0)
+    bg.inputs["Strength"].default_value = 0.9
+    bpy.context.scene.world = world
+    sun = bpy.data.lights.new("Sun", type="SUN")
+    sun.energy = 3.0
+    obj = bpy.data.objects.new("Sun", sun)
+    obj.rotation_euler = (math.radians(50), math.radians(10), math.radians(35))
+    bpy.context.collection.objects.link(obj)
+
+
+def _camera(ortho):
+    data = bpy.data.cameras.new("Proof")
+    if ortho:
+        data.type = "ORTHO"
+    data.clip_end = 2000.0
+    cam = bpy.data.objects.new("Proof", data)
+    bpy.context.collection.objects.link(cam)
+    bpy.context.scene.camera = cam
+    return cam
+
+
+def _shoot(path):
+    bpy.context.scene.render.filepath = path
+    bpy.ops.render.render(write_still=True)
+    if not os.path.exists(path):
+        raise RuntimeError("the proof render wrote no file")
+
+
+def render(out_dir, size, colliders, markers, bounds):
+    """Write plan.png and view.png into `out_dir`; return their paths."""
+    for c in colliders.children:
+        c.hide_render = True
+    if bounds is None:
+        raise ValueError("the level has no art to render")
+    lo, hi = Vector(bounds["min"]), Vector(bounds["max"])
+    centre, extent = (lo + hi) / 2, hi - lo
+    span = max(extent.x, extent.y, 1.0)
+    for m in markers:
+        _pin(m, max(span * 0.012, 0.15))
+    _stage()
+    sc = bpy.context.scene
+    sc.render.engine = scene.render_engine()
+    sc.render.resolution_x = sc.render.resolution_y = size
+    sc.render.image_settings.file_format = "PNG"
+    sc.render.film_transparent = False
+
+    cam = _camera(ortho=True)
+    cam.data.ortho_scale = span * 1.1
+    cam.location = (centre.x, centre.y, hi.z + span)
+    cam.rotation_euler = (0.0, 0.0, 0.0)
+    plan = os.path.join(out_dir, "plan.png")
+    _shoot(plan)
+
+    cam.data.type = "PERSP"
+    cam.data.lens = 35.0
+    # A raised south-east corner, close enough that a room fills the frame.
+    radius = max(extent.length * 0.72, 1.0)
+    cam.location = centre + Vector((radius * 0.7, -radius * 0.85, radius * 0.75))
+    cam.rotation_euler = (centre - cam.location).to_track_quat("-Z", "Y").to_euler()
+    view = os.path.join(out_dir, "view.png")
+    _shoot(view)
+    return {"plan": plan, "view": view, "engine": bpy.context.scene.render.engine}

package/bench/handlers/level_props.py

@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""The prop kit for `build_level`: one fixed low-poly recipe per kind.
+
+Each recipe builds into a `Piece` in the prop's own space — feet on y = 0,
+centred on x = z = 0, about a metre across — in palette ROLES, never colours,
+so a crate in a dungeon and a crate in a kitchen take their level's palette.
+The kinds are the spec's `PropKind` list (funpixel-core `level_spec`); a kind
+the spec gained without a recipe here is refused by `build`, not skipped.
+
+Sizes are real-world, so a table is table-height next to a door that is door-
+height: the level reads at the right scale before any art replaces it.
+"""
+import zlib
+
+
+def _crate(p, seed):
+    p.box((-0.4, 0.0, -0.4), (0.4, 0.8, 0.4), "prop")
+    p.box((-0.42, 0.34, -0.42), (0.42, 0.46, 0.42), "trim")
+
+
+def _barrel(p, seed):
+    p.cylinder((0, 0, 0), 0.32, 0.32, 0.9, "prop")
+    for y in (0.15, 0.7):
+        p.cylinder((0, y, 0), 0.335, 0.335, 0.06, "trim")
+
+
+def _table(p, seed):
+    p.box((-0.7, 0.68, -0.4), (0.7, 0.76, 0.4), "prop")
+    for x in (-0.62, 0.56):
+        for z in (-0.32, 0.26):
+            p.box((x, 0.0, z), (x + 0.06, 0.68, z + 0.06), "trim")
+
+
+def _chair(p, seed):
+    p.box((-0.23, 0.42, -0.23), (0.23, 0.47, 0.23), "prop")
+    for x in (-0.21, 0.17):
+        for z in (-0.21, 0.17):
+            p.box((x, 0.0, z), (x + 0.04, 0.42, z + 0.04), "trim")
+    p.box((-0.23, 0.47, 0.18), (0.23, 0.95, 0.23), "prop")
+
+
+def _bench(p, seed):
+    p.box((-0.7, 0.4, -0.2), (0.7, 0.47, 0.2), "prop")
+    for x in (-0.6, 0.52):
+        p.box((x, 0.0, -0.18), (x + 0.08, 0.4, 0.18), "trim")
+
+
+def _bed(p, seed):
+    p.box((-0.5, 0.0, -1.0), (0.5, 0.35, 1.0), "prop")
+    p.box((-0.46, 0.35, -0.95), (0.46, 0.5, 0.95), "wall")
+    p.box((-0.35, 0.5, -0.92), (0.35, 0.6, -0.62), "accent")
+    p.box((-0.5, 0.0, -1.06), (0.5, 0.9, -1.0), "prop")
+
+
+def _shelf(p, seed):
+    for x in (-0.5, 0.46):
+        p.box((x, 0.0, -0.17), (x + 0.04, 1.8, 0.17), "prop")
+    for y in (0.05, 0.6, 1.15, 1.72):
+        p.box((-0.46, y, -0.17), (0.46, y + 0.04, 0.17), "prop")
+    p.box((-0.46, 0.0, 0.15), (0.46, 1.8, 0.17), "trim")
+
+
+def _counter(p, seed):
+    p.box((-1.0, 0.0, -0.3), (1.0, 0.86, 0.3), "prop")
+    p.box((-1.03, 0.86, -0.33), (1.03, 0.92, 0.33), "trim")
+
+
+def _pillar(p, seed):
+    p.box((-0.3, 0.0, -0.3), (0.3, 0.2, 0.3), "trim")
+    p.box((-0.22, 0.2, -0.22), (0.22, 2.8, 0.22), "wall")
+    p.box((-0.3, 2.8, -0.3), (0.3, 3.0, 0.3), "trim")
+
+
+def _lamp(p, seed):
+    p.box((-0.15, 0.0, -0.15), (0.15, 0.06, 0.15), "trim")
+    p.box((-0.04, 0.06, -0.04), (0.04, 2.1, 0.04), "trim")
+    p.box((-0.16, 2.1, -0.16), (0.16, 2.4, 0.16), "accent")
+
+
+def _tree(p, seed):
+    p.cylinder((0, 0, 0), 0.16, 0.12, 1.5, "prop", segments=6)
+    p.blob((0, 2.1, 0), 0.95, 0.85, "foliage", jitter=0.25, seed=seed)
+
+
+def _bush(p, seed):
+    p.blob((0, 0.35, 0), 0.55, 0.7, "foliage", jitter=0.3, seed=seed)
+
+
+def _rock(p, seed):
+    p.blob((0, 0.2, 0), 0.5, 0.55, "trim", jitter=0.45, seed=seed)
+
+
+def _planter(p, seed):
+    p.box((-0.4, 0.0, -0.4), (0.4, 0.5, 0.4), "prop")
+    p.blob((0, 0.7, 0), 0.4, 0.6, "foliage", jitter=0.3, seed=seed)
+
+
+def _fence(p, seed):
+    for x in (-0.98, 0.9):
+        p.box((x, 0.0, -0.05), (x + 0.08, 1.0, 0.05), "trim")
+    for y in (0.35, 0.8):
+        p.box((-1.0, y, -0.03), (1.0, y + 0.08, 0.03), "trim")
+
+
+def _sign(p, seed):
+    p.box((-0.04, 0.0, -0.04), (0.04, 1.3, 0.04), "trim")
+    p.box((-0.45, 1.0, -0.05), (0.45, 1.5, 0.05), "prop")
+
+
+def _chest(p, seed):
+    p.box((-0.45, 0.0, -0.3), (0.45, 0.45, 0.3), "prop")
+    p.box((-0.47, 0.45, -0.32), (0.47, 0.6, 0.32), "accent")
+    p.box((-0.06, 0.3, -0.33), (0.06, 0.45, -0.3), "trim")
+
+
+def _pot(p, seed):
+    p.cylinder((0, 0, 0), 0.18, 0.26, 0.5, "accent", segments=8)
+
+
+RECIPES = {
+    "crate": _crate, "barrel": _barrel, "table": _table, "chair": _chair,
+    "bench": _bench, "bed": _bed, "shelf": _shelf, "counter": _counter,
+    "pillar": _pillar, "lamp": _lamp, "tree": _tree, "bush": _bush,
+    "rock": _rock, "planter": _planter, "fence": _fence, "sign": _sign,
+    "chest": _chest, "pot": _pot,
+}
+
+
+def build(piece, kind, name):
+    """Build prop `kind` into `piece`. The seed comes from the prop's NAME, so
+    the same spec gives the same rock every time."""
+    recipe = RECIPES.get(kind)
+    if recipe is None:
+        raise ValueError("no recipe for prop kind %r; known: %s" % (kind, ", ".join(sorted(RECIPES))))
+    recipe(piece, zlib.crc32(name.encode()) % 1000)