litematica-render 0.1.0__py3-none-any.whl

litematic/render/shapes/families.py

@@ -0,0 +1,357 @@
+"""Builtin shape table: box families plus multi-box and cross plants."""
+
+from collections.abc import Callable, Mapping
+
+import numpy as np
+
+from litematic.render.errors import RenderError
+from litematic.render.quads import (
+    CULL_NONE,
+    QUAD_DTYPE,
+    TIER_EAST,
+    TIER_NORTH,
+    TIER_SOUTH,
+    TIER_UP,
+    TIER_WEST,
+    _redstone_tint,
+)
+from litematic.render.shapes.boxes import (
+    Box,
+    _banner,
+    _barrel,
+    _button,
+    _cactus,
+    _carpet,
+    _chest,
+    _combine,
+    _composter,
+    _conduit,
+    _door,
+    _facing,
+    _flag,
+    _fluid,
+    _head,
+    _ladder,
+    _lectern,
+    _lily_pad,
+    _pressure_plate,
+    _rail,
+    _repeater,
+    _shulker_box,
+    _sign,
+    _slab,
+    _snow,
+    _stairs,
+    _text,
+    _torch_standing,
+    _torch_wall,
+    _trapdoor,
+    box_quads,
+)
+
+__all__ = ["builtin_quads", "box_quads"]
+
+Builder = Callable[[Mapping[str, str]], np.ndarray]
+_SIDES = ("north", "south", "west", "east")
+
+# Connection geometry per family (Blockscope shape.rs taxonomy): fences
+# carry two rails per connected side at y 6..9 and 12..15, walls one full
+# arm with the post height driven by "up" (low and tall arms share the
+# same 0..14 box, so tall arms' cross-block reach is approximated), panes
+# and iron bars one full arm per side plus a full bar when unconnected.
+_FENCE_POST: Box = (6, 0, 6, 10, 16, 10)
+_FENCE_ARMS: dict[str, tuple[Box, Box]] = {
+    "north": ((6, 6, 0, 10, 9, 6), (6, 12, 0, 10, 15, 6)),
+    "south": ((6, 6, 10, 10, 9, 16), (6, 12, 10, 10, 15, 16)),
+    "west": ((0, 6, 6, 6, 9, 10), (0, 12, 6, 6, 15, 10)),
+    "east": ((10, 6, 6, 16, 9, 10), (10, 12, 6, 16, 15, 10)),
+}
+_GATE_POST: Box = (6, 0, 6, 10, 16, 10)
+# Open gate bars stay centered over the full block depth per Blockscope,
+# coplanarly overlapping the post side faces; both faces share the same
+# auto-UV texel mapping, so the overlap does not change rendered pixels.
+_GATE_BAR_X: Box = (0, 6, 6, 16, 15, 10)
+_GATE_BAR_Z: Box = (6, 6, 0, 10, 15, 16)
+_WALL_ARMS: dict[str, Box] = {
+    "north": (4, 0, 0, 12, 14, 4),
+    "south": (4, 0, 12, 12, 14, 16),
+    "west": (0, 0, 4, 4, 14, 12),
+    "east": (12, 0, 4, 16, 14, 12),
+}
+_PANE_POST: Box = (7, 0, 7, 9, 16, 9)
+_PANE_ARMS: dict[str, Box] = {
+    "north": (7, 0, 0, 9, 16, 7),
+    "south": (7, 0, 9, 9, 16, 16),
+    "west": (0, 0, 7, 7, 16, 9),
+    "east": (9, 0, 7, 16, 16, 9),
+}
+_PANE_BAR: Box = (7, 0, 0, 9, 16, 16)
+
+# Cross plants: two diagonal planes spanning the full block height,
+# texture v running bottom (v=16) to top (v=0); both quads are double-
+# sided and carry the up tier like the vanilla cross model.
+_CROSS_VTX = np.array(
+    [
+        [(0, 0, 0), (16, 0, 16), (16, 16, 16), (0, 16, 0)],
+        [(16, 0, 0), (0, 0, 16), (0, 16, 16), (16, 16, 0)],
+    ],
+    dtype="f4",
+)
+_CROSS_UV = np.tile(
+    np.array([(0, 16), (16, 16), (16, 0), (0, 0)], dtype="f4"), (2, 1, 1)
+)
+
+# Cross-plant block names rendered as two diagonal planes (Blockscope
+# taxonomy plus the sapling/propagule suffix families).
+_CROSS_PLANTS = frozenset(
+    {
+        "short_grass",
+        "tall_grass",
+        "fern",
+        "large_fern",
+        "dandelion",
+        "poppy",
+        "blue_orchid",
+        "allium",
+        "azure_bluet",
+        "oxeye_daisy",
+        "cornflower",
+        "lily_of_the_valley",
+        "red_tulip",
+        "orange_tulip",
+        "white_tulip",
+        "pink_tulip",
+        "sunflower",
+        "lilac",
+        "rose_bush",
+        "peony",
+        "vine",
+        "cobweb",
+        "bamboo",
+        "dead_bush",
+        "seagrass",
+        "kelp",
+        "kelp_plant",
+        "sugar_cane",
+        "wheat",
+        "carrots",
+        "potatoes",
+        "beetroots",
+        "torchflower",
+        "pitcher_plant",
+        "bush",
+        "sweet_berry_bush",
+        "tall_seagrass",
+        "red_mushroom",
+        "brown_mushroom",
+        "crimson_roots",
+        "warped_roots",
+        "nether_sprouts",
+        "crimson_fungus",
+        "warped_fungus",
+    }
+)
+
+
+def _fence(properties: Mapping[str, str]) -> np.ndarray:
+    """Fence: center post plus two rails on every connected side."""
+    boxes: list[Box] = [_FENCE_POST]
+    for side in _SIDES:
+        if _flag(properties, side):
+            boxes.extend(_FENCE_ARMS[side])
+    return _combine(boxes)
+
+
+def _fence_gate(properties: Mapping[str, str]) -> np.ndarray:
+    """Fence gate: center post plus a bar swung aside when open."""
+    along_x = _facing(properties) in ("north", "south")
+    bar = _GATE_BAR_X if along_x else _GATE_BAR_Z
+    if _flag(properties, "open"):
+        bar = _GATE_BAR_Z if along_x else _GATE_BAR_X
+    return _combine([_GATE_POST, bar])
+
+
+def _side(properties: Mapping[str, str], key: str) -> bool:
+    """True when a wall side property is present and not "none"."""
+    return _text(properties, key, "none") != "none"
+
+
+def _wall(properties: Mapping[str, str]) -> np.ndarray:
+    """Wall: center column plus one arm per connected side."""
+    top = 16.0 if _flag(properties, "up") else 14.0
+    boxes: list[Box] = [(4, 0, 4, 12, top, 12)]
+    for side in _SIDES:
+        if _side(properties, side):
+            boxes.append(_WALL_ARMS[side])
+    return _combine(boxes)
+
+
+def _pane(properties: Mapping[str, str]) -> np.ndarray:
+    """Pane and iron bars: center post plus arms, full bar when alone."""
+    boxes: list[Box] = [_PANE_POST]
+    connected = False
+    for side in _SIDES:
+        if _flag(properties, side):
+            boxes.append(_PANE_ARMS[side])
+            connected = True
+    if not connected:
+        boxes.append(_PANE_BAR)
+    return _combine(boxes)
+
+
+def _cross(properties: Mapping[str, str]) -> np.ndarray:
+    """Cross plant: two diagonal double-sided planes at full height."""
+    quads = np.empty(2, dtype=QUAD_DTYPE)
+    quads["vtx"] = _CROSS_VTX
+    quads["uv"] = _CROSS_UV
+    quads["texkey"] = ""
+    quads["shade"] = TIER_UP
+    quads["dbl"] = True
+    quads["cull"] = CULL_NONE
+    return quads
+
+
+def _named(*names: str) -> Callable[[str], bool]:
+    """Match one of the exact block names."""
+    return lambda stem: stem in names
+
+
+def _suffixed(suffix: str) -> Callable[[str], bool]:
+    """Match any block name ending with the suffix."""
+    return lambda stem: stem.endswith(suffix)
+
+
+def _is_shulker(stem: str) -> bool:
+    """Match the shulker box family including the base block."""
+    return stem == "shulker_box" or stem.endswith("_shulker_box")
+
+
+def _is_head(stem: str) -> bool:
+    """Match heads and skulls."""
+    return stem.endswith("_head") or stem.endswith("skull")
+
+
+def _is_wall_torch(stem: str) -> bool:
+    """Match wall-mounted torches."""
+    return stem == "wall_torch" or stem.endswith("_wall_torch")
+
+
+def _is_torch(stem: str) -> bool:
+    """Match standing torches (checked after wall torches)."""
+    return stem == "torch" or stem.endswith("_torch")
+
+
+def _is_pane(stem: str) -> bool:
+    """Match glass panes and the iron bars block."""
+    return stem == "iron_bars" or stem.endswith("_pane")
+
+
+def _is_cross(stem: str) -> bool:
+    """Match cross-plant names and sapling/propagule suffixes."""
+    return stem in _CROSS_PLANTS or stem.endswith(("_sapling", "_propagule"))
+
+
+def _ground_plane(transposed: bool, texkey: str) -> np.ndarray:
+    """One full-width dust plane on the block floor; transposed uv runs E-W."""
+    quad = box_quads(0, 0, 0, 16, 0, 16)[[TIER_UP]]
+    if transposed:
+        quad["uv"][0] = quad["vtx"][0][:, [2, 0]]
+    quad["texkey"][0] = texkey
+    return quad
+
+
+def _wall_strip(tier: int, texkey: str) -> np.ndarray:
+    """One full-height dust strip on a block face, visible from both sides."""
+    bounds = {
+        TIER_NORTH: (0, 0, 0, 16, 16, 0),
+        TIER_SOUTH: (0, 0, 16, 16, 16, 16),
+        TIER_WEST: (0, 0, 0, 0, 16, 16),
+        TIER_EAST: (16, 0, 0, 16, 16, 16),
+    }[tier]
+    quad = box_quads(*bounds)[[tier]]
+    quad["texkey"][0] = texkey
+    quad["dbl"][0] = True
+    quad["shade"][0] = TIER_UP
+    return quad
+
+
+def _wire(properties: Mapping[str, str]) -> np.ndarray:
+    """Redstone dust: ground planes per connected axis, wall strips for up."""
+    try:
+        power = max(0, min(15, int(properties.get("power", "0"))))
+    except (TypeError, ValueError):
+        power = 0
+    r, g, b = _redstone_tint(power)
+    line = f"block/redstone_dust_line0@{r},{g},{b}"
+    dot = f"block/redstone_dust_dot@{r},{g},{b}"
+    connected = [
+        properties.get(direction, "none") in ("side", "up")
+        for direction in _SIDES
+    ]
+    quads: list[np.ndarray] = []
+    if not any(connected):
+        quads.append(_ground_plane(False, dot))
+    else:
+        # North-south planes sample the texture column along x; east-west
+        # planes transpose the uv so the same column runs along z.
+        if connected[0] or connected[1]:
+            quads.append(_ground_plane(False, line))
+        if connected[2] or connected[3]:
+            quads.append(_ground_plane(True, line))
+    for direction, tier in zip(_SIDES, (TIER_NORTH, TIER_SOUTH, TIER_WEST, TIER_EAST)):
+        if properties.get(direction, "none") == "up":
+            quads.append(_wall_strip(tier, line))
+    return np.concatenate(quads)
+
+
+# Ordered dispatch, earlier rows win: wall torches must precede standing
+# torches because "*_wall_torch" also ends with "_torch". The other rows
+# are pairwise disjoint and keep Blockscope's precedence for reference.
+_FAMILIES: tuple[tuple[Callable[[str], bool], Builder], ...] = (
+    (_suffixed("_fence_gate"), _fence_gate),
+    (_suffixed("_fence"), _fence),
+    (_suffixed("_wall"), _wall),
+    (_is_pane, _pane),
+    (_is_cross, _cross),
+    (_named("water", "lava", "bubble_column"), _fluid),
+    (_named("snow"), _snow),
+    (_named("redstone_wire"), _wire),
+    (_named("composter"), _composter),
+    (_suffixed("_slab"), _slab),
+    (_suffixed("_stairs"), _stairs),
+    (_suffixed("_carpet"), _carpet),
+    (_suffixed("rail"), _rail),
+    (_suffixed("_pressure_plate"), _pressure_plate),
+    (_named("repeater", "comparator"), _repeater),
+    (_suffixed("_trapdoor"), _trapdoor),
+    (_suffixed("_door"), _door),
+    (_named("ladder"), _ladder),
+    (_suffixed("_button"), _button),
+    (_suffixed("sign"), _sign),
+    (_suffixed("banner"), _banner),
+    (_named("chest", "trapped_chest", "ender_chest"), _chest),
+    (_is_shulker, _shulker_box),
+    (_named("barrel"), _barrel),
+    (_is_head, _head),
+    (_named("cactus"), _cactus),
+    (_named("lily_pad"), _lily_pad),
+    (_named("conduit"), _conduit),
+    (_named("lectern"), _lectern),
+    (_is_wall_torch, _torch_wall),
+    (_is_torch, _torch_standing),
+)
+
+
+def builtin_quads(
+    state_name: str, properties: Mapping[str, str]
+) -> np.ndarray | None:
+    """Build geometry-only quads for a known family, else None."""
+    if not isinstance(state_name, str):
+        raise RenderError("shapes: block state name must be a string")
+    if not isinstance(properties, Mapping):
+        raise RenderError("shapes: block properties must be a mapping")
+    stem = state_name.partition(":")[2] or state_name
+    for matches, build in _FAMILIES:
+        if matches(stem):
+            return build(properties)
+    return None

litematica_render-0.1.0.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.5
+Name: litematica-render
+Version: 0.1.0
+Summary: Parse Minecraft Litematica schematics and render them to isometric PNGs
+Project-URL: Homepage, https://github.com/late-maple/Litematica-Render
+Author: late-maple
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pillow>=9.1; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: pack
+Requires-Dist: pillow>=9.1; extra == 'pack'
+Description-Content-Type: text/markdown
+
+# Litematica-Render
+
+Offline isometric rendering of Minecraft Litematica `.litematic` schematics.
+
+## Features
+
+- Parse `.litematic` files: streaming NBT, lazy vectorized region unpacking
+- Render isometric PNGs from a resource pack's real blockstates, models, and textures
+- Pack stack: layer add-on packs (e.g. Faithful 32x) over a vanilla base, MC-style first-hit lookup
+
+## Example
+
+```python
+from litematic import load
+from litematic.render import isometric_png, unresolved_colors
+
+schem = load("schematic.litematic")
+
+png = isometric_png(
+    schem,
+    textures_path="vanilla-assets.zip",   # base pack, required
+    extra_packs=["Faithful 32x.zip"],     # add-ons, earlier = higher priority
+    max_size=2048,
+)
+with open("render.png", "wb") as f:
+    f.write(png)
+
+# block names the pack stack cannot cover; those render magenta
+missing = unresolved_colors(schem, textures_path="vanilla-assets.zip")
+```

litematica_render-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+litematic/__init__.py,sha256=E2jYR3b82jQXR81PqeT4A01P6J1gvrVRu8RRZ0BcGfg,715
+litematic/parse/__init__.py,sha256=l4mrsKjEn7snnwkUCX9olPWXjRcJGW0PX6s4RG3HfPE,70
+litematic/parse/errors.py,sha256=Kx5GCUdpRJcHqjF8J-znSlGGCb4NHDbR2cQULzp-9Z8,390
+litematic/parse/model.py,sha256=Tt4-atRpqYEGHRIQgDJ8oWABmqmN4vbKSpJen0i-8Q8,7212
+litematic/parse/nbt.py,sha256=PkpyfGraPDpHQexXmdAMADi_7DHCDcOZr5upTihFTNU,5137
+litematic/parse/parser.py,sha256=rHDgIlgiaRGF9ZlX3dmAuDH-b84ot5rtOOTUV1X0ZCE,11765
+litematic/render/__init__.py,sha256=enttGyJ4q7To8tJUx9Liw6R92hqNQ8n_o1oL-gq3-qA,4038
+litematic/render/errors.py,sha256=EY1MDCoRCXZ0YMOj1IodOUsNq56RJ3rpp4wBjszI-Ys,221
+litematic/render/png.py,sha256=t9E28uSm_FysBCPmK7Tng927EP-pctPRsPR7NlfK6Rw,1451
+litematic/render/quads.py,sha256=keEFJgM1JJFXSueenyQKQUepI6mK80dT4oAIEHWHWQM,3202
+litematic/render/pack/__init__.py,sha256=P-4XDsFVJ2kVdr6o89n55x5tUhaWUEbHNPDR8LYm9Po,320
+litematic/render/pack/blockstate.py,sha256=wozrHtq1SOWQ1BfWd0IUjbVl1GftL5b1TIVevCY3QG4,4021
+litematic/render/pack/compile.py,sha256=_DR7SA4tk_jk0ZsnX3kGZN-jwGcysdGVzMu4sX-vAAs,12448
+litematic/render/pack/elements.py,sha256=lMoZztRGGEKO1u8-eUiHctRnsAegAdgojsJwdJOd6zI,13645
+litematic/render/pack/entities.py,sha256=SRDUJqlDmQPi88qSu9j5SP4lYgyD2sLDXaLtVNDdN8Y,6027
+litematic/render/pack/extract.py,sha256=09UTQLSWZo2eX7zM1iy8x3r6n6QS_GWIkDtsd8UuEQA,8192
+litematic/render/pack/loader.py,sha256=48Nw4RnurJQBg4V9Lzc_MiFEdRiLVm4K7pUgZ-twluI,6768
+litematic/render/pack/resolve.py,sha256=BoyWX9ZQ7aqusYoLFHRYajrKhbKkJNKfZjkLYhA7p1o,11025
+litematic/render/pack/stack.py,sha256=0sBboFXIYij9TZ3Of1dEGux72Eh1KBwHh0NcJCRx_ks,2876
+litematic/render/pack/texture.py,sha256=yrvYRfhLaVlAoFBY6ruKTolHwXwb6dFfGhysWPSl-fs,10386
+litematic/render/scene/__init__.py,sha256=DXSoN_mQMVw12MkWfY5RJF6bqXmqoc5b7J2gX1h5FuE,266
+litematic/render/scene/isometric.py,sha256=Gs9MA8KxBB4jvzuOrKzvOLWFxFQWoAv4VkYcj7dnZPk,19832
+litematic/render/scene/painter.py,sha256=b3pI4CgjSoXsfj6e5Si46UeShcliBIy45_bRoUgrlBE,14184
+litematic/render/shapes/__init__.py,sha256=nbLcM_HO2l6U4uUMR7_5liMMuvexYdbz3ZHIxoTJlUw,232
+litematic/render/shapes/boxes.py,sha256=v8GkWeo7xrr9bbWV2t-m1XM6IZpKfS3zQgXuLlRrRb4,9603
+litematic/render/shapes/families.py,sha256=yzfN5GnUHSJC8sB3qmrhLVOgd2mGYfIjWd05Cx0ZGkY,11130
+litematica_render-0.1.0.dist-info/METADATA,sha256=C-od2iPBWy4oASOpmn539uSv8_RHImIsB3vb-rwckfU,1648
+litematica_render-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+litematica_render-0.1.0.dist-info/licenses/LICENSE,sha256=FeHjRX52Zw1w0SHoK2lW2xttM_HUYk_bsdFcoKPPTrk,1067
+litematica_render-0.1.0.dist-info/RECORD,,

litematica_render-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

litematica_render-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 late_maple
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.