OpenRCT2-ObjectCommon 0.1.1__tar.gz → 0.1.2__tar.gz

{openrct2_objectcommon-0.1.1 → openrct2_objectcommon-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenRCT2-ObjectCommon
-Version: 0.1.1
+Version: 0.1.2
 Summary: Shared config, CLI, .parkobj, and object.json scaffolding for OpenRCT2 object generators.
 Project-URL: Homepage, https://github.com/alex-parisi/OpenRCT2-ObjectCommon
 Project-URL: Repository, https://github.com/alex-parisi/OpenRCT2-ObjectCommon
@@ -9,7 +9,7 @@ License-Expression: GPL-3.0-or-later
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: numpy>=1.26
-Requires-Dist: openrct2-x7-renderer>=0.3.0
+Requires-Dist: openrct2-x7-renderer>=0.3.1
 Requires-Dist: pillow>=10.0
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: blender

{openrct2_objectcommon-0.1.1 → openrct2_objectcommon-0.1.2}/openrct2_object_common/__init__.py

@@ -11,3 +11,22 @@ try:
     __version__ = version("OpenRCT2-ObjectCommon")
 except PackageNotFoundError:  # pragma: no cover - source tree without an install
     __version__ = "0.0.0"
+
+from .cli import make_context, run_cli
+from .config import LoadError, load_meshes, load_preview, parse_config
+from .objectjson import object_json_header
+from .parkobj import assemble_parkobj, write_images_dat_lgx
+from .placement import add_model_to_scene
+
+__all__ = [
+    "LoadError",
+    "add_model_to_scene",
+    "assemble_parkobj",
+    "load_meshes",
+    "load_preview",
+    "make_context",
+    "object_json_header",
+    "parse_config",
+    "run_cli",
+    "write_images_dat_lgx",
+]

openrct2_objectcommon-0.1.2/openrct2_object_common/blender/mesh_extract.py

@@ -0,0 +1,183 @@
+"""Shared Blender mesh extraction utilities.
+
+Extracts geometry from Blender scene objects into the renderer's Mesh format,
+applying the standard coordinate basis change (Blender → OBJ space). Used by
+both the vehicle and scenery add-ons so the extraction logic has a single
+source of truth.
+
+Requires ``bpy``; only import inside Blender.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+
+import bpy
+import numpy as np
+from mathutils import Matrix, Vector
+from openrct2_x7_renderer.image import quantize_to_indexed, read_png
+from openrct2_x7_renderer.mesh import Material, Mesh
+from openrct2_x7_renderer.types import IndexedImage
+
+# Blender (x, y, z) → OBJ (x, z, -y). Proper rotation (det = +1), so winding
+# is preserved. Every contributing object bakes this into emitted vertices.
+BASIS = Matrix(((1.0, 0.0, 0.0), (0.0, 0.0, 1.0), (0.0, -1.0, 0.0)))
+
+
+class SceneError(Exception):
+    """Raised when the Blender scene can't be converted to a valid object."""
+
+
+MaterialFn = Callable[[object], Material]
+
+
+def base_color(bmat) -> tuple[float, float, float]:
+    """The material's flat RGB colour from the Principled BSDF Base Color.
+
+    Falls back to ``diffuse_color`` (viewport colour) when there's no Principled
+    BSDF node or the Base Color input is linked (textured).
+    """
+    if getattr(bmat, "use_nodes", False) and bmat.node_tree is not None:
+        for node in bmat.node_tree.nodes:
+            if node.type != "BSDF_PRINCIPLED":
+                continue
+            base = node.inputs.get("Base Color")
+            if base is not None and not base.is_linked:
+                c = base.default_value
+                return (c[0], c[1], c[2])
+    col = bmat.diffuse_color
+    return (col[0], col[1], col[2])
+
+
+RegionMap = dict[str, tuple[int, int]]
+
+
+def material_base(
+    bmat, *, prop_attr: str, region_map: RegionMap
+) -> tuple[Material, object]:
+    """Build a Material with shared colour/specular/region/flag handling.
+
+    Returns ``(material, settings)`` where *settings* is the add-on's property
+    group (e.g. ``bmat.vg_material``) or ``None``. Callers extend *material*
+    with domain-specific flags and texture loading after this returns.
+
+    *prop_attr*: attribute name on the bpy material (e.g. ``"vg_material"``).
+    *region_map*: maps region enum string → ``(flag_bits, region_id)``.
+    """
+    from openrct2_x7_renderer.constants import MaterialFlag
+
+    m = Material()
+    if bmat is None:
+        return m, None
+
+    s = getattr(bmat, prop_attr, None)
+
+    if s is not None and s.use_color_override:
+        m.color = np.array(tuple(s.diffuse_color), dtype=np.float64)
+    else:
+        m.color = np.array(base_color(bmat), dtype=np.float64)
+
+    intensity = float(s.specular_intensity) if s is not None else 0.5
+    m.specular_exponent = float(s.specular_exponent) if s is not None else 50.0
+    tint = tuple(s.specular_tint) if (s is not None and s.use_specular_tint) else (1.0, 1.0, 1.0)
+    m.specular_color = np.array(tint, dtype=np.float64) * intensity
+
+    if s is None:
+        return m, None
+
+    flag, region = region_map.get(s.region, (0, 0))
+    m.flags |= flag
+    m.region = region
+    if s.is_mask:
+        m.flags |= MaterialFlag.IS_MASK
+    if s.no_ao:
+        m.flags |= MaterialFlag.NO_AO
+    if s.edge:
+        m.flags |= MaterialFlag.BACKGROUND_AA
+    if s.dark_edge:
+        m.flags |= MaterialFlag.BACKGROUND_AA_DARK
+    if s.no_bleed:
+        m.flags |= MaterialFlag.NO_BLEED
+
+    return m, s
+
+
+def extract_mesh(obj, depsgraph, material_fn: MaterialFn) -> Mesh | None:
+    """Evaluate *obj*, bake its world rotation+scale + basis change, → Mesh.
+
+    *material_fn* converts a ``bpy.types.Material`` (or ``None``) into the
+    renderer's :class:`~openrct2_x7_renderer.mesh.Material`. Each add-on
+    provides its own implementation to handle domain-specific flags.
+    """
+    eval_obj = obj.evaluated_get(depsgraph)
+    me = eval_obj.to_mesh()
+    try:
+        me.calc_loop_triangles()
+        tris = me.loop_triangles
+        if len(tris) == 0:
+            return None
+
+        slots = [s.material for s in obj.material_slots]
+        materials = [material_fn(bm) for bm in slots] or [Material()]
+        n_mats = len(materials)
+
+        linear = BASIS @ obj.matrix_world.to_3x3()
+        normal_mat = linear.inverted_safe().transposed()
+
+        uv_layer = me.uv_layers.active
+        verts: list[tuple[float, float, float]] = []
+        norms: list[tuple[float, float, float]] = []
+        uvs: list[tuple[float, float]] = []
+        faces: list[tuple[int, int, int]] = []
+        face_mats: list[int] = []
+
+        for lt in tris:
+            corner = []
+            split_n = lt.split_normals
+            for k in range(3):
+                vidx = lt.vertices[k]
+                loop_idx = lt.loops[k]
+                co = linear @ me.vertices[vidx].co
+                n = (normal_mat @ Vector(split_n[k])).normalized()
+                uv = uv_layer.data[loop_idx].uv if uv_layer else (0.0, 0.0)
+                verts.append((co.x, co.y, co.z))
+                norms.append((n.x, n.y, n.z))
+                uvs.append((uv[0], uv[1]))
+                corner.append(len(verts) - 1)
+            faces.append((corner[0], corner[1], corner[2]))
+            face_mats.append(min(lt.material_index, n_mats - 1))
+
+        return Mesh(
+            vertices=np.array(verts, dtype=np.float32),
+            normals=np.array(norms, dtype=np.float32),
+            uvs=np.array(uvs, dtype=np.float32),
+            faces=np.array(faces, dtype=np.uint32),
+            face_materials=np.array(face_mats, dtype=np.uint32),
+            materials=materials,
+        )
+    finally:
+        eval_obj.to_mesh_clear()
+
+
+def object_position(obj) -> list[float]:
+    """World translation of *obj* converted to OBJ space."""
+    p = BASIS @ obj.matrix_world.to_translation()
+    return [float(p.x), float(p.y), float(p.z)]
+
+
+def load_preview(filepath) -> IndexedImage | None:
+    """Load a preview image from *filepath*, quantizing non-paletted sources."""
+    if not filepath:
+        return None
+    path = bpy.path.abspath(filepath)
+    if not path or not os.path.exists(path):
+        return None
+    try:
+        return read_png(path)
+    except Exception:
+        pass
+    try:
+        return quantize_to_indexed(path)
+    except Exception:
+        return None

{openrct2_objectcommon-0.1.1 → openrct2_objectcommon-0.1.2}/openrct2_object_common/blender/modal.py

@@ -18,7 +18,14 @@ import time
 import traceback
 from typing import Any
 
-from bpy.types import Operator
+try:
+    from bpy.types import Operator
+except ImportError:  # pragma: no cover
+    # Outside Blender: provide a no-op stub so this module can be imported
+    # (e.g. for type-checking or test collection) without a Blender runtime.
+    # A real operator requires bpy; this stub allows the class to be defined.
+    class Operator:  # type: ignore[no-redef]
+        pass
 
 _SPINNER_FRAMES = "|/-\\"
 

openrct2_objectcommon-0.1.2/openrct2_object_common/blender/props.py

@@ -0,0 +1,76 @@
+"""Shared Blender PropertyGroup utilities and base classes.
+
+Provides helpers and property definitions common to both the vehicle and scenery
+add-ons. Requires ``bpy``; only import inside Blender.
+
+NOTE: no ``from __future__ import annotations``; PEP 563 would stringify the
+``prop: SomeProperty(...)`` definitions and break Blender registration.
+"""
+
+from bpy.props import (
+    BoolProperty,
+    EnumProperty,
+    FloatProperty,
+    FloatVectorProperty,
+)
+from bpy.types import PropertyGroup
+from openrct2_x7_renderer.constants import TILE_SIZE
+
+
+def title(name: str) -> str:
+    """``"steep_slopes"`` → ``"Steep Slopes"``."""
+    return name.replace("_", " ").title()
+
+
+def simple_items(names):
+    """Build ``(identifier, label, description)`` tuples for a single-select enum."""
+    return [(n, title(n), "") for n in names]
+
+
+SCALE_PRESET_VALUES = {
+    "REALISTIC": TILE_SIZE,
+    "TILE": 1.0,
+}
+
+SCALE_PRESET_ITEMS = [
+    ("REALISTIC", f"Realistic ({TILE_SIZE:g} m/tile)", "Match RCT2's real-world tile scale"),
+    ("TILE", "1 unit = 1 tile", "Model in tiles: one OBJ unit spans one tile"),
+    ("CUSTOM", "Custom", "Set the units-per-tile value manually"),
+]
+
+
+def scale_preset_update(self, _context):
+    """Write the preset's units-per-tile into the consumed value (Custom: no-op)."""
+    value = SCALE_PRESET_VALUES.get(self.scale_preset)
+    if value is not None:
+        self.units_per_tile = value
+
+
+LIGHT_TYPE_ITEMS = [
+    ("diffuse", "Diffuse", "Directional diffuse light"),
+    ("specular", "Specular", "Specular highlight light"),
+]
+
+
+class SharedLight(PropertyGroup):
+    """One entry in a custom lighting rig (shared by both add-ons)."""
+
+    type: EnumProperty(name="Type", items=LIGHT_TYPE_ITEMS, default="diffuse")
+    shadow: BoolProperty(
+        name="Casts Shadow",
+        description="Whether this light contributes to ambient-occlusion shadowing",
+        default=False,
+    )
+    direction: FloatVectorProperty(
+        name="Direction",
+        description="Direction in OBJ space (+X forward, +Y up, +Z right); normalized at render",
+        size=3,
+        default=(0.0, 1.0, 0.0),
+        subtype="XYZ",
+    )
+    strength: FloatProperty(
+        name="Strength",
+        description="Light intensity",
+        default=0.5,
+        min=0.0,
+    )

openrct2_objectcommon-0.1.2/openrct2_object_common/cli.py

@@ -0,0 +1,19 @@
+"""Re-export CLI scaffolding from the renderer for downstream generators."""
+
+from openrct2_x7_renderer.cli import (  # noqa: F401
+    TEST_ZOOM,
+    RenderFn,
+    make_context,
+    output_directory_of,
+    parse_cli_args,
+    run_cli,
+)
+
+__all__ = [
+    "TEST_ZOOM",
+    "RenderFn",
+    "make_context",
+    "output_directory_of",
+    "parse_cli_args",
+    "run_cli",
+]

openrct2_objectcommon-0.1.2/openrct2_object_common/config.py

@@ -0,0 +1,35 @@
+"""Re-export config utilities from the renderer for downstream generators."""
+
+from openrct2_x7_renderer.config import (  # noqa: F401
+    LoadError,
+    as_array_or_wrap,
+    load_meshes,
+    load_preview,
+    optional_bool,
+    optional_int,
+    optional_number,
+    optional_string,
+    optional_string_list,
+    parse_config,
+    read_vector3,
+    require_int,
+    require_number,
+    require_string,
+)
+
+__all__ = [
+    "LoadError",
+    "as_array_or_wrap",
+    "load_meshes",
+    "load_preview",
+    "optional_bool",
+    "optional_int",
+    "optional_number",
+    "optional_string",
+    "optional_string_list",
+    "parse_config",
+    "read_vector3",
+    "require_int",
+    "require_number",
+    "require_string",
+]

{openrct2_objectcommon-0.1.1 → openrct2_objectcommon-0.1.2}/openrct2_object_common/parkobj.py

@@ -7,17 +7,22 @@ references it via ``$LGX:``, and zip the two together. The per-kind work is just
 *what* sprites to render and *what* metadata to emit; this module owns the rest.
 """
 
+import contextlib
 import json
 import logging
+import math
+import os
+import tempfile
 import zipfile
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
+import numpy as np
 from openrct2_x7_renderer.images_dat import write_images_dat
 from openrct2_x7_renderer.types import IndexedImage
 
-__all__ = ["RenderFn", "assemble_parkobj", "write_images_dat_lgx"]
+__all__ = ["RenderFn", "assemble_parkobj", "combine_indexed_images", "write_images_dat_lgx"]
 
 log = logging.getLogger(__name__)
 
@@ -26,6 +31,39 @@ log = logging.getLogger(__name__)
 RenderFn = Callable[[Path], list[str]]
 
 
+def combine_indexed_images(images: list[IndexedImage], columns: int = 2) -> IndexedImage:
+    """Tile IndexedImages into a single grid image, aligned by draw offset.
+
+    Each cell spans the union of every image's draw-offset bounding box, so a
+    shared sprite anchor lands at the same spot in every cell and the rotated
+    views line up. Cells fill left-to-right, top-to-bottom over a transparent
+    (palette index 0) background; ``columns`` is capped at the image count so a
+    single image doesn't leave a blank cell. Used to show all four rotated
+    preview directions in one image.
+    """
+    if not images:
+        return IndexedImage.blank(1, 1)
+    columns = max(1, min(columns, len(images)))
+    left = min(im.x_offset for im in images)
+    top = min(im.y_offset for im in images)
+    cell_w = max(im.x_offset + im.width for im in images) - left
+    cell_h = max(im.y_offset + im.height for im in images) - top
+    rows = math.ceil(len(images) / columns)
+    canvas = np.zeros((rows * cell_h, columns * cell_w), dtype=np.uint8)
+    for idx, im in enumerate(images):
+        row, col = divmod(idx, columns)
+        x = col * cell_w + (im.x_offset - left)
+        y = row * cell_h + (im.y_offset - top)
+        canvas[y : y + im.height, x : x + im.width] = im.pixels
+    return IndexedImage(
+        width=canvas.shape[1],
+        height=canvas.shape[0],
+        x_offset=0,
+        y_offset=0,
+        pixels=canvas,
+    )
+
+
 def write_images_dat_lgx(
     images: list[IndexedImage], work_dir: Path, *, note: str = ""
 ) -> list[str]:
@@ -83,6 +121,14 @@ def assemble_parkobj(
     (work_dir / "object.json").write_text(json.dumps(obj_json, indent=4))
 
     parkobj_path.parent.mkdir(parents=True, exist_ok=True)
-    with zipfile.ZipFile(parkobj_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-        zf.write(work_dir / "object.json", "object.json")
-        zf.write(work_dir / "images.dat", "images.dat")
+    tmp_fd, tmp_path = tempfile.mkstemp(suffix=".parkobj", dir=parkobj_path.parent)
+    os.close(tmp_fd)
+    try:
+        with zipfile.ZipFile(tmp_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+            zf.write(work_dir / "object.json", "object.json")
+            zf.write(work_dir / "images.dat", "images.dat")
+        os.replace(tmp_path, parkobj_path)
+    except BaseException:
+        with contextlib.suppress(OSError):
+            os.unlink(tmp_path)
+        raise

{openrct2_objectcommon-0.1.1 → openrct2_objectcommon-0.1.2}/openrct2_object_common/placement.py

@@ -12,6 +12,7 @@ last pose), which is the ``clamp_frame`` flag.
 import math
 
 import numpy as np
+from numpy.typing import NDArray
 from openrct2_x7_renderer.geometry import rotate_x, rotate_y, rotate_z
 from openrct2_x7_renderer.mesh import Mesh
 from openrct2_x7_renderer.ray_trace import SceneBuilder
@@ -20,7 +21,7 @@ from openrct2_x7_renderer.types import Model
 __all__ = ["add_model_to_scene", "orientation_to_matrix"]
 
 
-def orientation_to_matrix(orientation_deg: np.ndarray) -> np.ndarray:
+def orientation_to_matrix(orientation_deg: NDArray[np.float64]) -> NDArray[np.float64]:
     """A MeshFrame orientation ``(angle_y, angle_z, angle_x)`` in degrees as a
     ``(3, 3)`` rotation matrix, applied as ``rotate_y @ rotate_z @ rotate_x``."""
     rx, ry, rz = orientation_deg * (math.pi / 180.0)

openrct2_objectcommon-0.1.2/openrct2_object_common/testing.py

@@ -0,0 +1,82 @@
+"""Shared renderer stubs for unit-testing object generators.
+
+VehicleGenerator and SceneryGenerator both need a lightweight fake of the
+Embree render pipeline that records lifecycle events without touching real
+GPU/Embree resources.  Import these instead of reimplementing them per-suite.
+
+Event format in ``FakeContext.events``:
+  ``"begin"``        — :meth:`FakeContext.begin_render` was called.
+  ``"finalize"``     — :meth:`FakeBuilder.finalize` was called.
+  ``"end"``          — :meth:`FakeScene.end_render` was called (via explicit
+                       call or context-manager exit).
+  ``("add", mask)``  — :meth:`FakeBuilder.add_model` was called with ``mask``.
+"""
+
+from openrct2_x7_renderer.types import IndexedImage
+
+__all__ = ["FakeContext", "FakeScene", "FakeBuilder"]
+
+# Events appended to FakeContext.events by the stub pipeline.
+Event = str | tuple[str, int]
+
+
+class FakeScene:
+    """Stands in for ``FinalizedScene``; every view renders a 1×1 dummy."""
+
+    def __init__(self, events: list[Event]) -> None:
+        self._events = events
+
+    def __enter__(self) -> "FakeScene":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.end_render()
+
+    def render_view(self, _view: object) -> IndexedImage:
+        return IndexedImage.blank(1, 1)
+
+    def render_silhouette(self, _view: object) -> IndexedImage:
+        return IndexedImage.blank(1, 1)
+
+    def end_render(self) -> None:
+        self._events.append("end")
+
+
+class FakeBuilder:
+    """Stands in for ``SceneBuilder``; records lifecycle events."""
+
+    def __init__(self, events: list[Event]) -> None:
+        self._events = events
+
+    def __enter__(self) -> "FakeBuilder":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        pass
+
+    def add_model(
+        self,
+        mesh: object,
+        matrix: object,
+        translation: object,
+        mask: int = 0,
+    ) -> "FakeBuilder":
+        self._events.append(("add", mask))
+        return self
+
+    def finalize(self) -> FakeScene:
+        self._events.append("finalize")
+        return FakeScene(self._events)
+
+
+class FakeContext:
+    """Records render lifecycle calls without touching Embree."""
+
+    def __init__(self) -> None:
+        self.events: list[Event] = []
+        # Mirrors Context.remap_overrides; may be overwritten by export_*_test.
+        self.remap_overrides: dict[int, tuple[int, ...]] = {}
+
+    def begin_render(self) -> FakeBuilder:
+        self.events.append("begin")
+        return FakeBuilder(self.events)

{openrct2_objectcommon-0.1.1 → openrct2_objectcommon-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "OpenRCT2-ObjectCommon"
-version = "0.1.1"
+version = "0.1.2"
 description = "Shared config, CLI, .parkobj, and object.json scaffolding for OpenRCT2 object generators."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -9,7 +9,7 @@ authors = [
     { name = "Alex Parisi", email = "alex@atparisi.com" }
 ]
 dependencies = [
-    "openrct2-x7-renderer>=0.3.0",
+    "openrct2-x7-renderer>=0.3.1",
     "numpy>=1.26",
     "pillow>=10.0",
     "pyyaml>=6.0",
@@ -40,6 +40,7 @@ addopts = "-q --cov=openrct2_object_common"
 
 [tool.coverage.run]
 source = ["openrct2_object_common"]
+omit = ["openrct2_object_common/testing.py"]
 
 [tool.coverage.report]
 exclude_also = [
@@ -63,6 +64,7 @@ select = ["E", "F", "I", "UP", "B", "W", "N"]
 [tool.mypy]
 python_version = "3.11"
 files = ["openrct2_object_common"]
+strict = true
 warn_unused_ignores = true
 warn_redundant_casts = true
 warn_unused_configs = true
@@ -70,11 +72,6 @@ warn_unused_configs = true
 # type-checked in the consuming add-on repos, not here.
 exclude = ["openrct2_object_common/blender/"]
 
-# openrct2-x7-renderer ships no py.typed marker, so mypy can't resolve its types.
-[[tool.mypy.overrides]]
-module = ["openrct2_x7_renderer.*"]
-ignore_missing_imports = true
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"