litematica-render 0.1.0__py3-none-any.whl

litematic/render/pack/elements.py

@@ -0,0 +1,421 @@
+"""Model element geometry: boxes compiled to textured quads."""
+
+import math
+from typing import Any, Callable, cast
+
+import numpy as np
+
+from litematic.render.pack.texture import _rotate
+from litematic.render.quads import (
+    _CUBE_VTX,
+    CULL_NONE,
+    QUAD_DTYPE,
+    TIER_DOWN,
+    TIER_EAST,
+    TIER_NORTH,
+    TIER_SOUTH,
+    TIER_UP,
+    TIER_WEST,
+    is_parallelogram,
+)
+
+_OPAQUE_ALPHA = 250.0
+
+
+
+_FACE_TIER = {
+    "down": TIER_DOWN,
+    "up": TIER_UP,
+    "north": TIER_NORTH,
+    "south": TIER_SOUTH,
+    "west": TIER_WEST,
+    "east": TIER_EAST,
+}
+# Auto-UVs follow vanilla defaultFaceUV; ring order (u1,v1),(u2,v1),(u2,v2),(u1,v2).
+
+
+
+_VEC = {
+    "up": (0, 1, 0),
+    "down": (0, -1, 0),
+    "north": (0, 0, -1),
+    "south": (0, 0, 1),
+    "west": (-1, 0, 0),
+    "east": (1, 0, 0),
+}
+
+
+
+_ROT_AXIS = {"x": 0, "y": 1, "z": 2}
+
+
+
+_RESCALE_FACTORS = {22.5: 1.0823922, 45.0: 1.4142135}
+
+
+
+_FACE_GEOM: dict[int, tuple[tuple[int, int, int], ...]] = {
+    tier: tuple((int(c[0]), int(c[1]), int(c[2])) for c in corners)
+    for tier, corners in enumerate(_CUBE_VTX)
+}
+# Vanilla element rotation: 90-degree-free angles about one axis through an
+# origin, optionally rescaled on the perpendicular axes by 1/cos(|angle|).
+
+
+
+def _corner_tuple(point: Any) -> tuple[float, float, float]:
+    """Convert one vertex row to a plain three-float tuple."""
+    x, y, z = (float(value) for value in point)
+    return (x, y, z)
+
+
+
+def _sorted_corners(quad: Any) -> list[tuple[float, float, float]]:
+    """Return a quad's corners as a sorted, order-independent list."""
+    return sorted(_corner_tuple(point) for point in quad["vtx"])
+
+
+_UNIT_CORNERS: dict[int, list[tuple[float, float, float]]] = {
+    tier: sorted(_corner_tuple(corner) for corner in corners)
+    for tier, corners in _FACE_GEOM.items()
+}
+
+
+
+# Unit-cube corners per tier as sorted order-independent lists: blockstate
+# rotations map a face onto its own square with reversed winding, so an
+# element-wise comparison would wrongly reject rotated opaque cubes.
+
+
+
+
+def _unit_cube_occl(
+    quads: np.ndarray, tex_arrays: dict[str, np.ndarray]
+) -> bool:
+    """Judge the v1 opaque-cube rule: exact unit cube, visible faces opaque."""
+    if len(quads) != 6:
+        return False
+    by_tier: dict[int, Any] = {}
+    for quad in quads:
+        by_tier[int(quad["shade"])] = quad
+    if set(by_tier) != set(_FACE_GEOM):
+        return False
+    for tier in _FACE_GEOM:
+        if _sorted_corners(by_tier[tier]) != _UNIT_CORNERS[tier]:
+            return False
+    alphas: list[float] = []
+    for tier in (TIER_UP, TIER_SOUTH, TIER_EAST):
+        array = tex_arrays.get(str(by_tier[tier]["texkey"]))
+        if array is None:
+            return False
+        alphas.append(float(array[..., 3].mean()))
+    return float(np.mean(alphas)) >= _OPAQUE_ALPHA
+
+
+
+def _compile_elements(
+    elements: list[dict[str, Any]],
+    textures: dict[str, str],
+    ns: str,
+    x_rot: int,
+    y_rot: int,
+    texkey_for: Callable[[dict[str, Any], dict[str, str], str], str | None],
+    *,
+    uvlock: bool = False,
+) -> np.ndarray | None:
+    """Compile model elements into world-space quads for one variant."""
+    rows: list[tuple[Any, Any, str, int, bool, int]] = []
+    kx = (int(x_rot) // 90) % 4
+    ky = (int(y_rot) // 90) % 4
+    for element in elements:
+        if not isinstance(element, dict):
+            continue
+        bounds = _element_bounds(element)
+        faces = element.get("faces")
+        if bounds is None or not isinstance(faces, dict):
+            continue
+        try:
+            rotation = _element_rotation(element)
+        except ValueError:
+            continue
+        thin = _thin_axes(bounds)
+        if len(thin) > 1:
+            continue
+        rotated = rotation is not None
+        # Zero-thickness planes and rotated elements have non-axis-aligned
+        # or paired back faces: spec marks them dbl (double-sided, no AO).
+        double: bool = bool(thin) or rotated
+        shaded = bool(element.get("shade", True))
+        for face_name, tier in _FACE_TIER.items():
+            face = faces.get(face_name)
+            if not isinstance(face, dict):
+                continue
+            if thin and _VEC[face_name][thin[0]] == 0:
+                continue
+            texkey = texkey_for(face, textures, ns)
+            if texkey is None:
+                continue
+            corners = _box_corners(bounds, tier)
+            uvs = _face_uvs(face, tier, corners)
+            if uvs is None:
+                continue
+            if double or not shaded:
+                shade: int = TIER_UP
+            else:
+                shade = _FACE_TIER[_rotate(face_name, x_rot, y_rot)]
+            if rotation is not None:
+                axis, angle, origin, factor = rotation
+                corners = [
+                    _rotate_element_point(corner, axis, angle, origin, factor)
+                    for corner in corners
+                ]
+            cullface = face.get("cullface")
+            # A non-string cullface drops the face's cull, not the block.
+            cull = (
+                _FACE_TIER[_rotate(cullface, x_rot, y_rot)]
+                if isinstance(cullface, str) and cullface in _VEC
+                else CULL_NONE
+            )
+            # Vanilla bakes UV compensation only for uvlock variants.
+            turns = _UV_BAKE[(kx, ky)][tier] if uvlock else 0
+            uvs = [_bake_vertex_uv(uv, turns) for uv in uvs]
+            rows.append(
+                (_rotate_corners(corners, kx, ky), uvs, texkey, shade, double, cull)
+            )
+    if not rows:
+        return None
+    quads = np.empty(len(rows), dtype=QUAD_DTYPE)
+    for index, (corners, uvs, texkey, shade, dbl, cull) in enumerate(rows):
+        quads[index] = (corners, uvs, texkey, shade, dbl, cull)
+    keep = is_parallelogram(quads)
+    if not keep.any():
+        return None
+    return quads[keep]
+
+
+
+def _thin_axes(
+    bounds: tuple[float, float, float, float, float, float],
+) -> list[int]:
+    """Indices of the axes where from equals to (zero-thickness planes)."""
+    x0, y0, z0, x1, y1, z1 = bounds
+    sizes = (x1 - x0, y1 - y0, z1 - z0)
+    return [axis for axis, size in enumerate(sizes) if size == 0.0]
+
+
+
+def _element_rotation(
+    element: dict[str, Any],
+) -> tuple[int, float, tuple[float, float, float], float] | None:
+    """Parse rotation into (axis, angle, origin, rescale factor) or None."""
+    rot = element.get("rotation")
+    if rot is None:
+        return None
+    if not isinstance(rot, dict):
+        raise ValueError("element rotation must be a mapping")
+    axis = _ROT_AXIS.get(rot.get("axis", "y"))
+    if axis is None:
+        raise ValueError("element rotation has an unknown axis")
+    angle = rot.get("angle", 0.0)
+    if isinstance(angle, bool) or not isinstance(angle, (int, float)):
+        raise ValueError("element rotation angle must be a number")
+    angle = float(angle)
+    if not -45.0 <= angle <= 45.0 or angle % 22.5 != 0.0:
+        raise ValueError("element rotation angle out of the vanilla set")
+    origin = rot.get("origin", (8.0, 8.0, 8.0))
+    if not isinstance(origin, (list, tuple)) or len(origin) != 3:
+        raise ValueError("element rotation origin must be three numbers")
+    try:
+        point = tuple(float(value) for value in origin)
+    except (TypeError, ValueError, OverflowError) as exc:
+        raise ValueError("element rotation origin must be three numbers") from exc
+    if not all(math.isfinite(value) for value in point):
+        raise ValueError("element rotation origin must be finite")
+    rescale = bool(rot.get("rescale", False))
+    factor = _RESCALE_FACTORS.get(abs(angle), 1.0) if rescale else 1.0
+    return (axis, angle, cast("tuple[float, float, float]", point), factor)
+
+
+
+def _rotate_element_point(
+    point: tuple[float, float, float],
+    axis: int,
+    angle: float,
+    origin: tuple[float, float, float],
+    factor: float,
+) -> tuple[float, float, float]:
+    """Rotate one point by angle about the axis through origin, rescaled."""
+    rel = [point[i] - origin[i] for i in range(3)]
+    rad = math.radians(angle)
+    cos, sin = math.cos(rad), math.sin(rad)
+    if axis == 0:
+        rel[1], rel[2] = rel[1] * cos - rel[2] * sin, rel[1] * sin + rel[2] * cos
+    elif axis == 1:
+        rel[0], rel[2] = rel[0] * cos + rel[2] * sin, -rel[0] * sin + rel[2] * cos
+    else:
+        rel[0], rel[1] = rel[0] * cos - rel[1] * sin, rel[0] * sin + rel[1] * cos
+    if factor != 1.0:
+        for i in range(3):
+            if i != axis:
+                rel[i] *= factor
+    return (rel[0] + origin[0], rel[1] + origin[1], rel[2] + origin[2])
+
+
+
+def _element_bounds(
+    element: dict[str, Any],
+) -> tuple[float, float, float, float, float, float] | None:
+    """Parse from/to into six finite floats, or None when malformed."""
+    frm = element.get("from")
+    to = element.get("to")
+    if not isinstance(frm, (list, tuple)) or not isinstance(to, (list, tuple)):
+        return None
+    if len(frm) != 3 or len(to) != 3:
+        return None
+    try:
+        values = tuple(float(value) for value in (*frm, *to))
+    except (TypeError, ValueError, OverflowError):
+        return None
+    if not all(math.isfinite(value) for value in values):
+        return None
+    return cast("tuple[float, float, float, float, float, float]", values)
+
+
+
+def _box_corners(
+    bounds: tuple[float, float, float, float, float, float], tier: int
+) -> list[tuple[float, float, float]]:
+    """Scale the pinned unit-cube corners of one tier onto an element box."""
+    x0, y0, z0, x1, y1, z1 = bounds
+    axis = ((x0, x1), (y0, y1), (z0, z1))
+    return [
+        (axis[0][corner[0] // 16], axis[1][corner[1] // 16], axis[2][corner[2] // 16])
+        for corner in _FACE_GEOM[tier]
+    ]
+
+
+
+def _face_uvs(
+    face: dict[str, Any], tier: int, corners: list[tuple[float, float, float]]
+) -> list[tuple[float, float]] | None:
+    """Resolve per-corner texel coords per the vanilla vertex tables."""
+    rect = face.get("uv")
+    if rect is None:
+        rect = _default_face_uv(tier, corners)
+    else:
+        if not isinstance(rect, (list, tuple)) or len(rect) != 4:
+            return None
+        try:
+            rect = (float(rect[0]), float(rect[1]), float(rect[2]), float(rect[3]))
+        except (TypeError, ValueError, OverflowError):
+            return None
+        if not all(math.isfinite(value) for value in rect):
+            return None
+        if min(rect) < 0.0 or max(rect) > 16.0:
+            return None
+    rotation = face.get("rotation")
+    shift = 0
+    if rotation is not None:
+        if isinstance(rotation, bool) or not isinstance(rotation, (int, float)):
+            return None
+        if rotation not in (0, 90, 180, 270):
+            return None
+        shift = int(rotation) // 90
+    u1, v1, u2, v2 = rect
+    corner_uv = ((u1, v1), (u1, v2), (u2, v2), (u2, v1))
+    return [
+        corner_uv[(vertex + shift) % 4]
+        for vertex in _VANILLA_VERTEX[tier]
+    ]
+
+
+
+_VANILLA_VERTEX = {
+    TIER_DOWN: (0, 3, 2, 1),
+    TIER_UP: (0, 3, 2, 1),
+    TIER_NORTH: (0, 3, 2, 1),
+    TIER_SOUTH: (0, 3, 2, 1),
+    TIER_WEST: (3, 0, 1, 2),
+    TIER_EAST: (3, 0, 1, 2),
+}
+
+
+
+_UV_BAKE = {
+    (0, 0): (0, 0, 0, 0, 0, 0),
+    (0, 1): (3, 1, 0, 0, 0, 0),
+    (0, 2): (2, 2, 0, 0, 0, 0),
+    (0, 3): (1, 3, 0, 0, 0, 0),
+    (1, 0): (0, 2, 2, 0, 3, 1),
+    (1, 1): (0, 2, 1, 1, 3, 1),
+    (1, 2): (0, 2, 0, 2, 3, 1),
+    (1, 3): (0, 2, 3, 3, 3, 1),
+    (2, 0): (0, 0, 2, 2, 2, 2),
+    (2, 1): (3, 1, 2, 2, 2, 2),
+    (2, 2): (2, 2, 2, 2, 2, 2),
+    (2, 3): (1, 3, 2, 2, 2, 2),
+    (3, 0): (2, 0, 2, 0, 1, 3),
+    (3, 1): (2, 0, 3, 3, 1, 3),
+    (3, 2): (2, 0, 0, 2, 1, 3),
+    (3, 3): (2, 0, 1, 1, 1, 3),
+}
+
+
+def _bake_vertex_uv(uv: tuple[float, float], turns: int) -> tuple[float, float]:
+    """Rotate one texel coord around the tile center by quarter-turns."""
+    if turns == 0:
+        return uv
+    u, v = uv
+    if turns == 1:
+        return (16.0 - v, u)
+    if turns == 2:
+        return (16.0 - u, 16.0 - v)
+    return (v, 16.0 - u)
+
+
+def _default_face_uv(
+    tier: int, corners: list[tuple[float, float, float]]
+) -> tuple[float, float, float, float]:
+    """Vanilla defaultFaceUV extents for one tier from the element corners."""
+    xs = [corner[0] for corner in corners]
+    ys = [corner[1] for corner in corners]
+    zs = [corner[2] for corner in corners]
+    x0, x1 = min(xs), max(xs)
+    y0, y1 = min(ys), max(ys)
+    z0, z1 = min(zs), max(zs)
+    if tier == TIER_DOWN:
+        return (x0, 16.0 - z1, x1, 16.0 - z0)
+    if tier == TIER_UP:
+        return (x0, z0, x1, z1)
+    if tier == TIER_NORTH:
+        return (16.0 - x1, 16.0 - y1, 16.0 - x0, 16.0 - y0)
+    if tier == TIER_SOUTH:
+        return (x0, 16.0 - y1, x1, 16.0 - y0)
+    if tier == TIER_WEST:
+        return (z0, 16.0 - y1, z1, 16.0 - y0)
+    return (16.0 - z1, 16.0 - y1, 16.0 - z0, 16.0 - y0)
+
+
+
+def _rot_x_point(point: tuple[float, float, float]) -> tuple[float, float, float]:
+    """Rotate one block-space point 90 degrees around the x axis."""
+    return (point[0], point[2], 16.0 - point[1])
+
+
+
+def _rot_y_point(point: tuple[float, float, float]) -> tuple[float, float, float]:
+    """Rotate one block-space point 90 degrees around the y axis."""
+    return (16.0 - point[2], point[1], point[0])
+
+
+
+def _rotate_corners(
+    corners: list[tuple[float, float, float]], kx: int, ky: int
+) -> list[tuple[float, float, float]]:
+    """Apply x then y blockstate rotation steps to all four corners."""
+    out = corners
+    for _ in range(kx):
+        out = [_rot_x_point(point) for point in out]
+    for _ in range(ky):
+        out = [_rot_y_point(point) for point in out]
+    return out

litematic/render/pack/entities.py

@@ -0,0 +1,181 @@
+"""Block-entity-shaped blocks: chests compiled from entity textures."""
+
+import numpy as np
+
+from litematic.render.pack.blockstate import _state_pairs
+from litematic.render.quads import (
+    CULL_NONE,
+    QUAD_DTYPE,
+    TIER_DOWN,
+    TIER_EAST,
+    TIER_NORTH,
+    TIER_SOUTH,
+    TIER_UP,
+    TIER_WEST,
+)
+
+_CHEST_BASES = {
+    "chest": "normal",
+    "trapped_chest": "trapped",
+    "ender_chest": "ender",
+    "copper_chest": "copper",
+    "waxed_copper_chest": "copper",
+    "exposed_copper_chest": "copper_exposed",
+    "waxed_exposed_copper_chest": "copper_exposed",
+    "weathered_copper_chest": "copper_weathered",
+    "waxed_weathered_copper_chest": "copper_weathered",
+    "oxidized_copper_chest": "copper_oxidized",
+    "waxed_oxidized_copper_chest": "copper_oxidized",
+}
+# The model's front is +Z (south); the rotation turns it to the facing.
+_FACING_ROTATION = {"south": 0, "east": 90, "north": 180, "west": 270}
+_COS_SIN = {0: (1, 0), 90: (0, 1), 180: (-1, 0), 270: (0, -1)}
+
+_TIER_OF_NORMAL = {
+    (0, 1, 0): TIER_UP,
+    (0, -1, 0): TIER_DOWN,
+    (0, 0, -1): TIER_NORTH,
+    (0, 0, 1): TIER_SOUTH,
+    (-1, 0, 0): TIER_WEST,
+    (1, 0, 0): TIER_EAST,
+}
+
+
+def chest_quads(
+    block_id: str,
+    state_key: str,
+    resolve_texture,
+) -> np.ndarray | None:
+    """Compile one closed chest from entity textures, or None if uncovered.
+
+    `resolve_texture` maps an entity texture ref (entity/chest/...) to a
+    registered texkey, returning None when the pack lacks the file.
+    """
+    stem = block_id.partition(":")[2]
+    base = _CHEST_BASES.get(stem)
+    if base is None:
+        return None
+    properties = _state_pairs(state_key)
+    kind = properties.get("type", "single")
+    if kind not in ("single", "left", "right"):
+        return None
+    texkey = resolve_texture(_chest_texture_ref(base, kind))
+    if texkey is None:
+        return None
+    degrees = _FACING_ROTATION.get(properties.get("facing", "north"), 180)
+
+    faces: list[tuple[list, list, tuple[int, int, int], str]] = []
+    if kind == "single":
+        _add_box(faces, (1, 0, 1), (15, 10, 15), (0, 19), texkey)
+        _add_box(faces, (1, 9, 1), (15, 14, 15), (0, 0), texkey)
+        _add_box(faces, (7, 7, 15), (9, 11, 16), (0, 0), texkey)
+    else:
+        x1, x2 = (0, 15) if kind == "left" else (1, 16)
+        _add_box(faces, (x1, 0, 1), (x2, 10, 15), (0, 19), texkey)
+        _add_box(faces, (x1, 9, 1), (x2, 14, 15), (0, 0), texkey)
+        lock_x = 0 if kind == "left" else 15
+        _add_box(faces, (lock_x, 7, 15), (lock_x + 1, 11, 16), (0, 0), texkey)
+
+    quads = np.empty(len(faces), dtype=QUAD_DTYPE)
+    for index, (vertices, uvs, normal, face_texkey) in enumerate(faces):
+        rotated = [_rotate_y(point, degrees) for point in vertices]
+        quads[index] = (
+            rotated,
+            [(u / 4.0, v / 4.0) for (u, v) in uvs],
+            face_texkey,
+            _TIER_OF_NORMAL[_rotate_normal(normal, degrees)],
+            False,
+            CULL_NONE,
+        )
+    return quads
+
+
+def _chest_texture_ref(base: str, kind: str) -> str:
+    if kind in ("left", "right"):
+        return f"entity/chest/{base}_{kind}"
+    return f"entity/chest/{base}"
+
+
+def _add_box(
+    faces: list,
+    frm: tuple[int, int, int],
+    to: tuple[int, int, int],
+    origin: tuple[int, int],
+    texkey: str,
+) -> None:
+    """Append one box's six faces in entity-unwrap order and UV layout."""
+    x1, y1, z1 = frm
+    x2, y2, z2 = to
+    width, height, depth = x2 - x1, y2 - y1, z2 - z1
+    u, v = origin
+    x1f, y1f, z1f, x2f, y2f, z2f = (
+        float(x1), float(y1), float(z1), float(x2), float(y2), float(z2)
+    )
+    uf, vf, wf, hf, df = (
+        float(u), float(v), float(width), float(height), float(depth)
+    )
+    faces.extend([
+        (
+            [(x1f, y1f, z2f), (x1f, y1f, z1f), (x2f, y1f, z1f), (x2f, y1f, z2f)],
+            [(uf + df, vf), (uf + df, vf + df),
+             (uf + df + wf, vf + df), (uf + df + wf, vf)],
+            (0, -1, 0),
+            texkey,
+        ),
+        (
+            [(x1f, y2f, z1f), (x1f, y2f, z2f), (x2f, y2f, z2f), (x2f, y2f, z1f)],
+            [(uf + df + wf, vf + df), (uf + df + wf, vf),
+             (uf + df + 2 * wf, vf), (uf + df + 2 * wf, vf + df)],
+            (0, 1, 0),
+            texkey,
+        ),
+        (
+            [(x1f, y1f, z1f), (x1f, y2f, z1f), (x2f, y2f, z1f), (x2f, y1f, z1f)],
+            [(uf + df, vf + df), (uf + df, vf + df + hf),
+             (uf + df + wf, vf + df + hf), (uf + df + wf, vf + df)],
+            (0, 0, -1),
+            texkey,
+        ),
+        (
+            [(x2f, y1f, z2f), (x2f, y2f, z2f), (x1f, y2f, z2f), (x1f, y1f, z2f)],
+            [(uf + df + wf + df, vf + df), (uf + df + wf + df, vf + df + hf),
+             (uf + df + 2 * wf + df, vf + df + hf),
+             (uf + df + 2 * wf + df, vf + df)],
+            (0, 0, 1),
+            texkey,
+        ),
+        (
+            [(x1f, y1f, z2f), (x1f, y2f, z2f), (x1f, y2f, z1f), (x1f, y1f, z1f)],
+            [(uf, vf + df), (uf, vf + df + hf),
+             (uf + df, vf + df + hf), (uf + df, vf + df)],
+            (-1, 0, 0),
+            texkey,
+        ),
+        (
+            [(x2f, y1f, z1f), (x2f, y2f, z1f), (x2f, y2f, z2f), (x2f, y1f, z2f)],
+            [(uf + df + wf, vf + df), (uf + df + wf, vf + df + hf),
+             (uf + df + wf + df, vf + df + hf), (uf + df + wf + df, vf + df)],
+            (1, 0, 0),
+            texkey,
+        ),
+    ])
+
+
+def _rotate_y(
+    point: tuple[float, float, float], degrees: int
+) -> tuple[float, float, float]:
+    """Rotate one block-space point about the y axis through (8, *, 8)."""
+    cos, sin = _COS_SIN[degrees]
+    x, y, z = point[0] - 8.0, point[1], point[2] - 8.0
+    return (x * cos + z * sin + 8.0, y, -x * sin + z * cos + 8.0)
+
+
+def _rotate_normal(
+    normal: tuple[int, int, int], degrees: int
+) -> tuple[int, int, int]:
+    cos, sin = _COS_SIN[degrees]
+    return (
+        round(normal[0] * cos + normal[2] * sin),
+        normal[1],
+        round(-normal[0] * sin + normal[2] * cos),
+    )