path: root/stage/blender/ship.py

"""HNX-01 crewed interstellar starship dataset for the artifact pipeline.

Concept A "Keel" — a crewed fusion-torch starship study built on the same
Blender contract as the YJ-01 probe dataset (stage/blender/probe.py):

    --step-id <id> --output <glb> --result-output <json> [--render-output <png>]

Design intent (visual research, NOT a closed engineering design):
    - Long axial keel so the crew habitat sits as far as practical from the
      reactor section (inverse-square separation for neutron/gamma dose).
    - Rotating habitat torus for continuous spin gravity; six spokes carry
      the pressurized transfer tunnels; the hub is the zero-g docking core.
    - Heavy water-shadow shield collar and a storm cellar between the
      habitat and the reactor.
    - Aft fusion core with a magnetic nozzle; six droop radiators reject the
      waste heat. These hardware positions are placeholders — the script
      does not claim thrust, burn time, shielding closure, or life-support
      closure.

Object ids: starship.<part>[.<index>], lowercase dotted, stable per step.
Cumulative object lists must stay in lockstep with Design.shipSteps in
src/SomhairlesDream.Modeling/Definitions.fs.
"""

import argparse
import json
import math
import os
import sys
from datetime import datetime, timezone

import bpy  # noqa: F401  (must be imported before mathutils: registers the bundled mathutils module)
from mathutils import Vector

STEP_OBJECTS = {
    "ship-01-keel": [
        "starship.keel.spine",
        "starship.nose.cone",
        "starship.dock.ring",
    ],
    "ship-02-hab": [
        "starship.keel.spine",
        "starship.nose.cone",
        "starship.dock.ring",
        "starship.hab.torus",
        "starship.hub.core",
        "starship.spoke.00",
        "starship.spoke.01",
        "starship.spoke.02",
        "starship.spoke.03",
        "starship.spoke.04",
        "starship.spoke.05",
    ],
    "ship-03-radiation": [
        "starship.keel.spine",
        "starship.nose.cone",
        "starship.dock.ring",
        "starship.hab.torus",
        "starship.hub.core",
        "starship.spoke.00",
        "starship.spoke.01",
        "starship.spoke.02",
        "starship.spoke.03",
        "starship.spoke.04",
        "starship.spoke.05",
        "starship.shadow.collar",
        "starship.storm.cellar",
    ],
    "ship-04-reactor": [
        "starship.keel.spine",
        "starship.nose.cone",
        "starship.dock.ring",
        "starship.hab.torus",
        "starship.hub.core",
        "starship.spoke.00",
        "starship.spoke.01",
        "starship.spoke.02",
        "starship.spoke.03",
        "starship.spoke.04",
        "starship.spoke.05",
        "starship.shadow.collar",
        "starship.storm.cellar",
        "starship.core.pressure",
        "starship.core.shield.plug",
        "starship.nozzle.magnetic",
        "starship.radiator.00",
        "starship.radiator.01",
        "starship.radiator.02",
        "starship.radiator.03",
        "starship.radiator.04",
        "starship.radiator.05",
    ],
    "ship-05-power": [
        "starship.keel.spine",
        "starship.nose.cone",
        "starship.dock.ring",
        "starship.hab.torus",
        "starship.hub.core",
        "starship.spoke.00",
        "starship.spoke.01",
        "starship.spoke.02",
        "starship.spoke.03",
        "starship.spoke.04",
        "starship.spoke.05",
        "starship.shadow.collar",
        "starship.storm.cellar",
        "starship.core.pressure",
        "starship.core.shield.plug",
        "starship.nozzle.magnetic",
        "starship.radiator.00",
        "starship.radiator.01",
        "starship.radiator.02",
        "starship.radiator.03",
        "starship.radiator.04",
        "starship.radiator.05",
        "starship.power.truss",
        "starship.capacitor.ring",
        "starship.comm.dish",
        "starship.comm.feed",
    ],
    "ship-06-cabin": [
        "starship.keel.spine",
        "starship.nose.cone",
        "starship.dock.ring",
        "starship.hab.torus",
        "starship.hub.core",
        "starship.spoke.00",
        "starship.spoke.01",
        "starship.spoke.02",
        "starship.spoke.03",
        "starship.spoke.04",
        "starship.spoke.05",
        "starship.shadow.collar",
        "starship.storm.cellar",
        "starship.core.pressure",
        "starship.core.shield.plug",
        "starship.nozzle.magnetic",
        "starship.radiator.00",
        "starship.radiator.01",
        "starship.radiator.02",
        "starship.radiator.03",
        "starship.radiator.04",
        "starship.radiator.05",
        "starship.power.truss",
        "starship.capacitor.ring",
        "starship.comm.dish",
        "starship.comm.feed",
        "starship.window.00",
        "starship.window.01",
        "starship.window.02",
        "starship.window.03",
        "starship.airlock.ring",
        "starship.airlock.tunnel",
        "starship.cargo.pod.00",
        "starship.cargo.pod.01",
    ],
    "ship-07-livery": [
        "starship.keel.spine",
        "starship.nose.cone",
        "starship.dock.ring",
        "starship.hab.torus",
        "starship.hub.core",
        "starship.spoke.00",
        "starship.spoke.01",
        "starship.spoke.02",
        "starship.spoke.03",
        "starship.spoke.04",
        "starship.spoke.05",
        "starship.shadow.collar",
        "starship.storm.cellar",
        "starship.core.pressure",
        "starship.core.shield.plug",
        "starship.nozzle.magnetic",
        "starship.radiator.00",
        "starship.radiator.01",
        "starship.radiator.02",
        "starship.radiator.03",
        "starship.radiator.04",
        "starship.radiator.05",
        "starship.power.truss",
        "starship.capacitor.ring",
        "starship.comm.dish",
        "starship.comm.feed",
        "starship.window.00",
        "starship.window.01",
        "starship.window.02",
        "starship.window.03",
        "starship.airlock.ring",
        "starship.airlock.tunnel",
        "starship.cargo.pod.00",
        "starship.cargo.pod.01",
    ],
}

LIVERY_STEPS = {"ship-07-livery"}


def utc_now():
    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")


def fail(message, code):
    print(message, file=sys.stderr)
    raise SystemExit(code)


def rgba(rgb, alpha=1.0):
    return (*rgb, alpha)


def make_material(bpy, name, color, *, metallic=0.0, roughness=0.45, emission=None, emission_strength=0.0):
    material = bpy.data.materials.get(name) or bpy.data.materials.new(name)
    material.use_nodes = True
    material.diffuse_color = rgba(color)
    shader = material.node_tree.nodes.get("Principled BSDF")
    shader.inputs["Base Color"].default_value = rgba(color)
    shader.inputs["Metallic"].default_value = metallic
    shader.inputs["Roughness"].default_value = roughness
    if emission is not None:
        emission_input = shader.inputs.get("Emission Color") or shader.inputs.get("Emission")
        if emission_input:
            emission_input.default_value = rgba(emission)
        strength_input = shader.inputs.get("Emission Strength")
        if strength_input:
            strength_input.default_value = emission_strength
    return material


def build_materials(bpy):
    return {
        "clay_body": make_material(bpy, "CLAY BODY", (0.38, 0.42, 0.46), metallic=0.20, roughness=0.38),
        "clay_structure": make_material(bpy, "CLAY STRUCTURE", (0.17, 0.21, 0.25), metallic=0.65, roughness=0.32),
        "clay_dark": make_material(bpy, "CLAY DARK", (0.045, 0.055, 0.065), metallic=0.45, roughness=0.28),
        "clay_white": make_material(bpy, "CLAY REFLECTOR", (0.62, 0.65, 0.67), metallic=0.18, roughness=0.34),
        "clay_glass": make_material(bpy, "CLAY GLASS", (0.035, 0.10, 0.13), metallic=0.12, roughness=0.14, emission=(0.01, 0.05, 0.07), emission_strength=0.15),
        "livery_hull": make_material(bpy, "LIVERY HULL BONE", (0.72, 0.70, 0.64), metallic=0.30, roughness=0.30),
        "livery_structure": make_material(bpy, "LIVERY STRUCTURE", (0.13, 0.18, 0.22), metallic=0.78, roughness=0.24),
        "livery_dark": make_material(bpy, "LIVERY GRAPHITE", (0.018, 0.025, 0.032), metallic=0.70, roughness=0.24),
        "livery_ceramic": make_material(bpy, "LIVERY SHADOW CERAMIC", (0.10, 0.115, 0.125), metallic=0.25, roughness=0.42),
        "livery_amber": make_material(bpy, "LIVERY AMBER STRIPE", (0.62, 0.34, 0.05), metallic=0.25, roughness=0.30),
        "livery_white": make_material(bpy, "LIVERY DISH WHITE", (0.78, 0.81, 0.79), metallic=0.15, roughness=0.28),
        "livery_glass": make_material(bpy, "LIVERY GLASS", (0.008, 0.055, 0.085), metallic=0.20, roughness=0.10, emission=(0.005, 0.045, 0.09), emission_strength=0.20),
        "livery_nozzle": make_material(bpy, "LIVERY NOZZLE COIL", (0.16, 0.17, 0.20), metallic=0.85, roughness=0.20),
    }


def clear_scene(bpy):
    bpy.ops.wm.read_factory_settings(use_empty=True)


def assign_variants(obj, clay_material, livery_material):
    obj["object_id"] = obj.name
    obj["clay_material"] = clay_material.name
    obj["livery_material"] = livery_material.name
    obj.data.materials.clear()
    obj.data.materials.append(clay_material)
    return obj


def apply_material_mode(bpy, materials, mode):
    if mode not in {"clay", "livery"}:
        raise ValueError(f"unknown material mode: {mode}")
    for obj in bpy.context.scene.objects:
        material_name = obj.get(f"{mode}_material")
        if not material_name or not obj.data or not hasattr(obj.data, "materials"):
            continue
        material = bpy.data.materials.get(material_name)
        if material is None:
            raise RuntimeError(f"missing material {material_name!r} for {obj.name}")
        obj.data.materials.clear()
        obj.data.materials.append(material)


def add_beveled_cube(bpy, name, location, dimensions, clay_material, livery_material, bevel=0.04, rotation=None):
    bpy.ops.mesh.primitive_cube_add(location=location, rotation=rotation or (0.0, 0.0, 0.0))
    obj = bpy.context.object
    obj.name = name
    obj.data.name = name + ".mesh"
    obj.dimensions = dimensions
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
    if bevel:
        modifier = obj.modifiers.new("Structural edge softening", "BEVEL")
        modifier.width = bevel
        modifier.segments = 3
    return assign_variants(obj, clay_material, livery_material)


def add_cylinder(bpy, name, location, radius, depth, clay_material, livery_material, *, rotation=(0.0, 0.0, 0.0), vertices=32):
    bpy.ops.mesh.primitive_cylinder_add(
        vertices=vertices,
        radius=radius,
        depth=depth,
        location=location,
        rotation=rotation,
    )
    obj = bpy.context.object
    obj.name = name
    obj.data.name = name + ".mesh"
    return assign_variants(obj, clay_material, livery_material)


def add_cone(bpy, name, location, radius1, radius2, depth, clay_material, livery_material, *, rotation=(0.0, 0.0, 0.0)):
    bpy.ops.mesh.primitive_cone_add(
        vertices=24,
        radius1=radius1,
        radius2=radius2,
        depth=depth,
        location=location,
        rotation=rotation,
    )
    obj = bpy.context.object
    obj.name = name
    obj.data.name = name + ".mesh"
    return assign_variants(obj, clay_material, livery_material)


def add_torus(bpy, name, location, major_radius, minor_radius, clay_material, livery_material, *, rotation=(0.0, 0.0, 0.0), minor_segments=12):
    bpy.ops.mesh.primitive_torus_add(
        major_radius=major_radius,
        minor_radius=minor_radius,
        major_segments=64,
        minor_segments=minor_segments,
        location=location,
        rotation=rotation,
    )
    obj = bpy.context.object
    obj.name = name
    obj.data.name = name + ".mesh"
    return assign_variants(obj, clay_material, livery_material)


def add_between(bpy, name, start, end, radius, clay_material, livery_material, vertices=20):
    start_vec = Vector(start)
    end_vec = Vector(end)
    delta = end_vec - start_vec
    obj = add_cylinder(
        bpy,
        name,
        (start_vec + end_vec) / 2.0,
        radius,
        delta.length,
        clay_material,
        livery_material,
        vertices=vertices,
    )
    obj.rotation_euler = delta.to_track_quat("Z", "Y").to_euler()
    return obj


def add_dish(bpy, name, base_x, center_y, center_z, radius, depth, clay_material, livery_material):
    """Create a shallow open paraboloid whose boresight points along +X."""
    segments = 64
    rings = 9
    vertices = [(base_x, center_y, center_z)]
    for ring in range(1, rings + 1):
        fraction = ring / rings
        ring_radius = radius * fraction
        ring_x = base_x + depth * fraction * fraction
        for segment in range(segments):
            angle = 2.0 * math.pi * segment / segments
            vertices.append(
                (
                    ring_x,
                    center_y + ring_radius * math.cos(angle),
                    center_z + ring_radius * math.sin(angle),
                )
            )
    faces = []
    for segment in range(segments):
        faces.append((0, 1 + segment, 1 + (segment + 1) % segments))
    for ring in range(1, rings):
        first = 1 + (ring - 1) * segments
        next_first = first + segments
        for segment in range(segments):
            current = first + segment
            following = first + (segment + 1) % segments
            next_current = next_first + segment
            next_following = next_first + (segment + 1) % segments
            faces.append((current, next_current, next_following, following))
    mesh = bpy.data.meshes.new(name + ".mesh")
    mesh.from_pydata(vertices, [], faces)
    mesh.update()
    obj = bpy.data.objects.new(name, mesh)
    bpy.context.collection.objects.link(obj)
    assign_variants(obj, clay_material, livery_material)
    solidify = obj.modifiers.new("Reflector thickness", "SOLIDIFY")
    solidify.thickness = 0.012
    return obj




def merge_details(bpy, master, extras):
    """Join detail meshes into the master object so the exported GLB keeps
    exactly the contract object names while carrying real secondary detail."""
    if not extras:
        return master
    for obj in bpy.context.selected_objects:
        obj.select_set(False)
    for extra in extras:
        extra.select_set(True)
    master.select_set(True)
    bpy.context.view_layer.objects.active = master
    bpy.ops.object.join()
    return master


def detail_torus(bpy, name, location, major_radius, minor_radius, rotation=(0.0, 0.0, 0.0), minor_segments=10):
    bpy.ops.mesh.primitive_torus_add(
        major_radius=major_radius,
        minor_radius=minor_radius,
        major_segments=48,
        minor_segments=minor_segments,
        location=location,
        rotation=rotation,
    )
    obj = bpy.context.object
    obj.name = name
    return obj


def detail_cube(bpy, name, location, dimensions, rotation=(0.0, 0.0, 0.0)):
    bpy.ops.mesh.primitive_cube_add(location=location, rotation=rotation)
    obj = bpy.context.object
    obj.name = name
    obj.dimensions = dimensions
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
    return obj


def detail_cylinder(bpy, name, location, radius, depth, rotation=(0.0, 0.0, 0.0), vertices=20):
    bpy.ops.mesh.primitive_cylinder_add(
        vertices=vertices,
        radius=radius,
        depth=depth,
        location=location,
        rotation=rotation,
    )
    obj = bpy.context.object
    obj.name = name
    return obj


def build_details(bpy, object_id, master, materials):
    """Secondary engineering detail per contract object (joined back into the
    master mesh before export). Names below never reach the GLB as objects."""
    clay = None
    details = []

    if object_id == "starship.keel.spine":
        # Reinforcement rings along the spine + twin conduit lines + equipment
        # blocks riding the top ridge.
        for index in range(14):
            x = -5.2 + index * 0.72
            details.append(detail_torus(
                bpy,
                f"{master.name}.detail.ring.{index:02d}",
                (x, 0.0, 0.0),
                0.40,
                0.028,
                rotation=(0.0, math.pi / 2.0, 0.0),
            ))
        details.append(detail_cylinder(bpy, master.name + ".detail.conduit.0", (-0.8, 0.30, 0.10), 0.035, 9.4, rotation=(0.0, math.pi / 2.0, 0.0)))
        details.append(detail_cylinder(bpy, master.name + ".detail.conduit.1", (-0.8, -0.30, 0.10), 0.035, 9.4, rotation=(0.0, math.pi / 2.0, 0.0)))
        for index, x in enumerate((-3.9, -1.9, 0.6, 2.9)):
            details.append(detail_cube(bpy, f"{master.name}.detail.box.{index:02d}", (x, 0.0, 0.30), (0.5, 0.30, 0.16)))
    elif object_id == "starship.hab.torus":
        # Outer panel ribs every 15 degrees, inner twin conduits, and two
        # comm masts riding the ring.
        for index in range(24):
            angle = 2.0 * math.pi * index / 24.0
            y = HAB_RADIUS * math.cos(angle)
            z = HAB_RADIUS * math.sin(angle)
            rotation = (angle, 0.0, 0.0)
            details.append(detail_cube(
                bpy,
                f"{master.name}.detail.rib.{index:02d}",
                (HAB_X + 0.06, y, z),
                (0.10, 0.08, 0.09),
                rotation=rotation,
            ))
        for offset in (-0.10, 0.10):
            details.append(detail_torus(
                bpy,
                f"{master.name}.detail.conduit.{offset:+.2f}",
                (HAB_X + offset, 0.0, 0.0),
                HAB_RADIUS - HAB_MINOR - 0.04,
                0.020,
                rotation=(0.0, math.pi / 2.0, 0.0),
                minor_segments=8,
            ))
        details.append(detail_cylinder(bpy, master.name + ".detail.mast.0", (HAB_X - 0.02, HAB_RADIUS + HAB_MINOR, 0.0), 0.02, 0.5, rotation=(0.0, math.pi / 2.0, 0.0)))
        details.append(detail_cylinder(bpy, master.name + ".detail.mast.1", (HAB_X + 0.02, 0.0, -(HAB_RADIUS + HAB_MINOR)), 0.02, 0.5))
    elif object_id == "starship.hub.core":
        for offset, radius in ((-0.74, 0.40), (0.74, 0.40)):
            details.append(detail_cylinder(bpy, f"{master.name}.detail.flange.{offset:+.2f}", (HAB_X + offset, 0.0, 0.0), radius, 0.06, rotation=(0.0, math.pi / 2.0, 0.0)))
        details.append(detail_torus(bpy, master.name + ".detail.bearing", (HAB_X, 0.0, 0.0), 0.34, 0.035, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=10))
    elif object_id == "starship.core.pressure":
        for index in range(4):
            x = -4.05 + index * 0.42
            details.append(detail_torus(bpy, f"{master.name}.detail.band.{index:02d}", (x, 0.0, 0.0), 0.58, 0.030, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=10))
        for offset in (-0.92, 0.92):
            details.append(detail_cylinder(bpy, f"{master.name}.detail.flange.{offset:+.2f}", (-3.4 + offset, 0.0, 0.0), 0.60, 0.07, rotation=(0.0, math.pi / 2.0, 0.0)))
    elif object_id == "starship.shadow.collar":
        for index in range(8):
            angle = 2.0 * math.pi * index / 8.0
            y = 0.86 * math.cos(angle)
            z = 0.86 * math.sin(angle)
            details.append(detail_cube(bpy, f"{master.name}.detail.rib.{index:02d}", (-1.35, y, z), (0.34, 0.10, 0.10), rotation=(angle, 0.0, 0.0)))
    elif object_id == "starship.storm.cellar":
        details.append(detail_cube(bpy, master.name + ".detail.doorframe", (-0.55, 0.0, 0.30), (0.66, 0.52, 0.05)))
        details.append(detail_cylinder(bpy, master.name + ".detail.hinge", (-0.55, -0.32, 0.0), 0.035, 0.5))
    elif object_id == "starship.nozzle.magnetic":
        # Coil grooves down the bell + coolant lines hugging the cone.
        for index in range(5):
            fraction = 0.25 + index * 0.14
            x = -6.35 + 2.2 * fraction
            radius = 1.15 - 0.55 * fraction
            details.append(detail_torus(bpy, f"{master.name}.detail.coil.{index:02d}", (x, 0.0, 0.0), radius, 0.034, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=10))
        for index in range(4):
            angle = 2.0 * math.pi * index / 4.0 + math.pi / 4.0
            y = 0.95 * math.cos(angle)
            z = 0.95 * math.sin(angle)
            details.append(detail_cylinder(bpy, f"{master.name}.detail.coolant.{index:02d}", (-5.35, y, z), 0.028, 2.5, rotation=(0.0, math.pi / 2.0, 0.0)))
    elif object_id == "starship.power.truss":
        for index in range(6):
            t = index / 5.0
            x = -1.2 + t * 5.1
            details.append(detail_cylinder(bpy, f"{master.name}.detail.diagonal.{index:02d}", (x, 0.0, 0.34), 0.022, 0.34, rotation=(0.0, math.pi / 2.0, 0.0), vertices=8))
        details.append(detail_torus(bpy, master.name + ".detail.hoop", (1.6, 0.0, 0.34), 0.40, 0.028, rotation=(math.pi / 2.0, 0.0, 0.0), minor_segments=10))
    elif object_id.startswith("starship.radiator."):
        index = int(object_id.rsplit(".", 1)[-1])
        angle = 2.0 * math.pi * index / 6.0 + math.pi / 6.0
        y = 0.95 * math.cos(angle)
        z = 0.95 * math.sin(angle)
        details.append(detail_cube(bpy, master.name + ".detail.backbone", (-3.6, y, z), (1.5, 0.05, 0.06)))
        for rib in (-0.45, 0.0, 0.45):
            details.append(detail_cube(bpy, f"{master.name}.detail.stiff.{rib:+.2f}", (-3.6 + rib, y, z), (0.05, 0.06, 0.40)))
    elif object_id.startswith("starship.cargo.pod."):
        index = int(object_id.rsplit(".", 1)[-1])
        y = (-0.62, 0.62)[index]
        for offset in (-0.5, 0.0, 0.5):
            details.append(detail_cube(bpy, f"{master.name}.detail.rib.{offset:+.2f}", (0.35 + offset, y, 0.0), (0.05, 0.26, 0.32)))
        details.append(detail_cylinder(bpy, master.name + ".detail.endcap", (0.97, y, 0.0), 0.10, 0.05, rotation=(0.0, math.pi / 2.0, 0.0)))
    elif object_id == "starship.nose.cone":
        details.append(detail_torus(bpy, master.name + ".detail.seam.0", (4.45, 0.0, 0.0), 0.26, 0.02, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=8))
        details.append(detail_torus(bpy, master.name + ".detail.seam.1", (4.75, 0.0, 0.0), 0.16, 0.018, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=8))
    elif object_id == "starship.comm.dish":
        # Mounting mast rising from the keel deck + gimbal block under the
        # dish base, so the dish reads as bolted hardware instead of floating.
        details.append(detail_cylinder(bpy, master.name + ".detail.post", (3.40, 0.0, 0.37), 0.045, 0.30, vertices=12))
        details.append(detail_cube(bpy, master.name + ".detail.gimbal", (3.40, 0.0, 0.46), (0.16, 0.16, 0.10)))
        details.append(detail_cube(bpy, master.name + ".detail.baseplate", (3.40, 0.0, 0.24), (0.26, 0.26, 0.05)))
    elif object_id.startswith("starship.spoke."):
        index = int(object_id.rsplit(".", 1)[-1])
        angle = 2.0 * math.pi * index / SPOKE_COUNT
        end_y = HAB_RADIUS * math.cos(angle)
        end_z = HAB_RADIUS * math.sin(angle)
        # Collar at the ring end and a hinge ring at the hub end.
        details.append(detail_torus(bpy, master.name + ".detail.cuff", (HAB_X, end_y * 0.92, end_z * 0.92), 0.16, 0.045, rotation=(angle, 0.0, 0.0), minor_segments=12))
        details.append(detail_torus(bpy, master.name + ".detail.root", (HAB_X + 0.06, 0.0, 0.0), 0.40, 0.045, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=12))
    else:
        return []

    _ = clay
    return details


# ---------------------------------------------------------------------------
# Starship layout (units are display metres, unscaled示意 dimensions).
#
#   nose +X  : forward docking / sensor section
#   -X       : reactor + nozzle (the ship accelerates toward -X)
#
#   habitat  : torus in the Y-Z plane at x=+1.2 (far from reactor at x<-3)
#   shadow   : water-shadow collar at x=-1.2, storm cellar hugs the keel
#   reactor  : fusion pressure vessel x in [-4.2, -2.6], nozzle to x=-5.6
# ---------------------------------------------------------------------------

HAB_X = 1.2
HAB_RADIUS = 1.7
HAB_MINOR = 0.30
SPOKE_COUNT = 6


def build_geometry(bpy, materials, step_id):
    """Build every object of the cumulative step, in STEP_OBJECTS order."""
    clay_body = materials["clay_body"]
    clay_structure = materials["clay_structure"]
    clay_dark = materials["clay_dark"]
    clay_white = materials["clay_white"]
    clay_glass = materials["clay_glass"]
    livery_hull = materials["livery_hull"]
    livery_structure = materials["livery_structure"]
    livery_dark = materials["livery_dark"]
    livery_ceramic = materials["livery_ceramic"]
    livery_amber = materials["livery_amber"]
    livery_white = materials["livery_white"]
    livery_glass = materials["livery_glass"]
    livery_nozzle = materials["livery_nozzle"]

    def spoke_end(index):
        angle = 2.0 * math.pi * index / SPOKE_COUNT
        return (HAB_X, HAB_RADIUS * math.cos(angle), HAB_RADIUS * math.sin(angle))

    objects = {}
    for object_id in STEP_OBJECTS[step_id]:
        if object_id == "starship.keel.spine":
            objects[object_id] = add_beveled_cube(bpy, object_id, (-0.8, 0.0, 0.0), (10.0, 0.46, 0.42), clay_structure, livery_structure, bevel=0.05)
        elif object_id == "starship.nose.cone":
            objects[object_id] = add_cone(bpy, object_id, (4.6, 0.0, 0.0), 0.42, 0.08, 1.0, clay_body, livery_hull, rotation=(0.0, -math.pi / 2.0, 0.0))
        elif object_id == "starship.dock.ring":
            objects[object_id] = add_torus(bpy, object_id, (4.1, 0.0, 0.0), 0.44, 0.06, clay_structure, livery_amber, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id == "starship.hab.torus":
            objects[object_id] = add_torus(bpy, object_id, (HAB_X, 0.0, 0.0), HAB_RADIUS, HAB_MINOR, clay_body, livery_hull, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=18)
        elif object_id == "starship.hub.core":
            objects[object_id] = add_cylinder(bpy, object_id, (HAB_X, 0.0, 0.0), 0.34, 1.4, clay_structure, livery_structure, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id.startswith("starship.spoke."):
            index = int(object_id.rsplit(".", 1)[-1])
            end = spoke_end(index)
            objects[object_id] = add_between(bpy, object_id, (HAB_X, 0.0, 0.0), end, 0.11, clay_structure, livery_structure, vertices=16)
        elif object_id == "starship.shadow.collar":
            objects[object_id] = add_torus(bpy, object_id, (-1.35, 0.0, 0.0), 0.78, 0.24, clay_dark, livery_ceramic, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=16)
        elif object_id == "starship.storm.cellar":
            objects[object_id] = add_beveled_cube(bpy, object_id, (-0.55, 0.0, 0.0), (1.1, 0.62, 0.58), clay_dark, livery_ceramic, bevel=0.06)
        elif object_id == "starship.core.pressure":
            objects[object_id] = add_cylinder(bpy, object_id, (-3.4, 0.0, 0.0), 0.56, 1.7, clay_structure, livery_nozzle, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id == "starship.core.shield.plug":
            objects[object_id] = add_cylinder(bpy, object_id, (-2.45, 0.0, 0.0), 0.60, 0.5, clay_dark, livery_ceramic, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id == "starship.nozzle.magnetic":
            objects[object_id] = add_cone(bpy, object_id, (-5.35, 0.0, 0.0), 1.15, 0.60, 2.4, clay_structure, livery_nozzle, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id.startswith("starship.radiator."):
            index = int(object_id.rsplit(".", 1)[-1])
            angle = 2.0 * math.pi * index / 6.0 + math.pi / 6.0
            y = 0.95 * math.cos(angle)
            z = 0.95 * math.sin(angle)
            objects[object_id] = add_beveled_cube(bpy, object_id, (-3.6, y, z), (1.5, 0.04, 0.42), clay_white, livery_white, bevel=0.02, rotation=(angle, 0.0, 0.0))
        elif object_id == "starship.power.truss":
            objects[object_id] = add_between(bpy, object_id, (-1.2, 0.0, 0.34), (3.9, 0.0, 0.34), 0.09, clay_structure, livery_structure, vertices=14)
        elif object_id == "starship.capacitor.ring":
            objects[object_id] = add_torus(bpy, object_id, (2.6, 0.0, 0.34), 0.42, 0.08, clay_structure, livery_amber, rotation=(math.pi / 2.0, 0.0, 0.0))
        elif object_id == "starship.comm.dish":
            objects[object_id] = add_dish(bpy, object_id, 3.4, 0.0, 0.50, 0.55, 0.10, clay_white, livery_white)
        elif object_id == "starship.comm.feed":
            objects[object_id] = add_cylinder(bpy, object_id, (3.72, 0.0, 0.50), 0.05, 0.09, clay_glass, livery_glass, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id.startswith("starship.window."):
            index = int(object_id.rsplit(".", 1)[-1])
            angle = 2.0 * math.pi * index / SPOKE_COUNT + math.pi / 6.0
            y = (HAB_RADIUS + HAB_MINOR * 0.55) * math.cos(angle)
            z = (HAB_RADIUS + HAB_MINOR * 0.55) * math.sin(angle)
            objects[object_id] = add_cylinder(bpy, object_id, (HAB_X + 0.16, y, z), 0.14, 0.10, clay_glass, livery_glass, rotation=(angle, 0.0, 0.0), vertices=18)
        elif object_id == "starship.airlock.ring":
            objects[object_id] = add_torus(bpy, object_id, (4.1, 0.0, 0.0), 0.30, 0.05, clay_structure, livery_amber, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id == "starship.airlock.tunnel":
            objects[object_id] = add_cylinder(bpy, object_id, (4.55, 0.0, 0.0), 0.26, 0.9, clay_body, livery_hull, rotation=(0.0, math.pi / 2.0, 0.0))
        elif object_id.startswith("starship.cargo.pod."):
            index = int(object_id.rsplit(".", 1)[-1])
            y = (-0.62, 0.62)[index]
            objects[object_id] = add_beveled_cube(bpy, object_id, (0.35, y, 0.0), (1.2, 0.24, 0.30), clay_body, livery_hull, bevel=0.03)
        else:
            fail("unknown object id: " + object_id, 4)

    # Secondary engineering detail is generated per contract object and
    # merged into the master mesh, keeping the GLB object contract intact.
    for object_id in list(STEP_OBJECTS[step_id]):
        master = objects[object_id]
        merge_details(bpy, master, build_details(bpy, object_id, master, materials))

    ordered = [objects[object_id] for object_id in STEP_OBJECTS[step_id]]
    for obj, object_id in zip(ordered, STEP_OBJECTS[step_id]):
        if obj.get("object_id") != object_id:
            fail("source object custom property verification failed", 4)
    return ordered


def add_render_setup(bpy):
    from mathutils import Vector

    scene = bpy.context.scene
    scene.render.resolution_x = 512
    scene.render.resolution_y = 512
    scene.render.resolution_percentage = 100
    scene.render.image_settings.file_format = "PNG"
    if scene.world is None:
        scene.world = bpy.data.worlds.new("ship.world")
    scene.world.color = (0.025, 0.035, 0.045)

    camera_data = bpy.data.cameras.new("ship.camera")
    camera_data.type = "ORTHO"
    camera_data.ortho_scale = 13.5
    camera = bpy.data.objects.new("ship.camera", camera_data)
    bpy.context.collection.objects.link(camera)
    camera.location = (7.0, -13.5, 7.5)
    camera.rotation_euler = (Vector((-0.5, 0.0, 0.0)) - camera.location).to_track_quat("-Z", "Y").to_euler()
    scene.camera = camera

    def add_light(name, location, energy, size, color=(1.0, 1.0, 1.0)):
        light_data = bpy.data.lights.new(name, type="AREA")
        light_data.energy = energy
        light_data.shape = "DISK"
        light_data.size = size
        light_data.color = color
        light = bpy.data.objects.new(name, light_data)
        bpy.context.collection.objects.link(light)
        light.location = location
        light.rotation_euler = (Vector((-0.5, 0.0, 0.0)) - Vector(location)).to_track_quat("-Z", "Y").to_euler()
        return light

    add_light("ship.key", (5.0, -6.0, 9.0), 1400, 6.0, (1.0, 0.98, 0.94))
    add_light("ship.fill", (-4.0, -9.0, 2.0), 420, 8.0, (0.72, 0.82, 1.0))
    add_light("ship.rim", (-7.5, 5.0, -3.0), 900, 3.0, (1.0, 0.86, 0.62))


def export_glb(bpy, objects, output):
    for obj in bpy.context.selected_objects:
        obj.select_set(False)
    for obj in objects:
        obj.select_set(True)
    bpy.context.view_layer.objects.active = objects[-1]
    result = bpy.ops.export_scene.gltf(filepath=output, export_format="GLB", use_selection=True, export_apply=True)
    if "FINISHED" not in result or not os.path.isfile(output) or os.path.getsize(output) <= 0:
        fail("GLB export failed", 4)


def write_result(path, response):
    path = os.path.abspath(path)
    os.makedirs(os.path.dirname(path), exist_ok=True)
    temporary_path = path + ".tmp"
    with open(temporary_path, "w", encoding="utf-8") as stream:
        json.dump(response, stream, separators=(",", ":"))
        stream.flush()
        os.fsync(stream.fileno())
    os.replace(temporary_path, path)


def verify_reimport(bpy, output, expected):
    clear_scene(bpy)
    result = bpy.ops.import_scene.gltf(filepath=output)
    if "FINISHED" not in result:
        fail("GLB reimport failed", 4)

    names = [obj.name for obj in bpy.context.scene.objects if obj.type == "MESH"]
    if len(names) != len(expected) or set(names) != set(expected):
        fail("GLB reimport object IDs did not match", 4)

    return [object_id for object_id in expected if object_id in names]


def main():
    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("--step-id", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--render-output")
    parser.add_argument("--result-output", required=True)
    args = parser.parse_args()

    if args.step_id not in STEP_OBJECTS:
        fail("unknown step id", 2)
    if bool(args.render_output) and os.path.abspath(args.render_output) == os.path.abspath(args.output):
        fail("render output must differ from GLB output", 2)

    try:
        import bpy
    except Exception as exc:
        fail("bpy is unavailable: " + str(exc), 3)

    if tuple(bpy.app.version) < (3, 0, 0):
        fail("bpy version is unsupported", 3)

    output = os.path.abspath(args.output)
    result_output = os.path.abspath(args.result_output)
    os.makedirs(os.path.dirname(output), exist_ok=True)

    try:
        clear_scene(bpy)
        materials = build_materials(bpy)
        objects = build_geometry(bpy, materials, args.step_id)
        apply_material_mode(bpy, materials, "livery" if args.step_id in LIVERY_STEPS else "clay")
        export_glb(bpy, objects, output)
        exported_at = utc_now()
        glb_bytes = os.path.getsize(output)

        rendered_at = None
        if args.render_output:
            render_output = os.path.abspath(args.render_output)
            os.makedirs(os.path.dirname(render_output), exist_ok=True)
            add_render_setup(bpy)
            bpy.context.scene.render.filepath = render_output
            result = bpy.ops.render.render(write_still=True)
            if "FINISHED" not in result or not os.path.isfile(render_output) or os.path.getsize(render_output) <= 0:
                fail("PNG render failed", 4)
            rendered_at = utc_now()

        verified = verify_reimport(bpy, output, STEP_OBJECTS[args.step_id])
        response = {
            "ok": True,
            "blenderVersion": ".".join(str(part) for part in bpy.app.version),
            "exportedAt": exported_at,
            "objectIds": STEP_OBJECTS[args.step_id],
            "verifiedObjectIds": verified,
            "glbBytes": glb_bytes,
        }
        if args.render_output:
            response["renderPath"] = os.path.abspath(args.render_output)
            response["renderedAt"] = rendered_at
        write_result(result_output, response)
        print("starship result written: " + result_output)
    except SystemExit:
        raise
    except Exception as exc:
        fail("starship failed: " + str(exc), 4)


if __name__ == "__main__":
    main()