structura-render 0.1.0__tar.gz

structura_render-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: structura-render
+Version: 0.1.0
+Summary: Minecraft block-model resolution, image rendering and USDZ export
+Project-URL: Repository, https://github.com/kirimba1024/structura-render
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: structura-core<0.2,>=0.1.0
+Requires-Dist: numpy<3,>=1.26
+Requires-Dist: Pillow<12,>=11
+Requires-Dist: scipy<2,>=1.13
+Provides-Extra: hero
+Requires-Dist: pyvista<0.47,>=0.46; extra == "hero"
+Provides-Extra: usdz
+Requires-Dist: pyvista<0.47,>=0.46; extra == "usdz"
+Requires-Dist: usd-core<27,>=26; extra == "usdz"
+Provides-Extra: legacy
+Requires-Dist: structura-core[legacy]<0.2,>=0.1.0; extra == "legacy"
+
+# structura-render
+
+**Turn a Minecraft Structure NBT into a real photo or a 3D file — using
+your own game's actual textures and block shapes, not guesses.**
+
+No fake textures, no hardcoded block shapes, no bundled game files. Point
+it at your own Minecraft client and get pixel-accurate PNGs and USDZ out
+the other end.
+
+**This isn't a lookup table of ~50 common blocks with guessed shapes.**
+The resolver walks the same blockstate → multipart/variant → model → element
+rotation → UV pipeline the Minecraft client itself uses, so ordinary vanilla
+blocks — stairs, doors, fences, plants, redstone and the rest — come from the
+game's data rather than per-block guesses. Vanilla's non-model renderers
+(chests, banners, heads, shulker boxes, conduit, bell, decorated pots,
+portals and fluids) share a compact textured compound-model layer.
+
+<p>
+  <img src="docs/screenshots/usdz-floating-island.png" width="49%" alt="USDZ export of a floating island structure, viewed in a 3D viewer">
+  <img src="docs/screenshots/hero-render-detail.png" width="49%" alt="Close-up hero-render detail: windows, timber framing, flower pots">
+</p>
+
+## Why it's worth using
+
+- **Data-driven where vanilla is.** JSON-modelled blocks use the same
+  blockstate/model data and PNGs as the game. Dynamic blocks use their real
+  entity textures on compact state-aware compound geometry.
+- **One mesh, every output.** Geometry is resolved once and shared between
+  PNG renders and USDZ export, so what you preview is exactly what you get
+  in 3D — nothing drifts between formats.
+- **Clean by design.** Zero Mojang assets in this repo or its releases —
+  can't, EULA forbids it. You always supply your own client, so there's no
+  legal grey area to worry about.
+- **Version-flexible.** Point it at a `.jar` from Minecraft 1.13 through
+  the latest release and it just works — verified end to end on both
+  1.21.1 and the newest 26.2. New blocks resolve automatically; no waiting
+  on us to add support.
+- **Light by default.** Core install is just NumPy, Pillow and SciPy.
+  PyVista/USD only get pulled in if you actually ask for hero renders or
+  USDZ export.
+- **Self-updating classification.** Which blocks are solid cubes (for
+  occlusion) is computed from real model geometry, not a hand-maintained
+  name list — it doesn't go stale as new blocks ship.
+
+## What it does
+
+- **`block_model.py`** — generic blockstate/model resolver: variants,
+  multipart conditions, parent chains, element rotations, UV rotation and
+  UV locking. Builds real geometry for every JSON-modelled vanilla block.
+- **`textures.py`** — resolves `#variable` texture references and samples
+  the real PNG, including per-pixel alpha for correct occlusion (glass,
+  leaves, iron bars).
+- **`projections.py`** — six-view orthographic PNGs (top/bottom/N/S/E/W)
+  with envelope/aura/terrain-pod/glass-dome mask overlays, for engineering
+  QA rather than looks.
+- **`hero.py`** (`hero` extra) — one real-textured, real-lit PyVista render
+  of the finished structure — the kind of shot above.
+- **`usdz.py`** (`usdz` extra) — a textured 3D mesh for AR Quick Look or
+  any USDZ viewer, from the same mesh builder as the hero renderer.
+- **`build_full_cube_list.py` / `build_opaque_blocks.py`** — data-derived
+  block classification, described above.
+- **`docs/block-render-audit-26.2.md`** — one row for every vanilla
+  blockstate, including explicit dynamic-render limitations.
+- **`legacy_input.py`** (`legacy` extra) — every entry point also accepts a
+  legacy `.schematic`, sponge `.schem`, `.litematic`, or anything else
+  [amulet-core](https://github.com/Amulet-Team/Amulet-Core) recognizes, and
+  converts it to Structure NBT on the fly. No manual conversion step.
+
+## Quick start
+
+No clone needed for either package, but `structura-core` isn't on PyPI yet,
+so `pip` can't resolve it as a transitive dependency — install it
+explicitly first, then `structura-render`:
+
+```bash
+export STRUCTURA_MINECRAFT_ASSETS="$HOME/Library/Application Support/minecraft/versions/1.21.1/1.21.1.jar"
+pip install 'git+https://github.com/kirimba1024/structura-core.git'
+pip install "structura-render[usdz] @ git+https://github.com/kirimba1024/structura-render.git"
+structura-render-hero structure.nbt preview.png
+```
+
+Have a legacy `.schematic`/`.schem`/`.litematic` instead of Structure NBT?
+Add the `legacy` extra (`[usdz,legacy]`) and pass it straight in — no
+separate conversion step:
+
+```bash
+structura-render-hero house.schematic preview.png
+```
+
+Point `STRUCTURA_MINECRAFT_ASSETS` at a client `.jar` (any version from
+1.13 up) or an already-extracted `assets/minecraft` directory. A `.jar` is
+extracted once into `$XDG_CACHE_HOME/structura-render/jar-assets`
+(`~/.cache/...` if unset), keyed by its path, size and mtime, so repeat
+runs and multiple installed versions don't re-extract or collide. When the
+variable is unset, the package searches parent folders and the current
+directory for `assets/minecraft`.
+
+This project's own datapack targets Minecraft Java 1.21.1 specifically
+(`structura_core.version.JAVA_VERSION`); if you're previewing *its*
+structures, match that version for a guaranteed-correct result. Anything
+older than 1.13 uses a different asset layout entirely (pre-"flattening")
+and isn't supported. On load, the package checks for `heavy_core` (added
+in 1.21) and warns on stderr if it's missing, as a cheap signal that the
+pointed-at client predates 1.21 — not exhaustive, just a sanity check.
+
+Use the lighter `hero` extra when USDZ export isn't needed; plain
+projection rendering skips PyVista and OpenUSD entirely.

structura_render-0.1.0/README.md

@@ -0,0 +1,107 @@
+# structura-render
+
+**Turn a Minecraft Structure NBT into a real photo or a 3D file — using
+your own game's actual textures and block shapes, not guesses.**
+
+No fake textures, no hardcoded block shapes, no bundled game files. Point
+it at your own Minecraft client and get pixel-accurate PNGs and USDZ out
+the other end.
+
+**This isn't a lookup table of ~50 common blocks with guessed shapes.**
+The resolver walks the same blockstate → multipart/variant → model → element
+rotation → UV pipeline the Minecraft client itself uses, so ordinary vanilla
+blocks — stairs, doors, fences, plants, redstone and the rest — come from the
+game's data rather than per-block guesses. Vanilla's non-model renderers
+(chests, banners, heads, shulker boxes, conduit, bell, decorated pots,
+portals and fluids) share a compact textured compound-model layer.
+
+<p>
+  <img src="docs/screenshots/usdz-floating-island.png" width="49%" alt="USDZ export of a floating island structure, viewed in a 3D viewer">
+  <img src="docs/screenshots/hero-render-detail.png" width="49%" alt="Close-up hero-render detail: windows, timber framing, flower pots">
+</p>
+
+## Why it's worth using
+
+- **Data-driven where vanilla is.** JSON-modelled blocks use the same
+  blockstate/model data and PNGs as the game. Dynamic blocks use their real
+  entity textures on compact state-aware compound geometry.
+- **One mesh, every output.** Geometry is resolved once and shared between
+  PNG renders and USDZ export, so what you preview is exactly what you get
+  in 3D — nothing drifts between formats.
+- **Clean by design.** Zero Mojang assets in this repo or its releases —
+  can't, EULA forbids it. You always supply your own client, so there's no
+  legal grey area to worry about.
+- **Version-flexible.** Point it at a `.jar` from Minecraft 1.13 through
+  the latest release and it just works — verified end to end on both
+  1.21.1 and the newest 26.2. New blocks resolve automatically; no waiting
+  on us to add support.
+- **Light by default.** Core install is just NumPy, Pillow and SciPy.
+  PyVista/USD only get pulled in if you actually ask for hero renders or
+  USDZ export.
+- **Self-updating classification.** Which blocks are solid cubes (for
+  occlusion) is computed from real model geometry, not a hand-maintained
+  name list — it doesn't go stale as new blocks ship.
+
+## What it does
+
+- **`block_model.py`** — generic blockstate/model resolver: variants,
+  multipart conditions, parent chains, element rotations, UV rotation and
+  UV locking. Builds real geometry for every JSON-modelled vanilla block.
+- **`textures.py`** — resolves `#variable` texture references and samples
+  the real PNG, including per-pixel alpha for correct occlusion (glass,
+  leaves, iron bars).
+- **`projections.py`** — six-view orthographic PNGs (top/bottom/N/S/E/W)
+  with envelope/aura/terrain-pod/glass-dome mask overlays, for engineering
+  QA rather than looks.
+- **`hero.py`** (`hero` extra) — one real-textured, real-lit PyVista render
+  of the finished structure — the kind of shot above.
+- **`usdz.py`** (`usdz` extra) — a textured 3D mesh for AR Quick Look or
+  any USDZ viewer, from the same mesh builder as the hero renderer.
+- **`build_full_cube_list.py` / `build_opaque_blocks.py`** — data-derived
+  block classification, described above.
+- **`docs/block-render-audit-26.2.md`** — one row for every vanilla
+  blockstate, including explicit dynamic-render limitations.
+- **`legacy_input.py`** (`legacy` extra) — every entry point also accepts a
+  legacy `.schematic`, sponge `.schem`, `.litematic`, or anything else
+  [amulet-core](https://github.com/Amulet-Team/Amulet-Core) recognizes, and
+  converts it to Structure NBT on the fly. No manual conversion step.
+
+## Quick start
+
+No clone needed for either package, but `structura-core` isn't on PyPI yet,
+so `pip` can't resolve it as a transitive dependency — install it
+explicitly first, then `structura-render`:
+
+```bash
+export STRUCTURA_MINECRAFT_ASSETS="$HOME/Library/Application Support/minecraft/versions/1.21.1/1.21.1.jar"
+pip install 'git+https://github.com/kirimba1024/structura-core.git'
+pip install "structura-render[usdz] @ git+https://github.com/kirimba1024/structura-render.git"
+structura-render-hero structure.nbt preview.png
+```
+
+Have a legacy `.schematic`/`.schem`/`.litematic` instead of Structure NBT?
+Add the `legacy` extra (`[usdz,legacy]`) and pass it straight in — no
+separate conversion step:
+
+```bash
+structura-render-hero house.schematic preview.png
+```
+
+Point `STRUCTURA_MINECRAFT_ASSETS` at a client `.jar` (any version from
+1.13 up) or an already-extracted `assets/minecraft` directory. A `.jar` is
+extracted once into `$XDG_CACHE_HOME/structura-render/jar-assets`
+(`~/.cache/...` if unset), keyed by its path, size and mtime, so repeat
+runs and multiple installed versions don't re-extract or collide. When the
+variable is unset, the package searches parent folders and the current
+directory for `assets/minecraft`.
+
+This project's own datapack targets Minecraft Java 1.21.1 specifically
+(`structura_core.version.JAVA_VERSION`); if you're previewing *its*
+structures, match that version for a guaranteed-correct result. Anything
+older than 1.13 uses a different asset layout entirely (pre-"flattening")
+and isn't supported. On load, the package checks for `heavy_core` (added
+in 1.21) and warns on stderr if it's missing, as a cheap signal that the
+pointed-at client predates 1.21 — not exhaustive, just a sanity check.
+
+Use the lighter `hero` extra when USDZ export isn't needed; plain
+projection rendering skips PyVista and OpenUSD entirely.

structura_render-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "structura-render"
+version = "0.1.0"
+description = "Minecraft block-model resolution, image rendering and USDZ export"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+  "structura-core>=0.1.0,<0.2",
+  "numpy>=1.26,<3",
+  "Pillow>=11,<12",
+  "scipy>=1.13,<2",
+]
+
+[project.optional-dependencies]
+hero = ["pyvista>=0.46,<0.47"]
+usdz = ["pyvista>=0.46,<0.47", "usd-core>=26,<27"]
+legacy = ["structura-core[legacy]>=0.1.0,<0.2"]
+
+[project.scripts]
+structura-render-projections = "structura_render.projections:main"
+structura-render-hero = "structura_render.hero:main"
+structura-export-usdz = "structura_render.usdz:main"
+structura-package-usdz-variants = "structura_render.usdz_variants:main"
+structura-build-full-cube-list = "structura_render.build_full_cube_list:main"
+structura-build-opaque-blocks = "structura_render.build_opaque_blocks:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+structura_render = ["data/*.json"]
+
+[project.urls]
+Repository = "https://github.com/kirimba1024/structura-render"

structura_render-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

structura_render-0.1.0/src/structura_render/__init__.py

@@ -0,0 +1,6 @@
+"""Minecraft Structure NBT renderers and reusable mesh construction."""
+
+from .textures import TextureBank, tint_for
+
+__all__ = ["TextureBank", "tint_for"]
+__version__ = "0.1.0"

structura_render-0.1.0/src/structura_render/assets.py

@@ -0,0 +1,82 @@
+"""Minecraft client-asset discovery without a repository-relative import."""
+
+import hashlib
+import os
+import sys
+import zipfile
+from pathlib import Path
+
+_VERSION_MARKER_BLOCK = "heavy_core"
+
+
+def _cache_root() -> Path:
+    configured = os.environ.get("XDG_CACHE_HOME")
+    base = Path(configured).expanduser() if configured else Path.home() / ".cache"
+    return base / "structura-render" / "jar-assets"
+
+
+def _extract_jar_assets(jar_path: Path) -> Path:
+    stat = jar_path.stat()
+    key = hashlib.sha1(
+        f"{jar_path.resolve()}:{stat.st_mtime_ns}:{stat.st_size}".encode(),
+    ).hexdigest()[:16]
+    dest = _cache_root() / key
+    marker = dest / ".extracted"
+    target = dest / "assets" / "minecraft"
+    if marker.is_file() and target.is_dir():
+        return target
+
+    with zipfile.ZipFile(jar_path) as archive:
+        members = [
+            name for name in archive.namelist()
+            if name.startswith("assets/minecraft/") and not name.endswith("/")
+        ]
+        if not members:
+            raise FileNotFoundError(
+                f"{jar_path} has no assets/minecraft/ entries; "
+                "is this a real Minecraft client jar?",
+            )
+        dest.mkdir(parents=True, exist_ok=True)
+        archive.extractall(dest, members=members)
+    marker.touch()
+    return target
+
+
+def _warn_if_version_mismatch(assets_root: Path) -> None:
+    marker = assets_root / "models" / "block" / f"{_VERSION_MARKER_BLOCK}.json"
+    if not marker.is_file():
+        print(
+            f"structura_render: WARNING: {assets_root} has no "
+            f"{_VERSION_MARKER_BLOCK} model (added in Minecraft 1.21) -- "
+            "these assets look older than the datapack's target version; "
+            "renders may not match what actually spawns in-game.",
+            file=sys.stderr,
+        )
+
+
+def minecraft_assets_root() -> Path:
+    configured = os.environ.get("STRUCTURA_MINECRAFT_ASSETS")
+    if configured:
+        path = Path(configured).expanduser().resolve()
+        if path.is_dir():
+            _warn_if_version_mismatch(path)
+            return path
+        if path.is_file() and path.suffix == ".jar":
+            extracted = _extract_jar_assets(path)
+            _warn_if_version_mismatch(extracted)
+            return extracted
+        raise FileNotFoundError(
+            f"STRUCTURA_MINECRAFT_ASSETS does not exist: {path} "
+            "(point it at an assets/minecraft directory or a client .jar)",
+        )
+
+    candidates = [Path.cwd(), *Path(__file__).resolve().parents]
+    for root in candidates:
+        path = root / "assets" / "minecraft"
+        if path.is_dir():
+            _warn_if_version_mismatch(path)
+            return path
+    return Path.cwd() / "assets" / "minecraft"
+
+
+ASSETS = minecraft_assets_root()

structura_render-0.1.0/src/structura_render/block_model.py

@@ -0,0 +1,255 @@
+"""Resolve vanilla blockstate/model JSON into textured quads."""
+import json
+import math
+from functools import wraps
+
+from .assets import ASSETS
+
+BLOCKSTATES = ASSETS / "blockstates"
+MODELS = ASSETS / "models/block"
+
+DIRECTIONS = ("up", "down", "north", "south", "east", "west")
+AXIS_VEC = {
+    "up": (0, 1, 0), "down": (0, -1, 0),
+    "north": (0, 0, -1), "south": (0, 0, 1),
+    "east": (1, 0, 0), "west": (-1, 0, 0),
+}
+VEC_AXIS = {v: k for k, v in AXIS_VEC.items()}
+
+FACE_CORNERS = {
+    "up": (4, 5, 6, 7), "down": (0, 1, 2, 3),
+    "north": (1, 0, 4, 5), "south": (3, 2, 6, 7),
+    "east": (2, 1, 5, 6), "west": (0, 3, 7, 4),
+}
+FACE_UV_BASIS = {
+    "up": ((1, 0, 0), (0, 0, 1)), "down": ((1, 0, 0), (0, 0, 1)),
+    "north": ((-1, 0, 0), (0, 1, 0)), "south": ((1, 0, 0), (0, 1, 0)),
+    "east": ((0, 0, -1), (0, 1, 0)), "west": ((0, 0, 1), (0, 1, 0)),
+}
+FACE_UV_PLANE = {
+    "up": (0, 2), "down": (0, 2),
+    "north": (0, 1), "south": (0, 1),
+    "east": (2, 1), "west": (2, 1),
+}
+
+_blockstate_cache = {}
+_model_cache = {}
+_RESOLUTION_ERRORS = (KeyError, IndexError, TypeError, ValueError, json.JSONDecodeError)
+
+
+def safe(fn):
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except _RESOLUTION_ERRORS:
+            return None
+    return wrapper
+
+
+def strip_ns(name):
+    name = name.split(":", 1)[-1]
+    return name[len("block/"):] if name.startswith("block/") else name
+
+
+def load_blockstate(name):
+    name = strip_ns(name)
+    if name not in _blockstate_cache:
+        path = BLOCKSTATES / f"{name}.json"
+        _blockstate_cache[name] = json.loads(path.read_text()) if path.exists() else None
+    return _blockstate_cache[name]
+
+
+def load_model(name):
+    name = strip_ns(name)
+    if name not in _model_cache:
+        path = MODELS / f"{name}.json"
+        _model_cache[name] = json.loads(path.read_text()) if path.exists() else None
+    return _model_cache[name]
+
+
+def resolve_model(name, depth=0):
+    if depth > 10:
+        return {"elements": None, "textures": {}}
+    data = load_model(name)
+    if data is None:
+        return {"elements": None, "textures": {}}
+    parent = data.get("parent")
+    base = resolve_model(parent, depth + 1) if parent else {"elements": None, "textures": {}}
+    return {
+        "elements": data.get("elements", base["elements"]),
+        "textures": {**base["textures"], **data.get("textures", {})},
+    }
+
+
+def resolve_texture(ref, textures, depth=0):
+    if ref is None or depth > 10:
+        return None
+    if isinstance(ref, dict):
+        return resolve_texture(ref.get("sprite"), textures, depth + 1)
+    key = ref[1:] if ref.startswith("#") else ref
+    if key in textures:
+        return resolve_texture(textures[key], textures, depth + 1)
+    return strip_ns(ref) if not ref.startswith("#") else None
+
+
+def matching_variant(variants, props):
+    parsed = []
+    for key, value in variants.items():
+        pairs = tuple(pair.split("=", 1) for pair in key.split(",")) if key else ()
+        parsed.append((dict(pairs), value))
+    matches = [
+        (len(wanted), value)
+        for wanted, value in parsed
+        if all(props.get(k) == v for k, v in wanted.items())
+    ]
+    return max(matches, key=lambda item: item[0])[1] if matches else (parsed[0][1] if parsed else None)
+
+
+def condition_matches(condition, props):
+    if "OR" in condition:
+        return any(condition_matches(part, props) for part in condition["OR"])
+    if "AND" in condition:
+        return all(condition_matches(part, props) for part in condition["AND"])
+    return all(props.get(key) in str(wanted).split("|") for key, wanted in condition.items())
+
+
+def selected_models(blockstate, props):
+    if "variants" in blockstate:
+        entries = [matching_variant(blockstate["variants"], props)]
+    else:
+        entries = [
+            part["apply"] for part in blockstate.get("multipart", ())
+            if "when" not in part or condition_matches(part["when"], props)
+        ]
+    return [entry[0] if isinstance(entry, list) else entry for entry in entries if entry]
+
+
+def _rotate(point, origin, axis, degrees):
+    angle = math.radians(degrees)
+    cosine, sine = math.cos(angle), math.sin(angle)
+    x, y, z = (point[i] - origin[i] for i in range(3))
+    if axis == "x":
+        y, z = y * cosine - z * sine, y * sine + z * cosine
+    elif axis == "y":
+        x, z = x * cosine - z * sine, x * sine + z * cosine
+    else:
+        x, y = x * cosine - y * sine, x * sine + y * cosine
+    return x + origin[0], y + origin[1], z + origin[2]
+
+
+def rotate_vector(vector, x_deg, y_deg):
+    rotated = _rotate(vector, (0, 0, 0), "x", x_deg)
+    return tuple(round(v) for v in _rotate(rotated, (0, 0, 0), "y", y_deg))
+
+
+def rotate_direction(direction, x_deg, y_deg):
+    return VEC_AXIS[rotate_vector(AXIS_VEC[direction], x_deg, y_deg)]
+
+
+def rotate_element(point, rotation):
+    if not rotation:
+        return point
+    origin = rotation.get("origin", (8, 8, 8))
+    if "axis" not in rotation:
+        for axis in "xyz":
+            point = _rotate(point, origin, axis, rotation.get(axis, 0))
+        return point
+    axis, angle = rotation["axis"], rotation["angle"]
+    if rotation.get("rescale"):
+        scale = 1 / math.cos(math.radians(angle))
+        point = tuple(
+            origin[i] + (point[i] - origin[i]) * (1 if "xyz"[i] == axis else scale)
+            for i in range(3)
+        )
+    return _rotate(point, origin, axis, angle)
+
+
+def rotate_blockstate(point, x_deg, y_deg):
+    point = _rotate(point, (8, 8, 8), "x", x_deg)
+    return _rotate(point, (8, 8, 8), "y", y_deg)
+
+
+def box_corners(lo, hi):
+    return (
+        (lo[0], lo[1], lo[2]), (hi[0], lo[1], lo[2]),
+        (hi[0], lo[1], hi[2]), (lo[0], lo[1], hi[2]),
+        (lo[0], hi[1], lo[2]), (hi[0], hi[1], lo[2]),
+        (hi[0], hi[1], hi[2]), (lo[0], hi[1], hi[2]),
+    )
+
+
+def _neg(vector):
+    return tuple(-v for v in vector)
+
+
+def uvlock_quarters(direction, x_deg, y_deg):
+    world_direction = rotate_direction(direction, x_deg, y_deg)
+    u, v = (rotate_vector(axis, x_deg, y_deg) for axis in FACE_UV_BASIS[direction])
+    target_u, target_v = FACE_UV_BASIS[world_direction]
+    choices = ((u, v), (v, _neg(u)), (_neg(u), _neg(v)), (_neg(v), u))
+    return next((i for i, basis in enumerate(choices) if basis == (target_u, target_v)), 0)
+
+
+@safe
+def post_texture(name):
+    model = resolve_model(f"{strip_ns(name)}_post")
+    return resolve_texture(model["textures"].get("particle"), model["textures"])
+
+
+@safe
+def block_elements(name, props):
+    blockstate = load_blockstate(name)
+    if blockstate is None:
+        return None
+    entries = selected_models(blockstate, props)
+    result = []
+    for entry in entries:
+        model = resolve_model(entry["model"])
+        if not model["elements"]:
+            continue
+        x_deg, y_deg = entry.get("x", 0), entry.get("y", 0)
+        for element in model["elements"]:
+            lo, hi = element["from"], element["to"]
+            corners = [
+                rotate_blockstate(rotate_element(point, element.get("rotation")), x_deg, y_deg)
+                for point in box_corners(lo, hi)
+            ]
+            faces = {}
+            for direction, face in element.get("faces", {}).items():
+                texture = resolve_texture(face.get("texture"), model["textures"])
+                if texture is None:
+                    continue
+                uv = face.get("uv", default_uv(direction, lo, hi))
+                world_direction = rotate_direction(direction, x_deg, y_deg)
+                cullface = face.get("cullface")
+                cullface = {"top": "up", "bottom": "down"}.get(cullface, cullface)
+                faces[world_direction] = {
+                    "texture": texture,
+                    "uv": tuple(value / 16 for value in uv),
+                    "uv_rotation": (
+                        face.get("rotation", 0) // 90
+                        + (uvlock_quarters(direction, x_deg, y_deg) if entry.get("uvlock") else 0)
+                    ) % 4,
+                    "vertices": tuple(
+                        tuple(value / 16 for value in corners[i])
+                        for i in FACE_CORNERS[direction]
+                    ),
+                    "cullface": rotate_direction(cullface, x_deg, y_deg) if cullface else None,
+                    "tinted": "tintindex" in face,
+                }
+            if faces:
+                result.append({
+                    "lo": tuple(min(point[i] for point in corners) / 16 for i in range(3)),
+                    "hi": tuple(max(point[i] for point in corners) / 16 for i in range(3)),
+                    "faces": faces,
+                })
+    return result if result else ([] if entries else None)
+
+
+def default_uv(direction, lo, hi):
+    a, b = FACE_UV_PLANE[direction]
+    lo_b, hi_b = lo[b], hi[b]
+    if b == 1:
+        lo_b, hi_b = 16 - hi[b], 16 - lo[b]
+    return lo[a], lo_b, hi[a], hi_b