From 42227f343581e6d77cff5b98c336973eb2803bf4 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 12 Oct 2026 03:45:12 +0200 Subject: [PATCH] Blender add-on weapon mounts: Add Weapon, Add Muzzle, Mirror Mount, Remove Mount; Package derives mounted Position and yaw hull_grid gains mounted_position, facing_yaw, mirror_rotation and mirror_footprint. The mount helpers edit the layout buffer and create a tagged weapon-mount object with its row as a pair; Package derives each mounted row's Position from its object and each mount's yaw from its row's Rotation, then saves the buffer through _save_layout. The panel gets a Mounts box and greys a mounted row's x and y. smoke_mounts.py pins the gunboat flank, derive and remove paths. All commits build. Co-Authored-By: Claude Opus 5.5 --- tools/blender/aetheria_ships/__init__.py | 254 +++++++++++++++++- tools/blender/aetheria_ships/hull_grid.py | 36 +++ tools/blender/tests/smoke_mounts.py | 305 ++++++++++++++++++++++ tools/blender/tests/test_hull_grid.py | 24 ++ 4 files changed, 617 insertions(+), 2 deletions(-) create mode 100644 tools/blender/tests/smoke_mounts.py diff --git a/tools/blender/aetheria_ships/__init__.py b/tools/blender/aetheria_ships/__init__.py index 6d633d427..154912ec6 100644 --- a/tools/blender/aetheria_ships/__init__.py +++ b/tools/blender/aetheria_ships/__init__.py @@ -180,7 +180,7 @@ class AETHERIA_OT_add_hardpoint(bpy.types.Operator): bl_options = {"REGISTER", "UNDO"} def execute(self, context): - context.scene.aetheria_layout.hardpoints.add() + _add_row(context.scene.aetheria_layout) return {"FINISHED"} @@ -197,6 +197,239 @@ class AETHERIA_OT_remove_hardpoint(bpy.types.Operator): return {"FINISHED"} + +MOUNT_ROLE = "weapon-mount" +MUZZLE_ROLE = "weapon-muzzle" +MUZZLE_OFFSET = (0.0, -0.5, 0.0) # in the mount's frame: half a metre along its facing +WEAPON_TYPES = tuple(item for item in HARDPOINT_TYPES if item[1] in ("Energy", "Ballistic", "Launcher")) +CENTRELINE = hull_grid.CELL_SIZE / 2 # a mount closer than this to Ship Root's X = 0 has no mirror image + + +def _add_row(state, **fields): + """The one row creation: a new layout row, with HardpointData's defaults for anything not named.""" + hp = state.hardpoints.add() + for name, value in fields.items(): + setattr(hp, name, value) + return hp + + +def _mount_objects(collection): + """The weapon-mount objects by their aetheria.id.""" + return {obj["aetheria.id"]: obj for obj in collection.all_objects + if obj.get("aetheria.role") == MOUNT_ROLE and isinstance(obj.get("aetheria.id"), str)} + + +def _muzzles(mount): + return sorted((child for child in mount.children if child.get("aetheria.role") == MUZZLE_ROLE), + key=lambda child: (int(child.get("aetheria.order", 0)), child.name)) + + +def _mount_frame(context): + """(collection, layout buffer, Ship Root, grid_origin) for a mount helper: the buffer must be this ship's and the grid + must match it.""" + collection, path = _layout_path(context) + state = context.scene.aetheria_layout + if state.ship_id != collection["aetheria.id"] or state.ship_cc != path: + raise ValueError("Load this collection's layout first") + root = _ship_root(collection) + origin = collection.get("aetheria.grid_origin") + if root is None or origin is None: + raise ValueError("Rasterise first: a mount needs the ship's Ship Root and grid") + if not _grid_current(collection, state): + raise ValueError("Rasterise again: the grid no longer matches the layout") + return collection, state, root, (float(origin[0]), float(origin[1])) + + +def _root_local(root, obj): + """obj's origin in Ship Root's frame.""" + return root.matrix_world.inverted() @ obj.matrix_world.translation + + +def _derived_position(state, origin, local, footprint): + """The one derivation of a mounted row's Position: the cell at the object's origin (Ship Root frame), offset by the + footprint's centre. Refuses a Position outside the grid.""" + width, height = _parse_footprint(footprint)[0][:2] + position = hull_grid.mounted_position(hull_grid.cell_at(origin, (local[0], local[1])), width, height) + if not (0 <= position[0] < state.width and 0 <= position[1] < state.height): + raise ValueError("The mount lies outside the grid") + return position + + +def _selected_mount(context, collection): + obj = context.active_object + if obj is None or obj.get("aetheria.role") != MOUNT_ROLE or obj.name not in collection.all_objects: + raise ValueError("Select a weapon mount") + return obj + + +def _mount_row(state, mount_id): + row = next((hp for hp in state.hardpoints if hp.mount_id == mount_id), None) + if row is None: + raise ValueError("The weapon mount has no layout row") + return row + + +def _new_mount_id(collection, state): + taken = {hp.mount_id for hp in state.hardpoints} | set(_mount_objects(collection)) + n = 1 + while f"weapon.{n}" in taken: + n += 1 + return f"weapon.{n}" + + +def _make_empty(collection, anchor_id, role, parent, local, yaw=0.0, order=None): + empty = bpy.data.objects.new(anchor_id, None) + empty["aetheria.role"] = role + empty["aetheria.id"] = anchor_id + if order is not None: + empty["aetheria.order"] = order + collection.objects.link(empty) + _attach_to_root(empty, parent) + empty.location = tuple(local) + empty.rotation_euler = (0.0, 0.0, yaw) + return empty + + +def _make_muzzle(collection, mount, k, local, order): + return _make_empty(collection, f"{mount['aetheria.id']}.muzzle.{k}", MUZZLE_ROLE, mount, local, order=order) + + +def _add_mount(collection, state, root, origin, kind, rotation, local, footprint="#"): + """A weapon-mount object under Ship Root and its row, as a matching pair; returns the mount.""" + position = _derived_position(state, origin, local, footprint) + mount_id = _new_mount_id(collection, state) + mount = _make_empty(collection, mount_id, MOUNT_ROLE, root, local, hull_grid.facing_yaw(rotation)) + _add_row(state, kind=kind, mount_id=mount_id, rotation=str(rotation), footprint=footprint, + x=position[0], y=position[1]) + return mount + + +class AETHERIA_OT_add_weapon(bpy.types.Operator): + bl_idname = "aetheria.add_ship_weapon" + bl_label = "Add Weapon" + bl_description = "Add a weapon mount and its first muzzle at the 3D cursor, with a layout row" + bl_options = {"REGISTER", "UNDO"} + kind: bpy.props.EnumProperty(name="Type", items=WEAPON_TYPES) + rotation: bpy.props.EnumProperty(name="Rotation", items=ROTATIONS) + + def execute(self, context): + try: + collection, state, root, origin = _mount_frame(context) + local = root.matrix_world.inverted() @ context.scene.cursor.location + mount = _add_mount(collection, state, root, origin, self.kind, int(self.rotation), local) + _make_muzzle(collection, mount, 1, MUZZLE_OFFSET, 1) + except _EXPECTED as exc: + return _refuse(self, exc) + return {"FINISHED"} + + +class AETHERIA_OT_add_muzzle(bpy.types.Operator): + bl_idname = "aetheria.add_ship_muzzle" + bl_label = "Add Muzzle" + bl_description = "Add a muzzle under the selected weapon mount" + bl_options = {"REGISTER", "UNDO"} + + def execute(self, context): + try: + collection, _, _, _ = _mount_frame(context) + mount = _selected_mount(context, collection) + existing = _muzzles(mount) + names = {child.name for child in existing} + k = len(existing) + 1 + while f"{mount['aetheria.id']}.muzzle.{k}" in names: + k += 1 + order = max((int(child.get("aetheria.order", 0)) for child in existing), default=0) + 1 + _make_muzzle(collection, mount, k, MUZZLE_OFFSET, order) + except _EXPECTED as exc: + return _refuse(self, exc) + return {"FINISHED"} + + +class AETHERIA_OT_mirror_mount(bpy.types.Operator): + bl_idname = "aetheria.mirror_ship_mount" + bl_label = "Mirror Mount" + bl_description = "Duplicate the selected weapon mount and its muzzles across the centreline, as a new row" + bl_options = {"REGISTER", "UNDO"} + + def execute(self, context): + try: + collection, state, root, origin = _mount_frame(context) + mount = _selected_mount(context, collection) + row = _mount_row(state, mount["aetheria.id"]) + local = _root_local(root, mount) + if abs(local.x) < CENTRELINE: + raise ValueError("The weapon mount is on the centreline; it has no mirror image") + mirrored = _add_mount(collection, state, root, origin, row.kind, + hull_grid.mirror_rotation(int(row.rotation)), (-local.x, local.y, local.z), + hull_grid.mirror_footprint(row.footprint)) + new_row = _mount_row(state, mirrored["aetheria.id"]) + for name in ("armor", "firing_arc"): # the author's own numbers, copied; the helper invents none + setattr(new_row, name, getattr(row, name)) + for k, muzzle in enumerate(_muzzles(mount), start=1): + _make_muzzle(collection, mirrored, k, (-muzzle.location.x, muzzle.location.y, muzzle.location.z), + int(muzzle.get("aetheria.order", 0))) + except _EXPECTED as exc: + return _refuse(self, exc) + return {"FINISHED"} + + +class AETHERIA_OT_remove_mount(bpy.types.Operator): + bl_idname = "aetheria.remove_ship_mount" + bl_label = "Remove Mount" + bl_description = "Delete the selected weapon mount, its muzzles and its layout row" + bl_options = {"REGISTER", "UNDO"} + + def execute(self, context): + try: + collection, state, _, _ = _mount_frame(context) + mount = _selected_mount(context, collection) + mount_id = mount["aetheria.id"] + for index in reversed(range(len(state.hardpoints))): + if state.hardpoints[index].mount_id == mount_id: + state.hardpoints.remove(index) + for muzzle in _muzzles(mount): + _discard_object(muzzle) + _discard_object(mount) + except _EXPECTED as exc: + return _refuse(self, exc) + return {"FINISHED"} + + +def _plan_mounts(collection, state, root, path): + """(row, weapon-mount object, Position, yaw) for every buffer row whose Transform names a weapon-mount object: the + Position from the object's placement, the yaw from the row's Rotation. Refuses before anything changes.""" + mounts = _mount_objects(collection) + if not mounts: + return [] + if state.ship_id != collection["aetheria.id"] or state.ship_cc != path: + raise ValueError("Load Layout first: the weapon mounts need this ship's layout") + paired = [(hp, mounts[hp.mount_id]) for hp in state.hardpoints if hp.mount_id in mounts] + if not paired: + return [] + origin = collection.get("aetheria.grid_origin") + if root is None or origin is None: + raise ValueError("Rasterise first: a mount needs the ship's Ship Root and grid") + plan = [] + for hp, obj in paired: + if obj.parent != root: + raise ValueError("A weapon mount must be parented to Ship Root") + position = _derived_position(state, (float(origin[0]), float(origin[1])), _root_local(root, obj), hp.footprint) + plan.append((hp, obj, position, hull_grid.facing_yaw(int(hp.rotation)))) + return plan + + +def _apply_mounts(context, collection, state, plan): + """Writes the planned Positions into the buffer and yaws into the objects, then saves the buffer through + _save_layout, so the buffer and the .cc agree.""" + if not plan: + return + for hp, obj, position, yaw in plan: + hp.x, hp.y = position + obj.rotation_mode = "XYZ" + obj.rotation_euler = (0.0, 0.0, yaw) + _save_layout(context, collection, state) + + def _encode_buffer(state): """The layout buffer as ship_cc stores it: (shape, hardpoint rows).""" shape = [state.width, state.height, [cell.occupied for cell in state.cells]] @@ -911,8 +1144,10 @@ class AETHERIA_OT_package_ship(bpy.types.Operator): if read(path, cultlib).ship.body[0] != ship_id: raise ValueError("The bound collection ID does not match its .cc ship ID") root = _ship_root(collection) + mounts = _plan_mounts(collection, state, root, path) if root is not None: _frame_ship(context, collection, root, path, saved_shape) + _apply_mounts(context, collection, state, mounts) anchors = _anchors(collection) _export_glb(context, collection, str(Path(path).with_name(MODEL_ASSET))) replace_visual(path, cultlib, ship_id, MODEL_ASSET, anchors) @@ -993,20 +1228,34 @@ class AETHERIA_PT_ship(bpy.types.Panel): for x in range(state.width): row.prop(state.cells[x * state.height + y], "occupied", text="") layout.label(text="Hardpoints") + try: + mounts = _mount_objects(_ship_collection(context)) + except ValueError: + mounts = {} for index, hp in enumerate(state.hardpoints): box = layout.box() header = box.row(align=True) header.prop(hp, "mount_id") - header.operator("aetheria.remove_ship_hardpoint", text="", icon="X").index = index + if hp.mount_id not in mounts: # a mounted row goes with its object: Remove Mount + header.operator("aetheria.remove_ship_hardpoint", text="", icon="X").index = index box.prop(hp, "kind") position = box.row(align=True) + position.enabled = hp.mount_id not in mounts position.prop(hp, "x") position.prop(hp, "y") + if hp.mount_id in mounts: + box.label(text="Mount object: Position follows it", icon="EMPTY_ARROWS") box.prop(hp, "footprint") box.prop(hp, "rotation") box.prop(hp, "armor") box.prop(hp, "firing_arc") layout.operator("aetheria.add_ship_hardpoint", icon="ADD") + mount_box = layout.box() + mount_box.label(text="Mounts") + mount_box.operator("aetheria.add_ship_weapon", icon="ADD") + mount_box.operator("aetheria.add_ship_muzzle", icon="ADD") + mount_box.operator("aetheria.mirror_ship_mount", icon="MOD_MIRROR") + mount_box.operator("aetheria.remove_ship_mount", icon="X") layout.operator("aetheria.save_ship_layout", icon="FILE_TICK") self._draw_package(context, layout) @@ -1033,6 +1282,7 @@ class AETHERIA_PT_ship(bpy.types.Panel): classes = (AETHERIA_PG_cell, AETHERIA_PG_hardpoint, AETHERIA_PG_layout, AETHERIA_OT_load_layout, AETHERIA_OT_resize_layout, AETHERIA_OT_add_hardpoint, AETHERIA_OT_remove_hardpoint, + AETHERIA_OT_add_weapon, AETHERIA_OT_add_muzzle, AETHERIA_OT_mirror_mount, AETHERIA_OT_remove_mount, AETHERIA_OT_save_layout, AETHERIA_OT_bind_ship_collection, AETHERIA_OT_capture_ship_lines, AETHERIA_OT_new_ship, AETHERIA_OT_flip_nose, AETHERIA_OT_rasterise_hull, AETHERIA_OT_package_ship, AETHERIA_AP_preferences, AETHERIA_PT_ship) diff --git a/tools/blender/aetheria_ships/hull_grid.py b/tools/blender/aetheria_ships/hull_grid.py index fce193892..d6e4a1ae2 100644 --- a/tools/blender/aetheria_ships/hull_grid.py +++ b/tools/blender/aetheria_ships/hull_grid.py @@ -103,3 +103,39 @@ def convex_outline(points_xy): if len(outline) < 3: raise ValueError("The points have no outline: they are fewer than three or collinear") return outline + + +# ItemRotation values, in ship_cc.ROTATION_NAMES order. +ROTATION_NONE, ROTATION_COUNTER_CLOCKWISE, ROTATION_REVERSED, ROTATION_CLOCKWISE = 0, 1, 2, 3 +_FACING_YAW = { + ROTATION_NONE: 0.0, + ROTATION_COUNTER_CLOCKWISE: math.pi / 2, + ROTATION_REVERSED: math.pi, + ROTATION_CLOCKWISE: -math.pi / 2, +} + + +def mounted_position(cell, footprint_w, footprint_h): + """The hardpoint Position (its footprint's origin cell) whose w x h footprint is centred on cell: ShipAuthoringStore + places footprint cell (cx, cy) at Position + (cx, cy), and the footprint's centre is ((w - 1) // 2, (h - 1) // 2).""" + return (cell[0] - (footprint_w - 1) // 2, cell[1] - (footprint_h - 1) // 2) + + +def facing_yaw(rotation): + """Radians about Z that turn a mount empty so its local -Y points along the hardpoint Rotation's facing: None the + nose (-Y), CounterClockwise port (+X), Reversed aft (+Y), Clockwise starboard (-X).""" + return _FACING_YAW[rotation] + + +def mirror_rotation(rotation): + """The Rotation of a hardpoint mirrored across the centreline: Clockwise and CounterClockwise swap.""" + if rotation == ROTATION_CLOCKWISE: + return ROTATION_COUNTER_CLOCKWISE + if rotation == ROTATION_COUNTER_CLOCKWISE: + return ROTATION_CLOCKWISE + return rotation + + +def mirror_footprint(footprint): + """A footprint text ('#' and '.' rows separated by '/') mirrored across the centreline: each row reversed.""" + return "/".join(row[::-1] for row in footprint.split("/")) diff --git a/tools/blender/tests/smoke_mounts.py b/tools/blender/tests/smoke_mounts.py new file mode 100644 index 000000000..afc31012d --- /dev/null +++ b/tools/blender/tests/smoke_mounts.py @@ -0,0 +1,305 @@ +"""Headless Blender smoke for the add-on's weapon mounts, the gunboat path: Add Weapon, Add Muzzle, Mirror Mount, Remove +Mount, and what Package derives from them. + + blender --background --factory-startup --python-use-system-env --python tools/blender/tests/smoke_mounts.py + +Environment as smoke_package.py's header says: CULTLIB_PACKAGES and SMOKE_GAME_FOLDER (the published AetherDb under its +ModTools, no dotnet), and msgpack importable. The ship is created under /GameData/Mods/smoke.mounts, which +this smoke removes when it ends. + +The ship is smoke_frame's sphere, centred on the origin, through New Ship (6 x 10 cells, cell x = 0 at +X). Pass 1 adds a +Ballistic gun on the starboard flank as Clockwise: its row's Rotation is 3, its Position is the cell under the mount, and +its muzzle sits 0.5 m toward -X of it. Mirror Mount makes a CounterClockwise row at the mirrored cell with its muzzle +toward +X, and refuses a mount on the centreline. Pass 2 packages: the Clockwise muzzle node in the GLB turns glTF +Z to +glTF -X, and the mirrored one to +X. Pass 3 moves a weapon two cells by script and sets another's Rotation to Reversed in +the panel state: Package moves the first row's Position by two cells, leaves the internal Reactor row alone, yaws the +second mount to 180 degrees and the first back to its Rotation's yaw, and the validator accepts the ship. Pass 4 removes a +mount with two muzzles: its row, the mount and both muzzles go, and the other rows stay. +""" + +import json +import math +import os +import shutil +import struct +import sys +import traceback +from pathlib import Path + +import addon_utils +import bmesh +import bpy + +REPO = Path(__file__).resolve().parents[3] +PACKAGES = os.environ.get("CULTLIB_PACKAGES") or sys.exit("Set CULTLIB_PACKAGES to CultLib's packages directory") +SHIP_ID = "smoke.mounts" +GAME = Path(os.environ.get("SMOKE_GAME_FOLDER") or sys.exit("Set SMOKE_GAME_FOLDER to a folder holding GameData/Aetheria.cc and ModTools/AetherDb")) +MODS = GAME / "GameData" / "Mods" +COLLECTION = "Smoke Mounts" +NAMES_NOT_ECHOED = (SHIP_ID, COLLECTION, "weapon.", str(GAME), GAME.name) +CLOCKWISE, COUNTER_CLOCKWISE, REVERSED = 3, 1, 2 +BALLISTIC = "10" + + +def new_object(collection, name, mesh, location=(0, 0, 0), parent=None): + obj = bpy.data.objects.new(name, mesh) + obj.location = location + obj.parent = parent + collection.objects.link(obj) + return obj + + +def tag(obj, role, anchor_id): + obj["aetheria.role"] = role + obj["aetheria.id"] = anchor_id + return obj + + +def quad(name, size): + mesh = bpy.data.meshes.new(name) + half = size / 2 + mesh.from_pydata([(-half, -half, 0), (half, -half, 0), (half, half, 0), (-half, half, 0)], [], [(0, 1, 2, 3)]) + return mesh + + +def tetrahedron(name): + mesh = bpy.data.meshes.new(name) + mesh.from_pydata([(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1)], [], [(0, 2, 1), (0, 1, 3), (0, 3, 2), (1, 2, 3)]) + return mesh + + +def run(operator): + try: + return operator(), "" + except RuntimeError as exc: + print(f"OPERATOR error: {exc}") + return {"CANCELLED"}, str(exc) + + +def require(condition, message): + if not condition: + raise SystemExit(message) + + +def refused(operator, expected, what): + result, message = run(operator) + require(result == {"CANCELLED"}, f"{what} was not refused") + require(expected in message, f"{what}: the report is not the fixed text ({message!r})") + for name in NAMES_NOT_ECHOED: + require(name not in message, f"{what}: the report echoes an input ({name})") + + +def select(obj): + bpy.context.view_layer.objects.active = obj + obj.select_set(True) + + +def approx(a, b, tolerance=1e-3): + return all(abs(x - y) <= tolerance for x, y in zip(a, b)) + + +def rows(scene): + return [(hp.mount_id, int(hp.kind), (hp.x, hp.y), int(hp.rotation), hp.footprint, hp.armor, hp.firing_arc) + for hp in scene.aetheria_layout.hardpoints] + + +def row(scene, mount_id): + found = [r for r in rows(scene) if r[0] == mount_id] + require(len(found) == 1, f"Expected one row for a mount, found {len(found)}") + return found[0] + + +def world(obj): + bpy.context.view_layer.update() + return tuple(obj.matrix_world.translation) + + +def glb_world_rotation_of(path, name): + """The GLB node's world rotation applied to glTF +Z.""" + data = Path(path).read_bytes() + length, kind = struct.unpack_from("