OpenRCT2-ObjectCommon 0.2.3__tar.gz → 0.2.5__tar.gz

{openrct2_objectcommon-0.2.3 → openrct2_objectcommon-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenRCT2-ObjectCommon
-Version: 0.2.3
+Version: 0.2.5
 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.8
+Requires-Dist: openrct2-x7-renderer>=0.3.9
 Requires-Dist: pillow>=10.0
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: blender

openrct2_objectcommon-0.2.5/openrct2_object_common/blender/bake.py

@@ -0,0 +1,163 @@
+"""Bake a material's procedural shader-node graph to an albedo texture.
+
+The standalone renderer has no Cycles/``bpy`` at shade time, so it can't evaluate
+Blender's procedural node graphs directly. Instead, when a material opts in
+(``bake_procedural``), the add-on bakes the node graph's albedo (Cycles
+``DIFFUSE``/``COLOR`` pass — colour without lighting, since the renderer does its
+own shading) into an image at export and feeds it through the normal texture
+path. Baked textures are UV-locked, so they are rotation-stable across sprites.
+
+Shared by both add-ons. ``bpy``-dependent orchestration lives in
+:func:`bake_materials`; :func:`_image_to_texture` is kept ``bpy``-free so it can
+be unit-tested without Blender.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from openrct2_x7_renderer.mesh import Texture
+
+from .mesh_extract import SceneError
+
+_TARGET_NODE = "__orct2_bake_target"
+
+# (identifier, label, description) tuples for a bpy EnumProperty; both add-ons
+# expose the same bake resolutions.
+BAKE_RESOLUTION_ITEMS = [
+    ("64", "64×64", "Bake at 64×64"),
+    ("128", "128×128", "Bake at 128×128"),
+    ("256", "256×256", "Bake at 256×256"),
+    ("512", "512×512", "Bake at 512×512"),
+]
+
+
+def _image_to_texture(image) -> Texture:
+    """Convert a baked Blender image into a linear-RGB :class:`Texture`.
+
+    Blender stores image rows bottom-up; the renderer samples top-left, so the
+    rows are flipped (mirroring the UV V-flip in ``mesh_extract.extract_mesh``).
+    Float images are already linear, matching what the renderer expects.
+    """
+    width, height = int(image.size[0]), int(image.size[1])
+    flat = np.asarray(image.pixels[:], dtype=np.float32).reshape(height, width, 4)
+    rgb = np.ascontiguousarray(flat[::-1, :, :3])
+    return Texture(width=width, height=height, pixels=rgb)
+
+
+def _bake_settings(mat, prop_attr):
+    """The add-on's per-material settings if this material opts into baking."""
+    s = getattr(mat, prop_attr, None)
+    if s is not None and getattr(s, "bake_procedural", False):
+        return s
+    return None
+
+
+def _add_target_node(mat, image):
+    """Add (and activate) an Image Texture node Cycles will bake into."""
+    mat.use_nodes = True
+    nodes = mat.node_tree.nodes
+    node = nodes.new("ShaderNodeTexImage")
+    node.name = _TARGET_NODE
+    node.image = image
+    node.select = True
+    nodes.active = node
+    return node
+
+
+def _select_only(view_layer, obj) -> None:
+    for other in view_layer.objects:
+        other.select_set(False)
+    obj.select_set(True)
+    view_layer.objects.active = obj
+
+
+def bake_materials(context, objects, *, prop_attr) -> dict:
+    """Bake every opted-in material on *objects* to a texture.
+
+    Returns ``{bpy.types.Material: Texture}``. Main-thread only (drives Cycles via
+    ``bpy.ops``). Raises :class:`SceneError` with author-facing guidance when a
+    to-bake object has no UV map. Render engine, selection and the touched
+    materials' ``use_nodes`` are saved and restored.
+
+    *prop_attr* is the add-on's material settings attribute (``"vgs_material"`` /
+    ``"vg_material"``); each opted-in material's ``bake_resolution`` sets its size.
+    """
+    import bpy
+
+    # Plan: per object, the opted-in materials and their settings.
+    plan = []
+    for obj in objects:
+        if obj.type != "MESH":
+            continue
+        wanted = {}
+        for slot in obj.material_slots:
+            if slot.material is None:
+                continue
+            settings = _bake_settings(slot.material, prop_attr)
+            if settings is not None:
+                wanted[slot.material] = settings
+        if not wanted:
+            continue
+        if not obj.data.uv_layers:
+            name = next(iter(wanted)).name
+            raise SceneError(
+                f"{obj.name} / {name}: bake needs a UV map — "
+                "unwrap the object (U ▸ Smart UV Project)."
+            )
+        plan.append((obj, wanted))
+    if not plan:
+        return {}
+
+    scene = context.scene
+    view_layer = context.view_layer
+    prev_engine = scene.render.engine
+    prev_active = view_layer.objects.active
+    prev_selected = [o for o in view_layer.objects if o.select_get()]
+
+    result: dict = {}
+    try:
+        scene.render.engine = "CYCLES"
+        for obj, wanted in plan:
+            # Every material slot used by the mesh needs an active image node for
+            # the bake to succeed; non-target slots get a 1x1 throwaway.
+            touched = []  # (mat, node, image, prev_use_nodes, keep)
+            for slot in obj.material_slots:
+                mat = slot.material
+                if mat is None:
+                    continue
+                keep = mat in wanted
+                res = int(wanted[mat].bake_resolution) if keep else 1
+                prev_use_nodes = mat.use_nodes
+                image = bpy.data.images.new(
+                    f"__orct2_bake_{mat.name}",
+                    width=res,
+                    height=res,
+                    float_buffer=True,
+                    alpha=False,
+                )
+                node = _add_target_node(mat, image)
+                touched.append((mat, node, image, prev_use_nodes, keep))
+
+            _select_only(view_layer, obj)
+            bpy.ops.object.bake(type="DIFFUSE", pass_filter={"COLOR"}, margin=4)
+
+            for mat, node, image, prev_use_nodes, keep in touched:
+                if keep:
+                    result[mat] = _image_to_texture(image)
+                mat.node_tree.nodes.remove(node)
+                mat.use_nodes = prev_use_nodes
+                bpy.data.images.remove(image)
+    finally:
+        scene.render.engine = prev_engine
+        for o in view_layer.objects:
+            o.select_set(o in prev_selected)
+        view_layer.objects.active = prev_active
+
+    return result
+
+
+def draw_bake(layout, ms) -> None:
+    """Draw the bake toggle (+ resolution when enabled) into *layout*."""
+    layout.prop(ms, "bake_procedural")
+    if ms.bake_procedural:
+        layout.prop(ms, "bake_resolution")

{openrct2_objectcommon-0.2.3 → openrct2_objectcommon-0.2.5}/openrct2_object_common/blender/props.py

@@ -62,6 +62,11 @@ DITHER_MODE_ITEMS = [
         "Bayer (frame-stable)",
         "Ordered dither locked to screen position; stable across animation frames",
     ),
+    (
+        "blue_noise",
+        "Blue noise (frame-stable)",
+        "Like Bayer but a blue-noise mask; less perceptible residual motion under rotation",
+    ),
     ("none", "None", "No dithering; flat palette quantisation"),
 ]
 

{openrct2_objectcommon-0.2.3 → openrct2_objectcommon-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "OpenRCT2-ObjectCommon"
-version = "0.2.3"
+version = "0.2.5"
 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.8",
+    "openrct2-x7-renderer>=0.3.9",
     "numpy>=1.26",
     "pillow>=10.0",
     "pyyaml>=6.0",

{openrct2_objectcommon-0.2.3 → openrct2_objectcommon-0.2.5}/tests/test_blender_shared.py

@@ -7,8 +7,10 @@ collection), so these modules import and run without a Blender runtime.
 from types import SimpleNamespace
 
 import numpy as np
+import pytest
 from mathutils import Matrix, Vector  # provided by conftest fake
-from openrct2_object_common.blender import mesh_extract, props
+from openrct2_object_common.blender import bake, mesh_extract, props
+from openrct2_object_common.blender.mesh_extract import SceneError
 from openrct2_x7_renderer.constants import MaterialFlag
 
 # ===========================================================================
@@ -50,8 +52,10 @@ def test_shared_light_propertygroup_defined():
 def test_dither_mode_items_match_renderer_modes():
     # The add-on enum identifiers must be exactly the strings make_context /
     # Context accept, and the default must be one of them.
+    from openrct2_x7_renderer.ray_trace import DITHER_MODES
+
     ids = {ident for ident, _label, _desc in props.DITHER_MODE_ITEMS}
-    assert ids == {"none", "floyd_steinberg", "bayer"}
+    assert ids == set(DITHER_MODES)
     assert props.DEFAULT_DITHER_MODE in ids
 
 
@@ -313,3 +317,79 @@ def test_load_preview_returns_none_when_both_fail(monkeypatch):
     monkeypatch.setattr(mesh_extract, "read_png", _boom)
     monkeypatch.setattr(mesh_extract, "quantize_to_indexed", _boom)
     assert mesh_extract.load_preview("/img.png") is None
+
+
+# ===========================================================================
+# bake.py
+# ===========================================================================
+
+
+def test_image_to_texture_flips_rows_and_drops_alpha():
+    # 2x2 RGBA float image, Blender's bottom-up row order: bottom red, top blue.
+    pixels = [
+        1.0, 0.0, 0.0, 1.0,  1.0, 0.0, 0.0, 1.0,  # bottom row
+        0.0, 0.0, 1.0, 1.0,  0.0, 0.0, 1.0, 1.0,  # top row
+    ]
+    image = SimpleNamespace(size=(2, 2), pixels=pixels)
+    tex = bake._image_to_texture(image)
+    assert tex.width == 2
+    assert tex.height == 2
+    assert tex.pixels.shape == (2, 2, 3)
+    # After the V-flip, row 0 is the top (blue), row 1 the bottom (red).
+    assert np.allclose(tex.pixels[0, 0], [0.0, 0.0, 1.0])
+    assert np.allclose(tex.pixels[1, 0], [1.0, 0.0, 0.0])
+
+
+class _BakeMat:
+    # A real bpy Material is hashable (by identity); SimpleNamespace is not,
+    # so use a plain class for materials used as dict keys.
+    def __init__(self, name, *, on, res="256"):
+        self.name = name
+        self.vg_material = SimpleNamespace(bake_procedural=on, bake_resolution=res)
+
+
+def _bake_mat(name, *, on, res="256"):
+    return _BakeMat(name, on=on, res=res)
+
+
+def _bake_obj(materials, *, has_uv):
+    return SimpleNamespace(
+        name="Cube",
+        type="MESH",
+        material_slots=[SimpleNamespace(material=m) for m in materials],
+        data=SimpleNamespace(uv_layers=[object()] if has_uv else []),
+    )
+
+
+def test_bake_materials_no_opted_in_materials_returns_empty():
+    obj = _bake_obj([_bake_mat("Plain", on=False)], has_uv=True)
+    assert bake.bake_materials(SimpleNamespace(), [obj], prop_attr="vg_material") == {}
+
+
+def test_bake_materials_skips_non_mesh_objects():
+    obj = SimpleNamespace(type="EMPTY")
+    assert bake.bake_materials(SimpleNamespace(), [obj], prop_attr="vg_material") == {}
+
+
+def test_bake_materials_missing_uv_raises_guidance():
+    obj = _bake_obj([_bake_mat("Wood", on=True)], has_uv=False)
+    with pytest.raises(SceneError, match="UV map"):
+        bake.bake_materials(SimpleNamespace(), [obj], prop_attr="vg_material")
+
+
+class _FakeLayout:
+    def __init__(self):
+        self.props: list[str] = []
+
+    def prop(self, _data, name):
+        self.props.append(name)
+
+
+def test_draw_bake_shows_resolution_only_when_enabled():
+    on = _FakeLayout()
+    bake.draw_bake(on, SimpleNamespace(bake_procedural=True, bake_resolution="256"))
+    assert on.props == ["bake_procedural", "bake_resolution"]
+
+    off = _FakeLayout()
+    bake.draw_bake(off, SimpleNamespace(bake_procedural=False, bake_resolution="256"))
+    assert off.props == ["bake_procedural"]