unitytk 0.0.10__tar.gz → 0.0.11__tar.gz

{unitytk-0.0.10/unitytk.egg-info → unitytk-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitytk
-Version: 0.0.10
+Version: 0.0.11
 Summary: A modular Python toolkit for Unity interaction.
 Author-email: Ryan Simpson <m3trik@outlook.com>
 License: MIT

{unitytk-0.0.10 → unitytk-0.0.11}/test/test_render_effects_e2e.py

@@ -79,8 +79,12 @@ cube = cmds.polyCube(name="glow")[0]
 
 # Opacity: a fade-in over 1..20 (mirrors visibility as before).
 RenderEffects.key_fade([cube], start=1, end=20, direction="in")
-# Highlight: 60-frame period, bright 50%, ramps 25% each -> bright hold 1..16,
-# ramp to 0 at 31, dim hold to 46, ramp to 1 at 61, ... cut at 120.
+# Highlight: 60-frame period, bright 50%, ramps 25% each. The train is
+# BRACKETED by dim keys at start and end (mayatk 2026-09-05: Maya holds a
+# curve's first value back to the start of time, so a pulse that merely began
+# bright glowed for the whole timeline before it), and the default lead-in is
+# the cycle's own 15-frame ramp -> dim at 1, bright 16..31, dim 46..61,
+# bright 76..91, back to dim at 120.
 RenderEffects.key_pulse(
     [cube], start=1, end=120, period=60, bright_fraction=0.5,
     ramp_fraction=0.25, color=(0.2, 0.5, 1.0),
@@ -391,16 +395,19 @@ class TestRenderEffectsE2E(unittest.TestCase):
         got = [float(c) for c in unity["highlight_colors"][0].split(",")]
         for value, want in zip(got, (0.2, 0.5, 1.0)):
             self.assertAlmostEqual(value, want, delta=1 / 255)
-        # (e) The pulse shape survived: bright holds 1, dim holds 0.
+        # (e) The pulse shape survived: bright holds 1, dim holds 0, and the
+        # DIM BRACKET at `start` is there (mayatk 2026-09-05 -- the ramp opens
+        # at 0, not 1). Measured against the authored curve in mayapy for these
+        # exact fixture params: 1->0, 16->1, 31->1, 46->0, 61->0, 76->1, 91->1.
         samples = {
             int(s.split("|")[0]): float(s.split("|")[1])
             for s in unity["highlight_samples"]
         }
-        self.assertAlmostEqual(samples[1], 1.0, places=2)
+        self.assertAlmostEqual(samples[1], 0.0, places=2)
         self.assertAlmostEqual(samples[16], 1.0, places=2)
-        self.assertAlmostEqual(samples[31], 0.0, places=2)
+        self.assertAlmostEqual(samples[31], 1.0, places=2)
         self.assertAlmostEqual(samples[46], 0.0, places=2)
-        self.assertAlmostEqual(samples[61], 1.0, places=2)
+        self.assertAlmostEqual(samples[61], 0.0, places=2)
         # (f) Emission keyword on the highlighted material.
         self.assertTrue(unity["emission_keyword"], "no material inspected")
         self.assertTrue(

{unitytk-0.0.10 → unitytk-0.0.11}/test/test_shadow_plane_runtime_integration.py

@@ -8,7 +8,7 @@ Unity and no DCC:
 
     1. Create a Unity project, deploy the real package (controller + shader)
        and copy two generated fixtures into Assets: a stripe silhouette
-       (``Fixture_shadow.png``) and an analytic two-layer horizon map
+       (``Fixture_shadow.png``) and a baked height-field map
        (``Fixture_horizon.png``: a grounded pole and a floating disc, baked
        in numpy per the contract's encoding).
     2. An editor script builds a unit-quad plane on ``m3trik/ShadowPlane`` with
@@ -124,46 +124,33 @@ class StripeSilhouette:
 
 
 class HorizonFixture:
-    """An analytic two-layer horizon map and the numpy oracle that samples it.
-
-    Layer 0 (grounded, tile ``k``): two thin vertical poles — the first at
-    local ``(0.5, 0.3)``, off-centre on purpose so a flipped bearing axis or
-    a swapped frame vector moves its shadow and fails the pixel comparison;
-    the second shares a bin with it from many texels, so the map carries two
-    RUNS of set sub-bins there and the shader's run >= 2 (``G``) path is
-    exercised. Layer 1 (floating, tile ``bins + k``): a horizontal disc
-    hovering between two heights.
-
-    Encoding per the contract: ``B``/``A`` a 16-bit occupancy mask over the
-    bin's 16 sub-bins (``B`` bit ``i`` = sub-bin ``i``, ``A`` bit ``i`` =
-    sub-bin ``8 + i``; all zero = empty); ``R``/``G`` cotangents, ``value =
-    cot(angle) / max_stretch`` clamped to ``[0, 1]`` (0 = zenith). Floating:
-    ``R = cot(lo)``, ``G = cot(hi)``. Grounded: ``R = cot(hi)`` of the FIRST
-    run of set sub-bins, ``G = cot(hi)`` of the later runs (0 with one run);
-    ``lo`` is the cap.
+    """Two poles and a floating slab, baked by pythontk's own bake into the
+    height-field map the contract ships, and the oracle that samples it.
+
+    The first pole stands at local ``(0.5, 0.3)``, off-centre on purpose so a
+    flipped bearing axis or a swapped frame vector moves its shadow and fails
+    the pixel comparison; the second stands beside the first's light ray. The
+    slab hovers between two heights over open ground, so a ray under it must
+    pass and one through it must block -- the span a plain height field
+    cannot hold.
+
+    There was an analytic map here, and before it a numpy transcription of
+    the HLSL; both pinned the shader to something other than the one oracle
+    every consumer answers to. The map is now the real bake, and ``alpha`` is
+    ``HeightFieldMap.alpha`` decoding the very bytes the PNG holds (the map's
+    PNG round trip is exact).
     """
 
-    BINS = 6
-    LAYERS = 2
-    SUB_BINS = 16
-    TILE_W = 64
-    TILE_H = 32
-    R_MIN = 0.35
-    R_MAX = 3.0
-    #: The cot scale the map is BAKED with — deliberately NOT the record's
-    #: top-level ``max_stretch`` (the plane's live, keyable placement cap,
-    #: which an artist can retune after a bake). Decoding with the wrong one
-    #: scales every shadow length by the ratio, so the two differing here is
-    #: what makes the pixel comparison able to tell them apart.
-    MAX_STRETCH = 4.0
-    #: Grounded poles: (base (x, z), radius, height). The first is the one
-    #: the centroid check isolates; the second sits beside the first's light
-    #: ray, so from texels behind it the first pole holds a lower sub-bin of
-    #: the same bin with a gap between — two runs.
+    SIZE = 64
+    SPANS = 2
+    #: One fixed footprint for every variant (a pole alone, no slab), so the
+    #: texture layout and the frame never change between them.
+    BOUNDS = (-0.5, 2.5, -0.5, 2.0)
+    #: Grounded poles: (base (x, z), half-width, height) -- square posts.
     POLES = (((0.5, 0.3), 0.06, 1.2), ((0.214, 1.028), 0.05, 0.8))
     POLE = POLES[0][0]
-    #: The floating disc: centre (x, z), radius, underside and top heights —
-    #: placed so its shadow clears the first pole's shadow line.
+    #: The floating slab: centre (x, z), half-width, underside and top heights
+    #: -- placed so its shadow clears the first pole's shadow line.
     DISC = (1.5, 0.9)
     DISC_RADIUS = 0.5
     DISC_LO = 0.7
@@ -172,178 +159,73 @@ class HorizonFixture:
     FRAME_A = (1.0, 0.0, 0.0)
     FRAME_B = (0.0, 0.0, 1.0)
 
-    @classmethod
-    def cols(cls) -> int:
-        return int(math.ceil(math.sqrt(cls.LAYERS * cls.BINS)))
-
-    @classmethod
-    def rows(cls) -> int:
-        return int(math.ceil(cls.LAYERS * cls.BINS / cls.cols()))
-
-    # ---------------------------------------------------------------- bake
-    @classmethod
-    def _mask(cls, phi_lo, phi_hi, k, step):
-        """Bin ``k``'s 16-bit sub-bin occupancy of the (possibly wrapping)
-        interval ``[phi_lo, phi_hi]`` (arrays): a sub-bin is set when the
-        interval overlaps it."""
-        mask = np.zeros(phi_lo.shape, dtype=np.int64)
-        sub = step / cls.SUB_BINS
-        for j in range(cls.SUB_BINS):
-            s0 = k * step + j * sub
-            s1 = s0 + sub
-            hit = np.zeros(phi_lo.shape, dtype=bool)
-            for shift in (-TWO_PI, 0.0, TWO_PI):
-                hit |= (
-                    np.minimum(s1, phi_hi + shift) - np.maximum(s0, phi_lo + shift)
-                ) > 1e-12
-            mask |= np.where(hit, 1 << j, 0)
-        return mask
-
-    @classmethod
-    def _first_bit(cls, mask):
-        """Lowest set bit per texel (-1 when empty)."""
-        out = np.full(mask.shape, -1, dtype=int)
-        for j in range(cls.SUB_BINS - 1, -1, -1):
-            out = np.where(((mask >> j) & 1) == 1, j, out)
-        return out
-
-    @classmethod
-    def _run_at(cls, mask, bit):
-        """Number of 0->1 transitions in ``mask`` up to ``bit`` (inclusive) —
-        the run index of that bit (0 where ``bit`` < 0)."""
-        count = np.zeros(mask.shape, dtype=int)
-        prev = np.zeros(mask.shape, dtype=int)
-        for j in range(cls.SUB_BINS):
-            b = (mask >> j) & 1
-            count += ((b == 1) & (prev == 0) & (j <= bit)).astype(int)
-            prev = b
-        return count
+    @staticmethod
+    def _box(x0, x1, y0, y1, z0, z1):
+        pts = np.array(
+            [[x, y, z] for x in (x0, x1) for y in (y0, y1) for z in (z0, z1)],
+            dtype=float,
+        )
+        quads = [
+            (0, 1, 3, 2),
+            (4, 6, 7, 5),
+            (0, 4, 5, 1),
+            (2, 3, 7, 6),
+            (0, 2, 6, 4),
+            (1, 5, 7, 3),
+        ]
+        tris = []
+        for a, b, c, d in quads:
+            tris += [(a, b, c), (a, c, d)]
+        return pts, np.array(tris, dtype=np.int64)
 
     @classmethod
-    def bake(cls, poles=None, disc=True) -> np.ndarray:
-        """The map as an ``(rows*TILE_H, cols*TILE_W, 4)`` uint8 array,
-        row 0 at the top (PNG order). ``poles`` overrides the grounded set
-        and ``disc=False`` omits the floating layer (the centroid check
-        bakes the first pole alone)."""
+    def meshes(cls, poles=None, disc=True):
         poles = cls.POLES if poles is None else poles
-        ms = cls.MAX_STRETCH
-        cols, rows = cls.cols(), cls.rows()
-        img = np.zeros((rows * cls.TILE_H, cols * cls.TILE_W, 4), dtype=np.uint8)
-        step = TWO_PI / cls.BINS
-        theta = (np.arange(cls.TILE_W) + 0.5) * TWO_PI / cls.TILE_W  # (W,)
-        v = (np.arange(cls.TILE_H) + 0.5) / cls.TILE_H  # (H,) top = r_min
-        r = cls.R_MIN * (cls.R_MAX / cls.R_MIN) ** v  # (H,)
-        px = r[:, None] * np.cos(theta)[None, :]  # along frame a
-        pz = r[:, None] * np.sin(theta)[None, :]  # along frame b
-
-        def q(a):
-            """Quantise a [0, 1] channel the way the contract's encoding does."""
-            return np.clip(np.round(np.clip(a, 0.0, 1.0) * 255.0), 0, 255).astype(
-                np.uint8
+        parts = [
+            cls._box(bx - r, bx + r, 0.0, h, bz - r, bz + r) for (bx, bz), r, h in poles
+        ]
+        if disc:
+            cx, cz = cls.DISC
+            r = cls.DISC_RADIUS
+            parts.append(
+                cls._box(cx - r, cx + r, cls.DISC_LO, cls.DISC_HI, cz - r, cz + r)
             )
+        return parts
 
-        def place(layer, k, tile):
-            t = layer * cls.BINS + k
-            col, row = t % cols, t // cols
-            img[
-                row * cls.TILE_H : (row + 1) * cls.TILE_H,
-                col * cls.TILE_W : (col + 1) * cls.TILE_W,
-            ] = tile
-
-        # ---- grounded: the poles, encoded by run ----
-        per_pole = []
-        for base, rad, height in poles:
-            dx, dz = base[0] - px, base[1] - pz
-            d = np.hypot(dx, dz)
-            delta = np.arcsin(np.minimum(1.0, rad / np.maximum(d, 1e-9)))
-            phi_c = np.mod(np.arctan2(dz, dx), TWO_PI)
-            cot_hi = np.maximum(d - rad, 1e-3) / height  # cot(atan(H / (d - rad)))
-            per_pole.append((phi_c - delta, phi_c + delta, cot_hi))
-        for k in range(cls.BINS):
-            masks = [cls._mask(lo, hi, k, step) for lo, hi, _ in per_pole]
-            union = np.zeros(px.shape, dtype=np.int64)
-            for m in masks:
-                union |= m
-            first = np.full(px.shape, np.inf)
-            later = np.full(px.shape, np.inf)
-            for m, (_, _, cot_hi) in zip(masks, per_pole):
-                run = cls._run_at(union, cls._first_bit(m))
-                first = np.where(
-                    (m != 0) & (run == 1), np.minimum(first, cot_hi), first
-                )
-                later = np.where(
-                    (m != 0) & (run >= 2), np.minimum(later, cot_hi), later
-                )
-            tile = np.zeros((cls.TILE_H, cls.TILE_W, 4), dtype=np.uint8)
-            hit = union != 0
-            tile[..., 0] = np.where(
-                hit & np.isfinite(first),
-                q(np.where(np.isfinite(first), first, 0) / ms),
-                0,
-            )
-            tile[..., 1] = np.where(
-                hit & np.isfinite(later),
-                q(np.where(np.isfinite(later), later, 0) / ms),
-                0,
-            )
-            tile[..., 2] = (union & 0xFF).astype(np.uint8)
-            tile[..., 3] = ((union >> 8) & 0xFF).astype(np.uint8)
-            place(0, k, tile)
-
-        # ---- floating: the disc ----
-        if not disc:
-            return img
-        dx, dz = cls.DISC[0] - px, cls.DISC[1] - pz
-        d = np.hypot(dx, dz)
-        inside = d < cls.DISC_RADIUS
-        delta = np.where(
-            inside,
-            math.pi,
-            np.arcsin(np.minimum(1.0, cls.DISC_RADIUS / np.maximum(d, 1e-9))),
-        )
-        phi_c = np.mod(np.arctan2(dz, dx), TWO_PI)
-        cot_lo = (d + cls.DISC_RADIUS) / cls.DISC_LO
-        cot_hi = np.where(
-            inside, 0.0, np.maximum(d - cls.DISC_RADIUS, 0.0) / cls.DISC_HI
+    @classmethod
+    def map(cls, poles=None, disc=True) -> "ptk.HeightFieldMap":
+        """The baked map -- the reference itself."""
+        return ptk.ShadowHorizon.bake(
+            cls.meshes(poles, disc),
+            up=1,
+            size=cls.SIZE,
+            spans=cls.SPANS,
+            bounds=cls.BOUNDS,
         )
-        for k in range(cls.BINS):
-            mask = cls._mask(phi_c - delta, phi_c + delta, k, step)
-            hit = mask != 0
-            tile = np.zeros((cls.TILE_H, cls.TILE_W, 4), dtype=np.uint8)
-            tile[..., 0] = np.where(hit, q(cot_lo / ms), 0)
-            tile[..., 1] = np.where(hit, q(cot_hi / ms), 0)
-            tile[..., 2] = (mask & 0xFF).astype(np.uint8)
-            tile[..., 3] = ((mask >> 8) & 0xFF).astype(np.uint8)
-            place(1, k, tile)
-        return img
 
-    # -------------------------------------------------------------- oracle
     @classmethod
-    def map(cls, img=None) -> "ptk.HorizonMap":
-        """The baked image as a `pythontk.HorizonMap` — the reference itself.
-
-        There was a numpy transcription of the HLSL here, and it pinned the
-        shader to a copy of itself: a divergence between them was invisible by
-        construction, and the divergences the doc of record claimed were
-        pinned were exactly the ones neither side could see. The map now goes
-        straight to `HorizonMap.alpha`, which the shared shader body is
-        written against, so the Unity pixels are compared to the one oracle
-        every other consumer answers to.
-        """
-        return ptk.HorizonMap.from_rgba(
-            cls.bake() if img is None else img,
-            bins=cls.BINS,
-            size=(cls.TILE_W, cls.TILE_H),
-            r_min=cls.R_MIN,
-            r_max=cls.R_MAX,
-            max_stretch=cls.MAX_STRETCH,
-        )
+    def bake(cls, poles=None, disc=True) -> np.ndarray:
+        """The map as the ``(S, S x (K + 2), 4)`` uint8 image the contract
+        ships, row 0 at the top (PNG order)."""
+        return cls.map(poles, disc).to_rgba()
 
     @classmethod
-    def alpha(cls, img, points, source, source_size=0.0):
-        """`HorizonMap.alpha` at contact-local ground `points` (N, 3) for a
-        positional `source` (contact-local) of diameter `source_size`."""
-        return cls.map(img).alpha(points, light=source, source_size=source_size)
+    def alpha(cls, points, source, source_size=0.0, *, poles=None, disc=True):
+        """``HeightFieldMap.alpha`` at contact-local ground ``points`` (N, 3)
+        for a positional ``source`` (contact-local) of diameter
+        ``source_size``, decoding the image ``bake`` writes for the same
+        variant."""
+        hmap = cls.map(poles, disc)
+        back = ptk.HeightFieldMap.from_rgba(
+            hmap.to_rgba(),
+            size=cls.SIZE,
+            spans=cls.SPANS,
+            bounds=cls.BOUNDS,
+            ground=0.0,
+            up=1,
+            height_scale=hmap.height_scale,
+        )
+        return back.alpha(points, light=source, source_size=source_size)
 
 
 def _write_png(path: str, img: np.ndarray) -> None:
@@ -613,13 +495,13 @@ __CASES__
         // (c3) horizon: a sizeless source, then a finite one.
         ctrl.rigType = "horizon";
         ctrl.horizonMap = horizon;
-        ctrl.horizonBins = __BINS__;
-        ctrl.horizonLayers = __LAYERS__;
-        ctrl.horizonTile = new Vector2Int(__TILE_W__, __TILE_H__);
-        ctrl.horizonLayout = new Vector2Int(__COLS__, __ROWS__);
-        ctrl.horizonMaxStretch = __H_MAX_STRETCH__f;
-        ctrl.horizonRMin = __R_MIN__f;
-        ctrl.horizonRMax = __R_MAX__f;
+        ctrl.horizonSize = __SIZE__;
+        ctrl.horizonSpans = __SPANS__;
+        ctrl.horizonLevels = __LEVELS__;
+        ctrl.horizonBounds = new Vector4(__BND0__f, __BND1__f, __BND2__f, __BND3__f);
+        ctrl.horizonHeightScale = __HSCALE__f;
+        ctrl.horizonMapping = "heightfield";
+        ctrl.horizonEncoding = 2;
         ctrl.horizonFrameA = new Vector3(__A0__f, __A1__f, __A2__f);
         ctrl.horizonFrameB = new Vector3(__B0__f, __B1__f, __B2__f);
         ctrl.horizonRect = new Vector4(1f, 1f, 0f, 0f);
@@ -634,16 +516,8 @@ __CASES__
         sb.AppendLine("  \"block_axis_b\": " + V4(mpb.GetVector("_AxisB")) + ",");
         sb.AppendLine("  \"block_axis_up\": " + V4(mpb.GetVector("_AxisUp")) + ",");
         sb.AppendLine("  \"block_horizon_params\": " + V4(mpb.GetVector("_HorizonParams")) + ",");
-        sb.AppendLine("  \"block_horizon_range\": " + V4(mpb.GetVector("_HorizonRange")) + ",");
-        sb.AppendLine("  \"block_max_stretch\": " + F(mpb.GetFloat("_MaxStretch")) + ",");
-        // A map baked before the field existed carries no scale (0): the
-        // decode must fall back to the plane's live cap, not to zero.
-        ctrl.horizonMaxStretch = 0f;
-        ctrl.ApplyNow();
-        rend.GetPropertyBlock(mpb);
-        sb.AppendLine("  \"block_max_stretch_absent\": " + F(mpb.GetFloat("_MaxStretch")) + ",");
-        ctrl.horizonMaxStretch = __H_MAX_STRETCH__f;
-        ctrl.ApplyNow();
+        sb.AppendLine("  \"block_horizon_bounds\": " + V4(mpb.GetVector("_HorizonBounds")) + ",");
+        sb.AppendLine("  \"block_horizon_meta\": " + V4(mpb.GetVector("_HorizonMeta")) + ",");
         sb.AppendLine("  \"block_horizon_map_overridden\": "
             + B(mpb.GetTexture("_HorizonMap") != null) + ",");
         sb.AppendLine("  \"block_base_map_overridden\": "
@@ -713,15 +587,14 @@ def _verifier_source(results_path: str) -> str:
         "__HX__": repr(HORIZON_SOURCE[0]),
         "__HY__": repr(HORIZON_SOURCE[1]),
         "__HZ__": repr(HORIZON_SOURCE[2]),
-        "__BINS__": str(hz.BINS),
-        "__LAYERS__": str(hz.LAYERS),
-        "__TILE_W__": str(hz.TILE_W),
-        "__TILE_H__": str(hz.TILE_H),
-        "__COLS__": str(hz.cols()),
-        "__ROWS__": str(hz.rows()),
-        "__R_MIN__": repr(hz.R_MIN),
-        "__R_MAX__": repr(hz.R_MAX),
-        "__H_MAX_STRETCH__": repr(hz.MAX_STRETCH),
+        "__SIZE__": str(hz.SIZE),
+        "__SPANS__": str(hz.SPANS),
+        "__LEVELS__": str(hz.map().levels),
+        "__BND0__": repr(hz.BOUNDS[0]),
+        "__BND1__": repr(hz.BOUNDS[1]),
+        "__BND2__": repr(hz.BOUNDS[2]),
+        "__BND3__": repr(hz.BOUNDS[3]),
+        "__HSCALE__": repr(float(hz.map().height_scale)),
         "__A0__": repr(hz.FRAME_A[0]),
         "__A1__": repr(hz.FRAME_A[1]),
         "__A2__": repr(hz.FRAME_A[2]),
@@ -989,7 +862,7 @@ class TestShadowPlaneRuntimeIntegration(unittest.TestCase):
         hz = HorizonFixture
         self.assertEqual(
             (tex["width"], tex["height"]),
-            (hz.cols() * hz.TILE_W, hz.rows() * hz.TILE_H),
+            (hz.SIZE * (hz.SPANS + 2), hz.SIZE),
             "the NPOT tile grid must keep its exact size",
         )
         self.assertEqual(tex["mip_count"], 1)
@@ -1006,39 +879,17 @@ class TestShadowPlaneRuntimeIntegration(unittest.TestCase):
         self.assertAlmostEqual(unity["block_mode_horizon"], 1.0, places=5)
         params = unity["block_horizon_params"]
         self.assertEqual(
-            [int(v) for v in params], [hz.BINS, hz.TILE_W, hz.TILE_H, hz.cols()]
-        )
-        # (r_min, r_max) arrive in SCENE units -- the shared body takes no
-        # unit slot, so the controller scales them; layers and the ground
-        # plane's height in the frame take the other two.
-        rng = unity["block_horizon_range"]
-        self.assertAlmostEqual(rng[0], hz.R_MIN, places=5)
-        self.assertAlmostEqual(rng[1], hz.R_MAX, places=5)
-        self.assertEqual(int(rng[2]), hz.LAYERS)
-        self.assertAlmostEqual(rng[3], RECORD["ground"], places=5)
-        # The cotangent decode takes the scale the MAP was baked with, never
-        # the plane's live placement cap (they differ in this fixture).
-        self.assertAlmostEqual(
-            unity["block_max_stretch"],
-            hz.MAX_STRETCH,
-            places=5,
-            msg="the shader decodes with the wrong cot scale — a "
-            "retuned maxStretch would rescale every shadow length",
-        )
-        self.assertNotAlmostEqual(
-            hz.MAX_STRETCH,
-            RECORD["max_stretch"],
-            places=5,
-            msg="the fixture can no longer tell the two apart",
-        )
-        # ...and falls back to the live cap only when the record carried none.
-        self.assertAlmostEqual(
-            unity["block_max_stretch_absent"],
-            RECORD["max_stretch"],
-            places=5,
-            msg="a map with no baked scale must fall back to the "
-            "plane's cap, not to zero",
+            [int(v) for v in params], [hz.SIZE, hz.SPANS, hz.map().levels, 0]
         )
+        # The footprint and the height scale arrive in SCENE units -- the
+        # shared body takes no unit slot, so the controller scales them; the
+        # ground plane's height in the frame rides in the meta vector.
+        bounds = unity["block_horizon_bounds"]
+        for got, want in zip(bounds, hz.BOUNDS):
+            self.assertAlmostEqual(got, want, places=5)
+        meta = unity["block_horizon_meta"]
+        self.assertAlmostEqual(meta[0], hz.map().height_scale, places=5)
+        self.assertAlmostEqual(meta[1], RECORD["ground"], places=5)
         # The frame travels as an origin and three WORLD axes; the source
         # travels in world space too. The fixture's contact is the identity,
         # so each is its own contact-local value.
@@ -1109,19 +960,18 @@ class TestShadowPlaneRuntimeIntegration(unittest.TestCase):
 
     @EnvSkip.unless(_unity_available(), "no Unity editor found")
     def test_05_horizon_pixels_match_oracle(self):
-        """Shader alpha == the contract's math on the same PNG (two layers,
-        sizeless and finite sources), and the pole's shadow lies on the far
-        side of the light."""
+        """Shader alpha == the contract's math on the same PNG (a sizeless
+        and a finite source), and the pole's shadow lies on the far side of
+        the light."""
         unity = self._pixels_or_skip()
         self.assertLessEqual(unity["h1_max_rg"], 2, "not a grey shadow (error shader?)")
-        img = self.__class__.horizon_img
         xs, zs = _pixel_grid(unity)
         points = np.column_stack([xs, np.zeros_like(xs), zs])
 
         for key, size in (("h1", 0.0), ("h2", HORIZON_SOURCE_SIZE)):
             got = _alpha(unity, f"{key}_r")
             inside, _ = _inside_plane(unity[f"{key}_placement"], xs, zs)
-            expected = HorizonFixture.alpha(img, points, HORIZON_SOURCE, size)
+            expected = HorizonFixture.alpha(points, HORIZON_SOURCE, size)
             expected = np.where(inside, expected, 0.0)
             n = int(inside.sum())
             self.assertGreater(n, 200, f"{key}: the plane must cover pixels")
@@ -1164,12 +1014,9 @@ class TestShadowPlaneRuntimeIntegration(unittest.TestCase):
         # minus a pole-1-only bake leaves the disc's and the second pole's
         # shadows, which are masked out of the centroid.
         only1 = HorizonFixture.alpha(
-            HorizonFixture.bake(HorizonFixture.POLES[:1], disc=False),
-            points,
-            HORIZON_SOURCE,
-            0.0,
+            points, HORIZON_SOURCE, 0.0, poles=HorizonFixture.POLES[:1], disc=False
         )
-        full = HorizonFixture.alpha(img, points, HORIZON_SOURCE, 0.0)
+        full = HorizonFixture.alpha(points, HORIZON_SOURCE, 0.0)
         inside1, _ = _inside_plane(unity["h1_placement"], xs, zs)
         w = np.where(inside1 & (np.abs(full - only1) < 0.01), got, 0.0)
         self.assertGreater(float(w.sum()), 1.0, "no pole shadow to locate")

{unitytk-0.0.10 → unitytk-0.0.11}/unitytk/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.10"
+__version__ = "0.0.11"
 
 from .launcher import UnityLauncher, UnityFinder
 from .scene_builder import SceneBuilder