campfire.py

"""Game-ready campfire — a showcase piece, not an example.

Asserts budget conformance of a procedural campfire (two-course
wedge-stone ring stacked on a shared plane, pit-floor cobbles and ash,
a kissing log tripod, and resting firewood) after composing shipped
pipeline pieces: bmesh construction, UVs, three materials, high-to-low
normal bake, LOD chain, convex collider, Unity glTF export.

The old piece was two floating courses of identical boxes with a
daylight mortar gap, a 12-gon teepee whose tips occupied the same
point, and an empty pit.

Budgets are declared below and recomputed from the generated result.
They are not API-contract witnesses. Each falsifier violates one named
budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
hygiene, ``--lift-z`` grounded zmin, ``--short-stones`` named
bottom-course supports, ``--float-logs`` teepee kiss, ``--gap-courses``
the stacked-course seat.

Fixed seed 17 for stone-width jitter. DECIMATE COLLAPSE triangle counts
are not byte-identical across Blender versions — the LOD gate is a
ratio band, not an exact count.

    blender --background --python campfire.py --
    blender --background --python campfire.py -- --skip-decimate
    blender --background --python campfire.py -- --output campfire.png
"""
import argparse
import math
import os
import random
import sys
import tempfile
import traceback

import bmesh
import bpy
from mathutils import Vector
from mathutils.bvhtree import BVHTree

_REPO = os.path.abspath(
    os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
)
sys.path.insert(0, os.path.join(_REPO, "examples"))
sys.dont_write_bytecode = True
import gallery_framing  # noqa: E402

N_AROUND = 14
N_ROWS = 2
R_INNER = 0.26
R_OUTER = 0.39
R_MID = 0.5 * (R_INNER + R_OUTER)
STONE_H = 0.078
STONE_SEED = 17
STONE_JITTER = 0.22
# Each ring stone is a lofted chamfered section, not a curved brick: a
# seeded belly and radial offset, rounded ends pinched to END_PINCH, and
# (upper course only) a domed crown. Beds stay flat so the courses seat.
STONE_R_JITTER = 0.012
STONE_BULGE = 0.14
STONE_WOBBLE = 0.05
STONE_DOME = 0.020
END_PINCH = 0.62
STONE_CHAMFER = 0.28
STONE_VARY_MIN = 0.006
GAP_ANG = 0.004
N_COBBLES = 12
COBBLE_H = 0.016
ASH_H = 0.010
ASH_R = 0.20
N_STICKS = 3
STICK_R = 0.028
STICK_SEGS = 12
LOG_R = 0.030
LOG_LEN = 0.28
Z_APEX = 0.365
R_BASE = 0.20
COURSE_GAP = 0.022
FLOAT_LOG = 0.055
SHORT_STONES_LIFT = 0.040
LIFT_Z = 0.05
KISS_MAX = 0.008
COURSE_SEAT_MAX = 0.004
STAVE_ZMIN_MAX = 0.001

AREA_EPS = 1e-10
DOUBLES_EPS = 1e-5
ZMIN_EPS = 1e-4
ZFIGHT_EPS = 1e-4
ZFIGHT_COS = 0.998
BODY_TOL = 0.04
RING_DIA = 0.807
RING_H = 0.176
BBOX_TOL = 0.015
OUTER_SIZE = (0.807, 0.808, 0.404)

BASE_TRIS_MIN = 1400
BASE_TRIS_MAX = 3600
LOD1_RATIO_MIN = 0.32
LOD1_RATIO_MAX = 0.62
LOD2_RATIO_MIN = 0.10
LOD2_RATIO_MAX = 0.35
LOD1_TARGET = 0.50
LOD2_TARGET = 0.22
MATERIAL_COUNT = 3
WOOD_FACES_MIN = 80
ASH_FACES_MIN = 24
STONE_FACES_MIN = 200
UV_EPS = 1e-4
UV_OVERLAP_MAX = 1e-5
COLLIDER_TRIS_MAX = 360
BAKE_RES = 256
CAGE_EXTRUSION = 0.06
BOTTOM_COUNT = N_AROUND

STONE_IDX = 0
WOOD_IDX = 1
ASH_IDX = 2

# Per-piece tone jitter and wood grain frequency, as in shipping-crate.
PLANK_TONE_JITTER = 0.25
TONE_SEED = 29
WOOD_GRAIN_SCALE = 45.0


def eevee_engine_id():
    return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"


def fail(msg, code):
    print(f"ERROR: {msg}", file=sys.stderr)
    return code


def triangle_count(mesh):
    mesh.calc_loop_triangles()
    return len(mesh.loop_triangles)


def evaluated_triangle_count(obj):
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    eval_mesh = eval_obj.to_mesh()
    try:
        eval_mesh.calc_loop_triangles()
        return len(eval_mesh.loop_triangles)
    finally:
        eval_obj.to_mesh_clear()


def stone_spans(n, gap_ang, jitter, seed):
    rng = random.Random(seed)
    weights = [1.0 + rng.uniform(-jitter, jitter) for _ in range(n)]
    total = sum(weights)
    usable = 2.0 * math.pi - n * gap_ang
    spans = []
    a = 0.0
    for w in weights:
        width = usable * (w / total)
        spans.append((a, a + width))
        a += width + gap_ang
    return spans


def add_stone(bm, a0, a1, z0, z1, rng, crown, stations, mat_idx):
    """One ring stone: a chamfered octagon section lofted from a0 to a1.

    The section's width swells to a seeded belly mid-stone and pinches to
    END_PINCH at the ends, which are capped, so each stone is a rounded
    lump rather than a curved brick. The bed (z0) is flat on every stone.
    The crown is flat at z1 on the lower course, which the upper course
    sits on, and domed by a seeded ``crown`` on the upper course.
    """
    r_in = R_INNER + rng.uniform(-STONE_R_JITTER, STONE_R_JITTER)
    r_out = R_OUTER + rng.uniform(-STONE_R_JITTER, STONE_R_JITTER)
    bulge = rng.uniform(0.3, 1.0) * STONE_BULGE
    phase = rng.uniform(0.0, 2.0 * math.pi)
    top = z1 + crown
    rings = []
    for k in range(stations):
        t = k / (stations - 1)
        ang = a0 + (a1 - a0) * t
        sw = math.sin(math.pi * t)
        pinch = END_PINCH + (1.0 - END_PINCH) * math.sqrt(sw)
        cr = 0.5 * (r_in + r_out)
        hw = 0.5 * (r_out - r_in) * pinch * (1.0 + bulge * sw)
        lo = cr - hw
        hi = cr + hw * (1.0 + STONE_WOBBLE * math.sin(phase + 3.0 * math.pi * t))
        zt = z0 + (top - z0) * (0.80 + 0.20 * sw)
        c = STONE_CHAMFER * min(hi - lo, zt - z0) * 0.5
        section = (
            (lo + c, z0), (hi - c, z0), (hi, z0 + c), (hi, zt - c),
            (hi - c, zt), (lo + c, zt), (lo, zt - c), (lo, z0 + c),
        )
        ca, sa = math.cos(ang), math.sin(ang)
        rings.append([bm.verts.new((r * ca, r * sa, z)) for r, z in section])
    n = len(rings[0])
    for k in range(stations - 1):
        a, b = rings[k], rings[k + 1]
        for i in range(n):
            j = (i + 1) % n
            f = bm.faces.new((a[i], a[j], b[j], b[i]))
            f.material_index = mat_idx
    for ring, flip in ((rings[0], False), (rings[-1], True)):
        hub = bm.verts.new(sum((v.co for v in ring), Vector()) / n)
        for i in range(n):
            vs = (hub, ring[(i + 1) % n], ring[i])
            f = bm.faces.new(tuple(reversed(vs)) if flip else vs)
            f.material_index = mat_idx
    return [v for ring in rings for v in ring]


def add_cyl_between(bm, a, b, r0, r1, segs, mat_idx):
    a = Vector(a)
    b = Vector(b)
    delta = b - a
    length = delta.length
    if length < 1e-8:
        return []
    geo = bmesh.ops.create_cone(
        bm,
        cap_ends=True,
        cap_tris=True,
        segments=segs,
        radius1=r0,
        radius2=r1,
        depth=length,
    )
    verts = list(geo["verts"])
    quat = Vector((0.0, 0.0, 1.0)).rotation_difference(delta.normalized())
    rot = quat.to_matrix()
    mid = (a + b) * 0.5
    for v in verts:
        v.co = rot @ v.co + mid
    faces = {f for v in verts for f in v.link_faces}
    for f in faces:
        f.material_index = mat_idx
    return verts


def add_ash_disk(bm, radius, height, segs, mat_idx):
    geo = bmesh.ops.create_cone(
        bm,
        cap_ends=True,
        cap_tris=True,
        segments=segs,
        radius1=radius,
        radius2=radius * 0.92,
        depth=height,
    )
    verts = list(geo["verts"])
    for v in verts:
        v.co.z += height * 0.5
    faces = {f for v in verts for f in v.link_faces}
    for f in faces:
        f.material_index = mat_idx
    return verts


def triangulate_ngons(bm):
    faces = [f for f in bm.faces if len(f.verts) > 4]
    if faces:
        bmesh.ops.triangulate(bm, faces=faces)


def pack_uvs(bm, margin=0.08):
    uv = bm.loops.layers.uv.new("UVMap")
    faces = list(bm.faces)
    n = len(faces)
    cols = max(1, math.ceil(math.sqrt(n)))
    rows = max(1, math.ceil(n / cols))
    cell_w = 1.0 / cols
    cell_h = 1.0 / rows
    pad_u = margin * cell_w * 0.5
    pad_v = margin * cell_h * 0.5
    usable_w = cell_w - 2.0 * pad_u
    usable_h = cell_h - 2.0 * pad_v
    for i, face in enumerate(faces):
        col = i % cols
        row = i // cols
        nrm = face.normal
        ax = abs(nrm.x)
        ay = abs(nrm.y)
        az = abs(nrm.z)
        coords = []
        for loop in face.loops:
            co = loop.vert.co
            if az >= ax and az >= ay:
                coords.append((co.x, co.y))
            elif ax >= ay:
                coords.append((co.y, co.z))
            else:
                coords.append((co.x, co.z))
        xs = [c[0] for c in coords]
        ys = [c[1] for c in coords]
        minx, maxx = min(xs), max(xs)
        miny, maxy = min(ys), max(ys)
        dx = max(maxx - minx, 1e-8)
        dy = max(maxy - miny, 1e-8)
        origin_u = col * cell_w + pad_u
        origin_v = row * cell_h + pad_v
        for loop, (x, y) in zip(face.loops, coords):
            loop[uv].uv = (
                origin_u + (x - minx) / dx * usable_w,
                origin_v + (y - miny) / dy * usable_h,
            )


def build_campfire_mesh(
    name,
    bevel_offset,
    bevel_segments,
    short_stones=False,
    float_logs=False,
    gap_courses=False,
    uniform_stones=False,
):
    bm = bmesh.new()
    spans = stone_spans(N_AROUND, GAP_ANG, STONE_JITTER, STONE_SEED)
    z_ground = SHORT_STONES_LIFT if short_stones else 0.0
    extra = COURSE_GAP if gap_courses else 0.0
    stone_verts = []
    try:
        # --uniform-stones gives every stone the same draw: each jitter at its
        # upper bound, so the stones are identical but the ring keeps the
        # envelope of its widest seeded stone.
        class _Flat:
            def uniform(self, a, b):
                return b

        stations = 3 + bevel_segments
        for row in range(N_ROWS):
            z0 = z_ground + row * STONE_H + (extra if row else 0.0)
            z1 = z0 + STONE_H
            rot_off = (row % 2) * (math.pi / N_AROUND)
            for idx, (a0, a1) in enumerate(spans):
                rng = _Flat() if uniform_stones else random.Random(STONE_SEED * 31 + row * 101 + idx)
                crown = STONE_DOME * rng.uniform(0.35, 1.0) if row == N_ROWS - 1 else 0.0
                stone_verts.extend(
                    add_stone(
                        bm, a0 + rot_off, a1 + rot_off, z0, z1, rng, crown,
                        stations, STONE_IDX,
                    )
                )

        add_ash_disk(bm, ASH_R, ASH_H, 16, ASH_IDX)
        rng = random.Random(STONE_SEED)
        for i in range(N_COBBLES):
            ang = 2.0 * math.pi * i / N_COBBLES + 0.18
            r = 0.07 + 0.05 * ((i % 3) / 2.0)
            sz = 0.028 + 0.010 * (i % 2)
            loc = Vector((r * math.cos(ang), r * math.sin(ang), COBBLE_H * 0.5))
            geo = bmesh.ops.create_cube(bm, size=1.0)
            verts = geo["verts"]
            for v in verts:
                p = Vector((
                    v.co.x * (sz * 1.4),
                    v.co.y * sz,
                    v.co.z * COBBLE_H,
                ))
                h = rng.uniform(-0.12, 0.12)
                p = Vector((p.x * (1.0 + h), p.y * (1.0 - 0.5 * h), p.z))
                rot_z = ang + rng.uniform(-0.2, 0.2)
                c, s = math.cos(rot_z), math.sin(rot_z)
                v.co = Vector((
                    p.x * c - p.y * s,
                    p.x * s + p.y * c,
                    p.z,
                )) + loc
            for f in {f for v in verts for f in v.link_faces}:
                f.material_index = STONE_IDX

        apex_ring = (STICK_R * 0.55) / math.sin(math.pi / N_STICKS)
        if float_logs:
            apex_ring *= 2.8
        z_base = COBBLE_H + STICK_R * 0.35
        overshoot = STICK_R * 1.15
        for i in range(N_STICKS):
            yaw = i * (2.0 * math.pi / N_STICKS) + math.pi / 6.0
            base = Vector((
                R_BASE * math.cos(yaw),
                R_BASE * math.sin(yaw),
                z_base,
            ))
            apex = Vector((
                apex_ring * math.cos(yaw),
                apex_ring * math.sin(yaw),
                Z_APEX - i * (STICK_R * 0.55),
            ))
            direction = (apex - base).normalized()
            end = apex + direction * overshoot
            add_cyl_between(
                bm, base, end, STICK_R, STICK_R * 0.78, STICK_SEGS, WOOD_IDX,
            )

        for i in range(2):
            yaw = i * (math.pi / 2.0) + math.radians(22.0)
            z = COBBLE_H + LOG_R + 0.010 * i
            a = Vector((
                0.5 * LOG_LEN * math.cos(yaw),
                0.5 * LOG_LEN * math.sin(yaw),
                z,
            ))
            b = Vector((-a.x, -a.y, z))
            add_cyl_between(bm, a, b, LOG_R * (1.0 - 0.06 * i), LOG_R * 0.86, 12, WOOD_IDX)

        for i in range(6):
            ang = 2.0 * math.pi * i / 6.0 + 0.4
            r = 0.04 + 0.02 * (i % 2)
            sz = 0.018 + 0.006 * (i % 3)
            loc = (
                r * math.cos(ang),
                r * math.sin(ang),
                ASH_H + sz * 0.45,
            )
            geo = bmesh.ops.create_cube(bm, size=1.0)
            verts = geo["verts"]
            for v in verts:
                p = Vector((v.co.x * sz * 1.3, v.co.y * sz, v.co.z * sz * 0.7))
                c, s = math.cos(ang), math.sin(ang)
                v.co = Vector((p.x * c - p.y * s, p.x * s + p.y * c, p.z)) + Vector(loc)
            for f in {f for v in verts for f in v.link_faces}:
                f.material_index = WOOD_IDX

        triangulate_ngons(bm)
        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=1e-5)
        bmesh.ops.dissolve_degenerate(bm, dist=1e-6)
        pack_uvs(bm)
        bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
        for face in bm.faces:
            face.smooth = face.material_index == WOOD_IDX
        for edge in bm.edges:
            mats = {f.material_index for f in edge.link_faces}
            if WOOD_IDX in mats and STONE_IDX not in mats and ASH_IDX not in mats:
                edge.smooth = True
                if edge.is_manifold and len(edge.link_faces) == 2:
                    if edge.calc_face_angle() > math.radians(38.0):
                        edge.smooth = False
            else:
                edge.smooth = False
        me = bpy.data.meshes.new(name)
        bm.to_mesh(me)
        me.update()
        for poly in me.polygons:
            poly.use_smooth = poly.material_index == WOOD_IDX
    finally:
        bm.free()
    obj = bpy.data.objects.new(name, me)
    bpy.context.collection.objects.link(obj)
    return obj


def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
    mat = bpy.data.materials.new(name)
    mat.use_nodes = True
    nt = mat.node_tree
    bsdf = nt.nodes["Principled BSDF"]
    bsdf.inputs["Base Color"].default_value = color
    bsdf.inputs["Metallic"].default_value = metallic
    bsdf.inputs["Roughness"].default_value = roughness
    if noise_scale > 0.0 and wear is not None:
        tex = nt.nodes.new("ShaderNodeTexNoise")
        tex.inputs["Scale"].default_value = noise_scale
        tex.inputs["Detail"].default_value = 8.0
        tex.inputs["Roughness"].default_value = 0.55
        mix = nt.nodes.new("ShaderNodeMix")
        mix.data_type = "RGBA"
        mix.inputs["A"].default_value = color
        mix.inputs["B"].default_value = wear
        fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
        nt.links.new(tex.outputs["Fac"], fac)
        nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
        rmix = nt.nodes.new("ShaderNodeMix")
        rmix.data_type = "FLOAT"
        rmix.inputs["A"].default_value = roughness
        rmix.inputs["B"].default_value = min(1.0, roughness + 0.16)
        rfac = rmix.inputs.get("Factor") or rmix.inputs.get("Fac")
        nt.links.new(tex.outputs["Fac"], rfac)
        nt.links.new(rmix.outputs["Result"], bsdf.inputs["Roughness"])
    return mat


def assign_slots(obj, stone, wood, ash):
    mats = obj.data.materials
    wanted = (stone, wood, ash)
    for i, mat in enumerate(wanted):
        if i < len(mats):
            mats[i] = mat
        else:
            mats.append(mat)


def world_bbox(obj):
    corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
    xs = [c.x for c in corners]
    ys = [c.y for c in corners]
    zs = [c.z for c in corners]
    return (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))


def face_area(me, poly):
    verts = [me.vertices[i].co for i in poly.vertices]
    if len(verts) < 3:
        return 0.0
    acc = Vector((0.0, 0.0, 0.0))
    origin = verts[0]
    for a, b in zip(verts[1:], verts[2:]):
        acc += (a - origin).cross(b - origin)
    return 0.5 * acc.length


def uv_stats(mesh):
    uv = mesh.uv_layers.active
    if uv is None:
        return 0.0, 0.0, 1.0, 1.0, 0, 1.0
    data = uv.data
    us = [loop.uv[0] for loop in data]
    vs = [loop.uv[1] for loop in data]
    aabbs = []
    for poly in mesh.polygons:
        pu = [data[i].uv[0] for i in poly.loop_indices]
        pv = [data[i].uv[1] for i in poly.loop_indices]
        aabbs.append((min(pu), min(pv), max(pu), max(pv)))
    overlap = 0.0
    for i in range(len(aabbs)):
        a = aabbs[i]
        for j in range(i + 1, len(aabbs)):
            b = aabbs[j]
            x0 = max(a[0], b[0])
            y0 = max(a[1], b[1])
            x1 = min(a[2], b[2])
            y1 = min(a[3], b[3])
            overlap += max(0.0, x1 - x0) * max(0.0, y1 - y0)
    return min(us), min(vs), max(us), max(vs), overlap, len(aabbs)


def hygiene_audit(me):
    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
    ngons = sum(1 for p in me.polygons if len(p.vertices) > 4)
    zero_area = sum(1 for p in me.polygons if face_area(me, p) <= AREA_EPS)
    bm = bmesh.new()
    try:
        bm.from_mesh(me)
        bm.verts.ensure_lookup_table()
        bm.edges.ensure_lookup_table()
        loose_v = sum(1 for v in bm.verts if len(v.link_edges) == 0)
        loose_e = sum(1 for e in bm.edges if len(e.link_faces) == 0)
        nonman = sum(1 for e in bm.edges if not e.is_manifold)
        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
        doubles = len(ret.get("targetmap") or {})
    finally:
        bm.free()
    return {
        "nv": nv, "ne": ne, "nf": nf, "ngons": ngons,
        "loose_v": loose_v, "loose_e": loose_e, "nonman": nonman,
        "zero_area": zero_area, "doubles": doubles, "euler": nv - ne + nf,
    }


def zfight_pairs(me):
    data = [
        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
        for p in me.polygons
    ]
    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
    count = 0
    for i in range(len(data)):
        ci, ni, vi = data[i]
        for j in range(i + 1, len(data)):
            cj, nj, vj = data[j]
            if (cj - ci).length_squared > eps2:
                continue
            if abs(ni.dot(nj)) <= ZFIGHT_COS:
                continue
            if vi & vj:
                continue
            count += 1
    return count


def shells(me):
    neighbors = [[] for _ in range(len(me.vertices))]
    for edge in me.edges:
        a, b = edge.vertices
        neighbors[a].append(b)
        neighbors[b].append(a)
    seen = [False] * len(me.vertices)
    groups = []
    for start in range(len(me.vertices)):
        if seen[start]:
            continue
        seen[start] = True
        stack = [start]
        group = []
        while stack:
            current = stack.pop()
            group.append(current)
            for nxt in neighbors[current]:
                if not seen[nxt]:
                    seen[nxt] = True
                    stack.append(nxt)
        groups.append(group)
    return groups


def shell_aabb(me, group):
    pts = [me.vertices[i].co for i in group]
    return (
        min(p.x for p in pts), min(p.y for p in pts), min(p.z for p in pts),
        max(p.x for p in pts), max(p.y for p in pts), max(p.z for p in pts),
    )


def mat_of(me, group):
    member = set(group)
    for p in me.polygons:
        if all(i in member for i in p.vertices):
            return p.material_index
    return None


def support_audit(me):
    groups = shells(me)
    bottoms = []
    for g in groups:
        if mat_of(me, g) != STONE_IDX:
            continue
        a = shell_aabb(me, g)
        dz = a[5] - a[2]
        r = 0.25 * ((a[3] - a[0]) + (a[4] - a[1]))
        if dz > 0.05 and r > 0.04 and a[2] < 0.02:
            bottoms.append(a)
    zmin = min((a[2] for a in bottoms), default=99.0)
    return {"stones": len(bottoms), "stone_z": zmin}


def course_seat(me):
    groups = shells(me)
    lower, upper = [], []
    for g in groups:
        if mat_of(me, g) != STONE_IDX:
            continue
        a = shell_aabb(me, g)
        dz = a[5] - a[2]
        r = 0.25 * ((a[3] - a[0]) + (a[4] - a[1]))
        if dz < 0.05 or r < 0.04:
            continue
        mid = 0.5 * (a[2] + a[5])
        if mid < STONE_H:
            lower.append(a)
        else:
            upper.append(a)
    if not lower or not upper:
        return 99.0
    return min(a[2] for a in upper) - max(a[5] for a in lower)


def teepee_kiss(me):
    groups = shells(me)
    sticks = []
    for g in groups:
        if mat_of(me, g) != WOOD_IDX:
            continue
        a = shell_aabb(me, g)
        if a[5] < 0.25:
            continue
        sticks.append(g)
    if len(sticks) < 2:
        return 99.0
    trees = []
    for g in sticks:
        bm_s = bmesh.new()
        bm_s.from_mesh(me)
        keep = set(g)
        drop = [f for f in bm_s.faces if not all(v.index in keep for v in f.verts)]
        if drop:
            bmesh.ops.delete(bm_s, geom=drop, context="FACES")
        if bm_s.faces:
            trees.append((g, BVHTree.FromBMesh(bm_s), bm_s))
        else:
            bm_s.free()
    best = 99.0
    try:
        for i in range(len(trees)):
            g, _tree, _bm = trees[i]
            zmax = max(me.vertices[k].co.z for k in g)
            for j in range(i + 1, len(trees)):
                tree = trees[j][1]
                pair = 99.0
                for k in g:
                    p = me.vertices[k].co
                    if p.z < zmax - 0.10:
                        continue
                    loc, _n, _idx, dist = tree.find_nearest(p)
                    if loc is None:
                        continue
                    pair = min(pair, dist)
                best = min(best, pair)
        return best
    finally:
        for _g, _t, bm_s in trees:
            bm_s.free()


def stone_variation(me):
    """Spread of the ring stones' crowns and outer radii, in metres.

    Identical stones read instantly as CG. Across the stones of each
    course, the spread (max - min) of each stone's top and of its outer
    radius is measured from the mesh; the smaller of the two spreads,
    over both courses, must clear STONE_VARY_MIN.
    """
    courses = {}
    for g in shells(me):
        if mat_of(me, g) != STONE_IDX:
            continue
        a = shell_aabb(me, g)
        if a[5] - a[2] < 0.05:
            continue
        top = a[5]
        r_out = max(math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) for i in g)
        row = 0 if 0.5 * (a[2] + a[5]) < STONE_H else 1
        courses.setdefault(row, []).append((top, r_out))
    spreads = []
    for row, vals in courses.items():
        tops = [v[0] for v in vals]
        radii = [v[1] for v in vals]
        if row == N_ROWS - 1:
            spreads.append(max(tops) - min(tops))
        spreads.append(max(radii) - min(radii))
    return min(spreads, default=0.0)


def _long_axis(pts):
    """Principal axis of a point set, by power iteration on its covariance."""
    c = sum(pts, Vector()) / len(pts)
    cov = [[0.0] * 3 for _ in range(3)]
    for p in pts:
        d = p - c
        for i in range(3):
            for j in range(3):
                cov[i][j] += d[i] * d[j]
    v = Vector((1.0, 0.3, 0.1))
    for _ in range(30):
        w = Vector([sum(cov[i][j] * v[j] for j in range(3)) for i in range(3)])
        if w.length < 1e-12:
            break
        v = w.normalized()
    return v


def paint_pieces(me):
    """Per-shell ``PieceTone`` and ``GrainDir`` face attributes.

    Every stone, stick and log is its own shell, so each gets one tone,
    and the wood shader runs grain along each piece's own long axis.
    """
    tone = [0.5] * len(me.polygons)
    grain = [(0.0, 0.0, 1.0)] * len(me.polygons)
    owner = {}
    rng = random.Random(TONE_SEED)
    for g in shells(me):
        pts = [me.vertices[i].co.copy() for i in g]
        d = _long_axis(pts) if len(pts) > 2 else Vector((0.0, 0.0, 1.0))
        t = 0.5 + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
        for i in g:
            owner[i] = (t, tuple(d))
    for poly in me.polygons:
        t, d = owner[poly.vertices[0]]
        tone[poly.index] = t
        grain[poly.index] = d
    a = me.attributes.new("PieceTone", "FLOAT", "FACE")
    a.data.foreach_set("value", tone)
    b = me.attributes.new("GrainDir", "FLOAT_VECTOR", "FACE")
    b.data.foreach_set("vector", [c for v in grain for c in v])


def _sock(sockets, identifier):
    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
    return next(sk for sk in sockets if sk.identifier == identifier)


def wood_material(name):
    """Grain along each stick and log (``GrainDir``), tone per piece (``PieceTone``)."""
    mat = bpy.data.materials.new(name)
    mat.use_nodes = True
    nt = mat.node_tree
    bsdf = nt.nodes["Principled BSDF"]
    coord = nt.nodes.new("ShaderNodeTexCoord")
    gdir = nt.nodes.new("ShaderNodeAttribute")
    gdir.attribute_name = "GrainDir"
    tone = nt.nodes.new("ShaderNodeAttribute")
    tone.attribute_name = "PieceTone"
    dot = nt.nodes.new("ShaderNodeVectorMath")
    dot.operation = "DOT_PRODUCT"
    nt.links.new(coord.outputs["Object"], dot.inputs[0])
    nt.links.new(gdir.outputs["Vector"], dot.inputs[1])
    squash = nt.nodes.new("ShaderNodeMath")
    squash.operation = "MULTIPLY"
    squash.inputs[1].default_value = 0.94
    nt.links.new(dot.outputs["Value"], squash.inputs[0])
    along = nt.nodes.new("ShaderNodeVectorMath")
    along.operation = "SCALE"
    nt.links.new(gdir.outputs["Vector"], along.inputs[0])
    nt.links.new(squash.outputs["Value"], along.inputs["Scale"])
    grain_co = nt.nodes.new("ShaderNodeVectorMath")
    grain_co.operation = "SUBTRACT"
    nt.links.new(coord.outputs["Object"], grain_co.inputs[0])
    nt.links.new(along.outputs["Vector"], grain_co.inputs[1])
    shift = nt.nodes.new("ShaderNodeVectorMath")
    shift.operation = "ADD"
    nt.links.new(grain_co.outputs["Vector"], shift.inputs[0])
    nt.links.new(tone.outputs["Fac"], shift.inputs[1])
    noise = nt.nodes.new("ShaderNodeTexNoise")
    noise.inputs["Scale"].default_value = WOOD_GRAIN_SCALE
    noise.inputs["Detail"].default_value = 6.0
    noise.inputs["Roughness"].default_value = 0.62
    nt.links.new(shift.outputs["Vector"], noise.inputs["Vector"])
    ramp = nt.nodes.new("ShaderNodeValToRGB")
    ramp.color_ramp.elements[0].position = 0.30
    ramp.color_ramp.elements[0].color = (0.12, 0.052, 0.018, 1.0)
    ramp.color_ramp.elements[1].position = 0.72
    ramp.color_ramp.elements[1].color = (0.38, 0.18, 0.065, 1.0)
    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
    gain = nt.nodes.new("ShaderNodeMath")
    gain.operation = "MULTIPLY_ADD"
    gain.inputs[1].default_value = 1.1
    gain.inputs[2].default_value = 0.45
    nt.links.new(tone.outputs["Fac"], gain.inputs[0])
    mix = nt.nodes.new("ShaderNodeMix")
    mix.data_type = "RGBA"
    mix.blend_type = "MULTIPLY"
    _sock(mix.inputs, "Factor_Float").default_value = 1.0
    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
    nt.links.new(gain.outputs["Value"], _sock(mix.inputs, "B_Color"))
    nt.links.new(_sock(mix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
    rough = nt.nodes.new("ShaderNodeMapRange")
    rough.inputs["To Min"].default_value = 0.72
    rough.inputs["To Max"].default_value = 0.52
    nt.links.new(noise.outputs["Fac"], rough.inputs["Value"])
    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
    # Char: heat falls off with distance from the fire's core (the ash bed at
    # the ring centre), so the tripod blackens toward the flames and keeps its
    # bark colour at the far ends. Inside the char, cracked embers glow.
    heat = _heat_field(nt, coord)
    char = nt.nodes.new("ShaderNodeMapRange")
    char.inputs["From Min"].default_value = 0.12
    char.inputs["From Max"].default_value = 0.55
    nt.links.new(heat, char.inputs["Value"])
    cmix = nt.nodes.new("ShaderNodeMix")
    cmix.data_type = "RGBA"
    nt.links.new(char.outputs["Result"], _sock(cmix.inputs, "Factor_Float"))
    nt.links.new(_sock(mix.outputs, "Result_Color"), _sock(cmix.inputs, "A_Color"))
    _sock(cmix.inputs, "B_Color").default_value = (0.016, 0.013, 0.011, 1.0)
    nt.links.new(_sock(cmix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
    crack = nt.nodes.new("ShaderNodeTexVoronoi")
    crack.feature = "DISTANCE_TO_EDGE"
    crack.inputs["Scale"].default_value = 42.0
    nt.links.new(coord.outputs["Object"], crack.inputs["Vector"])
    seam = nt.nodes.new("ShaderNodeMapRange")
    seam.inputs["From Min"].default_value = 0.0
    seam.inputs["From Max"].default_value = 0.035
    seam.inputs["To Min"].default_value = 1.0
    seam.inputs["To Max"].default_value = 0.0
    nt.links.new(crack.outputs["Distance"], seam.inputs["Value"])
    glow = nt.nodes.new("ShaderNodeMath")
    glow.operation = "MULTIPLY"
    nt.links.new(seam.outputs["Result"], glow.inputs[0])
    hot = nt.nodes.new("ShaderNodeMapRange")
    hot.inputs["From Min"].default_value = 0.70
    hot.inputs["From Max"].default_value = 0.95
    nt.links.new(heat, hot.inputs["Value"])
    nt.links.new(hot.outputs["Result"], glow.inputs[1])
    # only some of the cracks are live: a coarse noise mask breaks the net
    live = nt.nodes.new("ShaderNodeTexNoise")
    live.inputs["Scale"].default_value = 9.0
    live.inputs["Detail"].default_value = 2.0
    nt.links.new(coord.outputs["Object"], live.inputs["Vector"])
    lmap = nt.nodes.new("ShaderNodeMapRange")
    lmap.inputs["From Min"].default_value = 0.48
    lmap.inputs["From Max"].default_value = 0.62
    nt.links.new(live.outputs["Fac"], lmap.inputs["Value"])
    masked = nt.nodes.new("ShaderNodeMath")
    masked.operation = "MULTIPLY"
    nt.links.new(glow.outputs["Value"], masked.inputs[0])
    nt.links.new(lmap.outputs["Result"], masked.inputs[1])
    bsdf.inputs["Emission Color"].default_value = (1.0, 0.30, 0.05, 1.0)
    estr = nt.nodes.new("ShaderNodeMath")
    estr.operation = "MULTIPLY"
    estr.inputs[1].default_value = 3.5
    nt.links.new(masked.outputs["Value"], estr.inputs[0])
    nt.links.new(estr.outputs["Value"], bsdf.inputs["Emission Strength"])
    return mat


def _heat_field(nt, coord):
    """0..1 heat: 1 at the fire's core just above the ash bed, 0 by ~0.34 m out."""
    off = nt.nodes.new("ShaderNodeVectorMath")
    off.operation = "SUBTRACT"
    off.inputs[1].default_value = (0.0, 0.0, 0.06)
    nt.links.new(coord.outputs["Object"], off.inputs[0])
    dist = nt.nodes.new("ShaderNodeVectorMath")
    dist.operation = "LENGTH"
    nt.links.new(off.outputs["Vector"], dist.inputs[0])
    heat = nt.nodes.new("ShaderNodeMapRange")
    heat.inputs["From Min"].default_value = 0.34
    heat.inputs["From Max"].default_value = 0.04
    nt.links.new(dist.outputs["Value"], heat.inputs["Value"])
    return heat.outputs["Result"]


def stone_material(name, light, dark, roughness, mottle, speck, bump, soot=0.0, spread=0.8):
    """Fieldstone: isotropic mottling, speckle and pitting, a tone per stone.

    Copied from stone-archway, reading ``PieceTone`` for the per-stone
    shade. Nothing in the pattern has a direction, so it cannot read as
    wood grain the way stretched noise does.
    """
    mat = bpy.data.materials.new(name)
    mat.use_nodes = True
    nt = mat.node_tree
    bsdf = nt.nodes["Principled BSDF"]
    coord = nt.nodes.new("ShaderNodeTexCoord")
    mot = nt.nodes.new("ShaderNodeTexNoise")
    mot.inputs["Scale"].default_value = mottle
    mot.inputs["Detail"].default_value = 4.0
    mot.inputs["Roughness"].default_value = 0.55
    nt.links.new(coord.outputs["Object"], mot.inputs["Vector"])
    ramp = nt.nodes.new("ShaderNodeValToRGB")
    ramp.color_ramp.elements[0].position = 0.32
    ramp.color_ramp.elements[0].color = dark
    ramp.color_ramp.elements[1].position = 0.70
    ramp.color_ramp.elements[1].color = light
    nt.links.new(mot.outputs["Fac"], ramp.inputs["Fac"])
    spk = nt.nodes.new("ShaderNodeTexNoise")
    spk.inputs["Scale"].default_value = speck
    spk.inputs["Detail"].default_value = 2.0
    nt.links.new(coord.outputs["Object"], spk.inputs["Vector"])
    gain = nt.nodes.new("ShaderNodeMapRange")
    gain.inputs["To Min"].default_value = 0.82
    gain.inputs["To Max"].default_value = 1.12
    nt.links.new(spk.outputs["Fac"], gain.inputs["Value"])
    mix = nt.nodes.new("ShaderNodeMix")
    mix.data_type = "RGBA"
    mix.blend_type = "MULTIPLY"
    _sock(mix.inputs, "Factor_Float").default_value = 1.0
    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
    nt.links.new(gain.outputs["Result"], _sock(mix.inputs, "B_Color"))
    tone = nt.nodes.new("ShaderNodeAttribute")
    tone.attribute_name = "PieceTone"
    shade = nt.nodes.new("ShaderNodeMath")
    shade.operation = "MULTIPLY_ADD"
    shade.inputs[1].default_value = spread
    shade.inputs[2].default_value = 1.0 - 0.5 * spread
    nt.links.new(tone.outputs["Fac"], shade.inputs[0])
    mix2 = nt.nodes.new("ShaderNodeMix")
    mix2.data_type = "RGBA"
    mix2.blend_type = "MULTIPLY"
    _sock(mix2.inputs, "Factor_Float").default_value = 1.0
    nt.links.new(_sock(mix.outputs, "Result_Color"), _sock(mix2.inputs, "A_Color"))
    nt.links.new(shade.outputs["Value"], _sock(mix2.inputs, "B_Color"))
    nt.links.new(_sock(mix2.outputs, "Result_Color"), bsdf.inputs["Base Color"])
    if soot:
        # smoke-blackened where the stones face the fire, patchy by mottle
        heat = _heat_field(nt, coord)
        smap = nt.nodes.new("ShaderNodeMapRange")
        smap.inputs["From Min"].default_value = 0.05
        smap.inputs["From Max"].default_value = 0.40
        smap.inputs["To Max"].default_value = soot
        nt.links.new(heat, smap.inputs["Value"])
        patch = nt.nodes.new("ShaderNodeMath")
        patch.operation = "MULTIPLY"
        nt.links.new(smap.outputs["Result"], patch.inputs[0])
        nt.links.new(mot.outputs["Fac"], patch.inputs[1])
        pmul = nt.nodes.new("ShaderNodeMath")
        pmul.operation = "MULTIPLY"
        pmul.inputs[1].default_value = 1.6
        pmul.use_clamp = True
        nt.links.new(patch.outputs["Value"], pmul.inputs[0])
        smix = nt.nodes.new("ShaderNodeMix")
        smix.data_type = "RGBA"
        nt.links.new(pmul.outputs["Value"], _sock(smix.inputs, "Factor_Float"))
        nt.links.new(_sock(mix2.outputs, "Result_Color"), _sock(smix.inputs, "A_Color"))
        _sock(smix.inputs, "B_Color").default_value = (0.022, 0.019, 0.017, 1.0)
        nt.links.new(_sock(smix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
    rough = nt.nodes.new("ShaderNodeMapRange")
    rough.inputs["To Min"].default_value = roughness - 0.06
    rough.inputs["To Max"].default_value = min(1.0, roughness + 0.08)
    nt.links.new(spk.outputs["Fac"], rough.inputs["Value"])
    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
    if bump > 0.0:
        bmp = nt.nodes.new("ShaderNodeBump")
        bmp.inputs["Strength"].default_value = bump
        bmp.inputs["Distance"].default_value = 0.002
        nt.links.new(spk.outputs["Fac"], bmp.inputs["Height"])
        nt.links.new(bmp.outputs["Normal"], bsdf.inputs["Normal"])
    return mat


def ash_material(name):
    """Grey ash with a few embers: sparse orange emission from a noise threshold."""
    mat = principled(name, (0.11, 0.105, 0.10, 1.0), 0.0, 0.95,
                     noise_scale=10.0, wear=(0.05, 0.045, 0.04, 1.0))
    nt = mat.node_tree
    bsdf = nt.nodes["Principled BSDF"]
    coord = nt.nodes.new("ShaderNodeTexCoord")
    hot = nt.nodes.new("ShaderNodeTexNoise")
    hot.inputs["Scale"].default_value = 28.0
    hot.inputs["Detail"].default_value = 3.0
    nt.links.new(coord.outputs["Object"], hot.inputs["Vector"])
    ramp = nt.nodes.new("ShaderNodeValToRGB")
    ramp.color_ramp.elements[0].position = 0.62
    ramp.color_ramp.elements[0].color = (0.0, 0.0, 0.0, 1.0)
    ramp.color_ramp.elements[1].position = 0.74
    ramp.color_ramp.elements[1].color = (1.0, 0.32, 0.06, 1.0)
    nt.links.new(hot.outputs["Fac"], ramp.inputs["Fac"])
    nt.links.new(ramp.outputs["Color"], bsdf.inputs["Emission Color"])
    bsdf.inputs["Emission Strength"].default_value = 2.5
    return mat


def campfire_materials():
    """(stone, wood, ash): shared by the check, the render and inspection."""
    stone = stone_material(
        "CampfireStone", (0.24, 0.20, 0.155, 1.0), (0.085, 0.07, 0.055, 1.0),
        0.86, mottle=6.0, speck=160.0, bump=0.6, soot=0.85, spread=1.3,
    )
    wood = wood_material("CampfireWood")
    ash = ash_material("CampfireAsh")
    return stone, wood, ash


def body_plan(me):
    groups = shells(me)
    xs, ys, z0s, z1s = [], [], [], []
    for g in groups:
        if mat_of(me, g) != STONE_IDX:
            continue
        a = shell_aabb(me, g)
        if a[5] - a[2] < 0.05:
            continue
        xs.extend((a[0], a[3]))
        ys.extend((a[1], a[4]))
        z0s.append(a[2])
        z1s.append(a[5])
    if not xs:
        return 0.0, 0.0
    dia = 0.5 * ((max(xs) - min(xs)) + (max(ys) - min(ys)))
    return dia, max(z1s) - min(z0s)


def add_stray_vert(me):
    bm = bmesh.new()
    try:
        bm.from_mesh(me)
        bm.verts.new((0.0, 0.0, 0.20))
        bm.to_mesh(me)
        me.update()
    finally:
        bm.free()


def make_lod(obj, name, ratio, skip_decimate):
    mesh = obj.data.copy()
    lod = bpy.data.objects.new(name, mesh)
    lod.matrix_world = obj.matrix_world.copy()
    bpy.context.collection.objects.link(lod)
    if not skip_decimate and 0.0 < ratio < 1.0:
        mod = lod.modifiers.new("DecimateBudget", "DECIMATE")
        mod.decimate_type = "COLLAPSE"
        mod.ratio = ratio
    return lod


def convex_hull_collider(obj, name):
    mesh = bpy.data.meshes.new(name)
    bm = bmesh.new()
    try:
        bm.from_mesh(obj.data)
        result = bmesh.ops.convex_hull(bm, input=list(bm.verts))
        interior = result.get("geom_interior") or []
        unused = result.get("geom_unused") or []
        if interior:
            bmesh.ops.delete(bm, geom=interior, context="VERTS")
        if unused:
            bmesh.ops.delete(bm, geom=unused, context="VERTS")
        bmesh.ops.dissolve_limit(
            bm,
            angle_limit=math.radians(10.0),
            verts=list(bm.verts),
            edges=list(bm.edges),
            delimit={"NORMAL"},
        )
        bmesh.ops.triangulate(bm, faces=list(bm.faces))
        bm.to_mesh(mesh)
        mesh.update()
    finally:
        bm.free()
    collider = bpy.data.objects.new(name, mesh)
    bpy.context.collection.objects.link(collider)
    collider.matrix_world = obj.matrix_world.copy()
    return collider


def setup_bake_image(obj, target_mat, size=BAKE_RES):
    if not obj.data.uv_layers:
        return None, None
    img = bpy.data.images.new("CampfireNrm", size, size, alpha=True, float_buffer=False)
    img.colorspace_settings.name = "Non-Color"
    nodes = target_mat.node_tree.nodes
    tex = nodes.new("ShaderNodeTexImage")
    tex.image = img
    nodes.active = tex
    tex.select = True
    obj.active_material_index = STONE_IDX
    return img, tex


def bake_normal(high, low):
    scene = bpy.context.scene
    scene.render.engine = "CYCLES"
    scene.cycles.device = "CPU"
    scene.cycles.samples = 1
    scene.cycles.use_denoising = False
    for ob in bpy.context.view_layer.objects:
        ob.select_set(False)
    high.select_set(True)
    low.select_set(True)
    bpy.context.view_layer.objects.active = low
    return bpy.ops.object.bake(
        type="NORMAL",
        use_selected_to_active=True,
        cage_extrusion=CAGE_EXTRUSION,
        use_cage=False,
        normal_space="TANGENT",
        margin=4,
        margin_type="ADJACENT_FACES",
        use_clear=True,
        target="IMAGE_TEXTURES",
    )


def export_unity(path, objects):
    for ob in bpy.context.view_layer.objects:
        ob.select_set(False)
    for ob in objects:
        ob.select_set(True)
    bpy.context.view_layer.objects.active = objects[0]
    bpy.ops.export_scene.gltf(
        filepath=path,
        use_selection=True,
        export_yup=True,
        export_apply=True,
        export_draco_mesh_compression_enable=False,
        export_animations=False,
    )


def check(
    skip_decimate,
    lift_z=False,
    stray_vert=False,
    short_stones=False,
    float_logs=False,
    gap_courses=False,
    uniform_stones=False,
):
    bpy.ops.wm.read_factory_settings(use_empty=True)
    flags = dict(
        short_stones=short_stones,
        float_logs=float_logs,
        gap_courses=gap_courses,
        uniform_stones=uniform_stones,
    )
    low = build_campfire_mesh("CampfireLow", 0.006, 2, **flags)
    high = build_campfire_mesh("CampfireHigh", 0.006, 4, **flags)
    stone, wood, ash = campfire_materials()
    paint_pieces(low.data)
    paint_pieces(high.data)
    assign_slots(low, stone, wood, ash)
    assign_slots(high, stone, wood, ash)
    if stray_vert:
        add_stray_vert(low.data)
    if lift_z:
        for v in low.data.vertices:
            v.co.z += LIFT_Z
        low.data.update()
        bpy.context.view_layer.update()

    if low.data is None or len(low.data.polygons) < 6:
        return fail("campfire mesh did not build", 3), None, None, None, None, None

    base_tris = triangle_count(low.data)
    mats = [s for s in low.data.materials if s is not None]
    nmat = len(mats)
    distinct_mats = len({id(s) for s in mats})
    idx_counts = {}
    for poly in low.data.polygons:
        idx_counts[poly.material_index] = idx_counts.get(poly.material_index, 0) + 1
    print(f"measured mat_index_counts={idx_counts}")
    u0, v0, u1, v1, overlap, nfaces = uv_stats(low.data)
    bb = world_bbox(low)
    size_x = bb[3] - bb[0]
    size_y = bb[4] - bb[1]
    size_z = bb[5] - bb[2]
    hyg = hygiene_audit(low.data)
    zf = zfight_pairs(low.data)
    sup = support_audit(low.data)
    cseat = course_seat(low.data)
    kiss = teepee_kiss(low.data)
    vary = stone_variation(low.data)
    dia, ht = body_plan(low.data)
    print(
        f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
        f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}"
    )
    print(
        f"measured stones={sup['stones']} stone_z={sup['stone_z']:.5f} "
        f"course_seat={cseat:.5f} kiss={kiss:.5f} body={dia:.4f}x{ht:.4f}"
    )
    print(f"measured stone_variation={vary:.5f}")

    img, tex = setup_bake_image(low, stone)
    if img is None:
        return fail("campfire has no UV layer", 3), None, None, None, None, None
    bake_result = bake_normal(high, low)

    lod1 = make_lod(low, "CampfireLOD1", LOD1_TARGET, skip_decimate)
    lod2 = make_lod(low, "CampfireLOD2", LOD2_TARGET, skip_decimate)
    bpy.context.view_layer.update()
    lod1_tris = evaluated_triangle_count(lod1)
    lod2_tris = evaluated_triangle_count(lod2)
    r1 = lod1_tris / base_tris if base_tris else 0.0
    r2 = lod2_tris / base_tris if base_tris else 0.0

    collider_src = build_campfire_mesh("CampfireColSrc", 0.0, 1)
    collider = convex_hull_collider(collider_src, "CampfireCollider")
    bpy.data.objects.remove(collider_src, do_unlink=True)
    col_tris = triangle_count(collider.data)

    export_path = os.path.join(
        tempfile.gettempdir(),
        f"bdt_campfire_{os.getpid()}.glb",
    )
    if os.path.exists(export_path):
        os.remove(export_path)
    export_unity(export_path, [low, collider])
    export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
    # Blender points TMPDIR at the working directory, so the export must not
    # outlive the measurement.
    if os.path.exists(export_path):
        os.remove(export_path)

    print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
    print(
        f"measured base_tris={base_tris} lod1_tris={lod1_tris} "
        f"lod2_tris={lod2_tris} r1={r1:.4f} r2={r2:.4f}"
    )
    print(
        f"measured nmat={nmat} uv=({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f}) "
        f"overlap={overlap:.6f} nfaces={nfaces}"
    )
    print(
        f"measured bbox=({size_x:.4f},{size_y:.4f},{size_z:.4f}) "
        f"outer={OUTER_SIZE} zmin={bb[2]:.4f}"
    )
    print(
        f"measured collider_tris={col_tris} bake={bake_result} "
        f"bake_has_data={img.has_data} export_bytes={export_size}"
    )

    if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
        return fail(
            f"base tris {base_tris} not in [{BASE_TRIS_MIN}, {BASE_TRIS_MAX}]",
            4,
        ), None, None, None, None, None
    if nmat != MATERIAL_COUNT or distinct_mats != MATERIAL_COUNT:
        return fail(
            f"material slots {nmat} distinct {distinct_mats} != {MATERIAL_COUNT}",
            5,
        ), None, None, None, None, None
    if idx_counts.get(WOOD_IDX, 0) < WOOD_FACES_MIN:
        return fail(
            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}",
            5,
        ), None, None, None, None, None
    if idx_counts.get(ASH_IDX, 0) < ASH_FACES_MIN:
        return fail(
            f"ash faces {idx_counts.get(ASH_IDX, 0)} < {ASH_FACES_MIN}",
            5,
        ), None, None, None, None, None
    if idx_counts.get(STONE_IDX, 0) < STONE_FACES_MIN:
        return fail(
            f"stone faces {idx_counts.get(STONE_IDX, 0)} < {STONE_FACES_MIN}",
            5,
        ), None, None, None, None, None
    if u0 < -UV_EPS or v0 < -UV_EPS or u1 > 1.0 + UV_EPS or v1 > 1.0 + UV_EPS:
        return fail(
            f"UVs outside 0..1: ({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f})",
            6,
        ), None, None, None, None, None
    if overlap > UV_OVERLAP_MAX:
        return fail(
            f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
            7,
        ), None, None, None, None, None
    if (
        abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
        or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
        or abs(size_z - OUTER_SIZE[2]) > BBOX_TOL
    ):
        return fail(
            f"bbox ({size_x:.4f},{size_y:.4f},{size_z:.4f}) "
            f"off outer {OUTER_SIZE}",
            8,
        ), None, None, None, None, None
    if not (LOD1_RATIO_MIN <= r1 <= LOD1_RATIO_MAX):
        return fail(
            f"LOD1 ratio {r1:.4f} not in [{LOD1_RATIO_MIN}, {LOD1_RATIO_MAX}] "
            "(--skip-decimate is the designed fail)",
            9,
        ), None, None, None, None, None
    if not (LOD2_RATIO_MIN <= r2 <= LOD2_RATIO_MAX):
        return fail(
            f"LOD2 ratio {r2:.4f} not in [{LOD2_RATIO_MIN}, {LOD2_RATIO_MAX}]",
            9,
        ), None, None, None, None, None
    if col_tris > COLLIDER_TRIS_MAX:
        return fail(
            f"collider tris {col_tris} > {COLLIDER_TRIS_MAX}",
            11,
        ), None, None, None, None, None
    if bake_result != {"FINISHED"} or not img.has_data:
        return fail(
            f"bake failed result={bake_result} has_data={img.has_data}",
            12,
        ), None, None, None, None, None
    if export_size <= 0:
        return fail("export file missing or empty", 13), None, None, None, None, None
    if (
        hyg["loose_v"] or hyg["loose_e"] or hyg["nonman"] or hyg["zero_area"]
        or hyg["doubles"] or hyg["ngons"] or zf
    ):
        return fail(
            f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
            f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}",
            15,
        ), None, None, None, None, None
    if bb[2] > ZMIN_EPS or sup["stones"] != BOTTOM_COUNT or sup["stone_z"] > STAVE_ZMIN_MAX:
        return fail(
            f"grounded zmin={bb[2]:.5f} stones={sup['stones']} "
            f"stone_z={sup['stone_z']:.5f}",
            16,
        ), None, None, None, None, None
    if kiss > KISS_MAX:
        return fail(f"teepee kiss {kiss:.5f} > {KISS_MAX}", 17), None, None, None, None, None
    if abs(cseat) > COURSE_SEAT_MAX:
        return fail(
            f"course seat {cseat:.5f} abs > {COURSE_SEAT_MAX}",
            18,
        ), None, None, None, None, None
    if abs(dia - RING_DIA) > BODY_TOL or abs(ht - RING_H) > BODY_TOL:
        return fail(
            f"ring {dia:.4f}x{ht:.4f} off {RING_DIA}x{RING_H}",
            19,
        ), None, None, None, None, None
    if vary < STONE_VARY_MIN:
        return fail(
            f"stone variation {vary:.5f} < {STONE_VARY_MIN}: the ring stones are "
            "identical (--uniform-stones is the designed fail)",
            20,
        ), None, None, None, None, None
    return 0, low, high, stone, tex, collider


def render_still(low, _stone, _tex, path, engine):
    scene = bpy.context.scene
    for ob in list(scene.objects):
        if ob.type == "MESH" and ob != low:
            ob.hide_render = True
            ob.hide_viewport = True

    low.rotation_euler.z = math.radians(-28.0)

    floor_me = bpy.data.meshes.new("Floor")
    bm = bmesh.new()
    try:
        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=14.0)
        bm.to_mesh(floor_me)
    finally:
        bm.free()
    fmat = bpy.data.materials.new("Floor")
    fmat.use_nodes = True
    fb = fmat.node_tree.nodes["Principled BSDF"]
    fb.inputs["Base Color"].default_value = (0.03, 0.032, 0.037, 1.0)
    fb.inputs["Roughness"].default_value = 0.7
    floor_me.materials.append(fmat)
    floor = bpy.data.objects.new("Floor", floor_me)
    scene.collection.objects.link(floor)
    wall = bpy.data.objects.new("Wall", floor_me.copy())
    wall.location = (0.0, 8.5, 0.0)
    wall.rotation_euler = (math.radians(90), 0.0, 0.0)
    scene.collection.objects.link(wall)

    world = bpy.data.worlds.new("World")
    world.use_nodes = True
    world.node_tree.nodes["Background"].inputs["Color"].default_value = (
        0.02, 0.021, 0.025, 1.0,
    )
    scene.world = world

    def light(name, loc, energy, size, col, rot):
        ld = bpy.data.lights.new(name, "AREA")
        ld.energy = energy
        ld.size = size
        ld.color = col
        ob = bpy.data.objects.new(name, ld)
        ob.location = loc
        ob.rotation_euler = tuple(math.radians(a) for a in rot)
        scene.collection.objects.link(ob)

    light("Key", (-3.6, -5.0, 5.8), 640.0, 4.0, (1.0, 0.94, 0.86), (50, 0, -36))
    light("Fill", (5.0, -3.6, 2.6), 40.0, 8.0, (0.72, 0.82, 1.0), (62, 0, 50))
    light("Wedge", (2.4, 4.2, 4.1), 640.0, 5.5, (1.0, 0.70, 0.40), (-70, 0, 198))
    # the fire itself: a warm, shadow-soft point in the ember bed that lights
    # the tripod's inner faces and the soot-dark inner ring (render only)
    fire = bpy.data.lights.new("FireGlow", "POINT")
    fire.energy = 260.0
    fire.color = (1.0, 0.42, 0.12)
    fire.shadow_soft_size = 0.08
    fob = bpy.data.objects.new("FireGlow", fire)
    fob.location = (0.0, 0.0, 0.07)
    scene.collection.objects.link(fob)

    bb = world_bbox(low)
    span = max(bb[3] - bb[0], bb[4] - bb[1], bb[5] - bb[2], 0.2)
    cam_data = bpy.data.cameras.new("Cam")
    cam_data.lens = 50.0
    cam = bpy.data.objects.new("Cam", cam_data)
    cam.location = (span * 1.24, -span * 1.80, span * 1.36)
    scene.collection.objects.link(cam)
    aim = bpy.data.objects.new("Aim", None)
    aim.location = (0.0, 0.0, 0.5 * (bb[2] + bb[5]) - 0.04 * span)
    scene.collection.objects.link(aim)
    con = cam.constraints.new("TRACK_TO")
    con.target = aim
    con.track_axis = "TRACK_NEGATIVE_Z"
    con.up_axis = "UP_Y"
    scene.camera = cam

    scene.render.engine = "CYCLES" if engine == "cycles" else eevee_engine_id()
    if engine == "cycles":
        scene.cycles.samples = 32
        scene.cycles.device = "CPU"
    else:
        try:
            scene.eevee.taa_render_samples = 64
        except AttributeError:
            pass
    scene.render.resolution_x = 1280
    scene.render.resolution_y = 720
    scene.render.image_settings.file_format = (
        "WEBP" if path.lower().endswith(".webp") else "PNG"
    )
    if path.lower().endswith(".webp"):
        scene.render.image_settings.quality = 90
    scene.render.filepath = path
    scene.view_settings.view_transform = "Standard"

    fcode = gallery_framing.check_framing(
        scene, cam, hero=[low], elements=[low], stage=[floor, wall],
    )
    if fcode:
        return fcode
    bpy.ops.render.render(write_still=True)
    if not (os.path.exists(path) and os.path.getsize(path) > 0):
        return fail("render produced no file", 14)
    return 0


def main():
    argv = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
    p = argparse.ArgumentParser()
    p.add_argument("--output", default=None)
    p.add_argument("--engine", default="eevee", choices=("eevee", "cycles"))
    p.add_argument("--skip-decimate", action="store_true")
    p.add_argument("--stray-vert", action="store_true")
    p.add_argument("--lift-z", action="store_true")
    p.add_argument("--short-stones", action="store_true")
    p.add_argument("--float-logs", action="store_true")
    p.add_argument("--gap-courses", action="store_true")
    p.add_argument("--uniform-stones", action="store_true")
    args = p.parse_args(argv)

    code, low, _high, stone, tex, _col = check(
        args.skip_decimate,
        lift_z=args.lift_z,
        stray_vert=args.stray_vert,
        short_stones=args.short_stones,
        float_logs=args.float_logs,
        gap_courses=args.gap_courses,
        uniform_stones=args.uniform_stones,
    )
    if code:
        return code
    if args.output:
        rcode = render_still(low, stone, tex, os.path.abspath(args.output), args.engine)
        if rcode:
            return rcode
        print(f"rendered still {args.output}")
    print("campfire OK")
    return 0


if __name__ == "__main__":
    try:
        sys.exit(main())
    except Exception as e:
        traceback.print_exc()
        print(f"FATAL: {e}", file=sys.stderr)
        sys.exit(1)