@funpixel/tools 0.0.0-stage → 0.1.1

package/bench/handlers/normalize_materials.py

@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`normalize_materials` — make an invisible model visible again.
+
+THE FIRST VERB THAT WRITES. Everything before it only reported.
+
+It fixes exactly the trap `render_turntable` made visible, and `creatures.py`
+recorded verbatim:
+
+    THE TRAP. This pack's FBX carries alpha 0 on every material. Exported
+    faithfully that is a completely invisible model: it loads without error,
+    reports five visible skinned meshes, and draws nothing at all. Force opaque.
+
+...and its second half:
+
+    An all-black base colour renders as a flat silhouette under any light. Fall
+    back to the material's viewport colour, which is what the pack actually
+    authored for these parts.
+
+WHAT IT WILL NOT DO. It repairs materials that are provably broken — a fully
+transparent surface, a base colour at pure black — and leaves everything else
+exactly as authored. A verb that "improves" materials would be a verb that
+overwrites an artist's deliberate choice, and there is no way for the caller to
+tell that happened. Every change is reported with the reason, so a caller can
+always see what was touched and why.
+
+DELIBERATE NON-GOALS, so nobody adds them later thinking they were forgotten:
+  * glass, and anything else legitimately translucent, is why only alpha == 0
+    is repaired and 0.4 is left alone.
+  * a black material with a TEXTURE is not repaired: the texture supplies the
+    colour, and `base_color_linked` says so.
+"""
+import os
+
+import bpy
+
+from . import scene
+
+# Alpha at or below this is "invisible", not "translucent". Deliberately tight:
+# a design that repairs 0.05 also repairs deliberate glass.
+INVISIBLE_ALPHA = 1e-6
+
+# Sum of the three base-colour channels below which a surface reads as a flat
+# silhouette under any light. `creatures.py` used exactly this threshold.
+NEAR_BLACK_SUM = 0.05
+
+
+def _principled(mat):
+    if not mat.use_nodes or mat.node_tree is None:
+        return None
+    return next(
+        (n for n in mat.node_tree.nodes if n.type == "BSDF_PRINCIPLED"), None
+    )
+
+
+def _repair(mat):
+    """Repair one material. Returns a list of (field, reason) actually changed.
+
+    REPAIRS ONLY WHAT IS PROVABLY BROKEN. Everything here is gated on evidence
+    of a defect, never on "this could be tidier".
+    """
+    changes = []
+
+    bsdf = _principled(mat)
+    if bsdf is None:
+        # Nothing to repair on a material with no Principled BSDF. Say so rather
+        # than silently reporting success.
+        return changes
+
+    alpha_in = bsdf.inputs.get("Alpha")
+    invisible = (
+        alpha_in is not None
+        and not alpha_in.is_linked
+        and float(alpha_in.default_value) <= INVISIBLE_ALPHA
+    )
+
+    if invisible:
+        alpha_in.default_value = 1.0
+        changes.append(
+            ("alpha", "0 -> 1 (fully transparent: the model drew nothing)")
+        )
+
+        # Only NOW is blend_method worth touching. A material left on
+        # BLEND/HASHED still composites against the background once alpha is 1,
+        # which on some exporters is the difference between visible and nearly
+        # visible — but that repair belongs to a material we just proved was
+        # broken, not to every material we happen to see.
+        #
+        # CAUGHT BY THE RESTRAINT TEST, 2026-09-16: repairing blend_method
+        # unconditionally rewrote EVERY model, correct ones included, because
+        # Blender's glTF importer sets HASHED on import regardless of what the
+        # file meant. Worse, forcing OPAQUE on a legitimately translucent
+        # material — glass, foliage, a UI panel — would BREAK it, and the caller
+        # would have no way to tell an improvement from an overwrite.
+        if getattr(mat, "blend_method", "OPAQUE") != "OPAQUE":
+            before = mat.blend_method
+            mat.blend_method = "OPAQUE"
+            changes.append(
+                (
+                    "blend_method",
+                    "%s -> OPAQUE (alongside the alpha repair above)" % before,
+                )
+            )
+
+    base = bsdf.inputs.get("Base Color")
+    if base is not None and not base.is_linked:
+        c = list(base.default_value)
+        if c[0] + c[1] + c[2] < NEAR_BLACK_SUM:
+            # The viewport colour is what the pack authored for this part, and
+            # on the source `creatures.py` handled it survived when the node
+            # colour did not.
+            #
+            # MEASURED, and DO NOT RE-CHASE with a synthetic fixture: neither
+            # Blender's glTF nor its FBX importer round-trips `diffuse_color`
+            # independently — both DERIVE it from the node base colour on
+            # import, so a file exported with a black node colour comes back
+            # with a black viewport colour and this branch cannot fire
+            # (verified both formats, 2026-09-16). The fallback is still
+            # correct and still worth keeping: it fires on a source whose
+            # viewport colour is genuinely independent, which is what
+            # `creatures.py` was handed. It simply cannot be reproduced by
+            # round-tripping our own fixture through an exporter.
+            vc = list(mat.diffuse_color)
+            if vc[0] + vc[1] + vc[2] >= NEAR_BLACK_SUM:
+                base.default_value = (vc[0], vc[1], vc[2], 1.0)
+                changes.append(
+                    (
+                        "base_color",
+                        "near-black -> viewport colour (%.2f, %.2f, %.2f)"
+                        % (vc[0], vc[1], vc[2]),
+                    )
+                )
+            else:
+                # Both are black. Repairing to an invented colour would be this
+                # verb making an art decision, so it reports and leaves it.
+                changes.append(
+                    (
+                        "base_color",
+                        "near-black AND viewport colour is black — NOT repaired, "
+                        "an invented colour would be an art decision",
+                    )
+                )
+    return changes
+
+
+def run(args):
+    path = args.get("model_path") or ""
+    if not path or not os.path.isfile(path):
+        raise ValueError("model_path does not exist")
+
+    out_path = args.get("out_path") or ""
+    if not out_path:
+        raise ValueError("out_path is required — this verb writes a new model")
+
+    scene.import_model(path, args.get("format") or "")
+    if not scene.mesh_objects():
+        raise ValueError("the file imported but contains no mesh")
+
+    materials = []
+    for mat in bpy.data.materials:
+        changes = _repair(mat)
+        if changes:
+            materials.append(
+                {
+                    "name": mat.name,
+                    "changes": [
+                        {"field": f, "reason": r} for f, r in changes
+                    ],
+                }
+            )
+
+    # Export even when nothing changed. A caller that asked for a repaired model
+    # must get a model back either way — returning nothing on a no-op would make
+    # "already correct" indistinguishable from "failed", which is the same
+    # two-state mistake -1 exists to prevent elsewhere.
+    scene.export_glb(out_path)
+
+    return {
+        "out_path": out_path,
+        "materials_fixed": materials,
+        "materials_total": len(bpy.data.materials),
+        "bytes_after": os.path.getsize(out_path),
+    }

package/bench/handlers/normalize_transform.py

@@ -0,0 +1,174 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`normalize_transform` — bake every transform into the geometry, put the pivot
+at the centre of the base, +Y up, one unit = one metre (plan b10).
+
+What a game engine wants from a prop or a character and rarely gets: a
+generator's GLB arrives with a root node carrying a scale, a rotation or an
+offset, an FBX in centimetres carries 0.01 on every object, and the origin sits
+wherever the tool left it. Physics, snapping to the floor and instancing all
+read the root transform, so each of those becomes the game's problem.
+One studio's prep scripts did exactly this before shipping ("normalise to unit
+height with the origin at the base"; another "fits one dimension
+in metres").
+
+AFTERWARDS: every mesh has an identity transform, the model's lowest point sits
+on y = 0 (glTF) with its footprint centred on the origin, and if `height_m` was
+given the model is exactly that tall. "+Y up" is the glTF convention the export
+writes (`export_yup`); a model AUTHORED lying on its side stays on its side and
+is reported (`up_axis`), never guessed at — a car is legitimately longer than it
+is tall, and only a caller knows it is looking at a humanoid.
+
+A RIG IS HANDLED AS A RIG. Applying a scale to an armature rescales its rest
+pose but NOT its pose-bone location curves, which are in bone-local units: a
+walk authored at 0.01 would stride 100 times too far once the 0.01 is applied.
+So every bone location curve is multiplied by the uniform scale applied. A
+non-uniform scale on an armature would shear its bones; that is refused with
+the reason rather than baked.
+"""
+import os
+
+import bpy
+from mathutils import Matrix, Vector
+
+from . import scene
+
+# A uniform scale is uniform to this relative tolerance. Importers round-trip
+# 0.01 as 0.009999999776; anything further apart is a real stretch.
+UNIFORM_TOLERANCE = 1e-3
+
+
+def _bounds(meshes):
+    b = scene.world_bounds(meshes)
+    if b is None:
+        raise ValueError("the file imported but contains no mesh")
+    return Vector(b["min"]), Vector(b["max"])
+
+
+def _uniform_scale(matrix, what):
+    s = matrix.to_scale()
+    if max(abs(s.x - s.y), abs(s.y - s.z)) > UNIFORM_TOLERANCE * max(abs(s.x), 1e-9):
+        raise ValueError(
+            "%s is scaled non-uniformly (%.4g, %.4g, %.4g); applying that would shear "
+            "its bones. Fix the scale in the source file" % (what, s.x, s.y, s.z)
+        )
+    return abs(s.x)
+
+
+def _bake_static(meshes, fit):
+    """Bake world transform then `fit` into each mesh's vertices."""
+    worlds = {o.name: o.matrix_world.copy() for o in meshes}
+    for o in meshes:
+        if o.data.users > 1:
+            o.data = o.data.copy()  # shared data would be transformed twice
+    for o in meshes:
+        m = fit @ worlds[o.name]
+        o.parent = None
+        o.data.transform(m)
+        if m.determinant() < 0:
+            # A mirroring transform turns faces inside out once baked.
+            o.data.flip_normals()
+        o.matrix_world = Matrix.Identity(4)
+    return len(meshes)
+
+
+def _scale_bone_location_curves(factor):
+    """Multiply every pose-bone location key by `factor`. Returns curves touched."""
+    touched = 0
+    if abs(factor - 1.0) < 1e-6:
+        return touched
+    for action in bpy.data.actions:
+        for fc in action.fcurves:
+            if fc.data_path.startswith("pose.bones[") and fc.data_path.endswith(".location"):
+                for k in fc.keyframe_points:
+                    k.co[1] *= factor
+                    k.handle_left[1] *= factor
+                    k.handle_right[1] *= factor
+                touched += 1
+    return touched
+
+
+def _apply_rig(arm, children, fit):
+    """Move the armature by `fit`, then apply its transform and its meshes'."""
+    if arm.parent is not None:
+        world = arm.matrix_world.copy()
+        arm.parent = None
+        arm.matrix_world = world
+    arm.matrix_world = fit @ arm.matrix_world
+    factor = _uniform_scale(arm.matrix_world, "the armature")
+    scene.select_only([arm] + children, arm)
+    bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
+    return factor, _scale_bone_location_curves(factor)
+
+
+def run(args):
+    path = args.get("model_path") or ""
+    out_path = args.get("out_path") or ""
+    if not path or not os.path.isfile(path):
+        raise ValueError("model_path does not exist")
+    if not out_path:
+        raise ValueError("out_path is required — this verb writes a new model")
+    height = float(args.get("height_m") or 0.0)
+    if height < 0 or height != height:
+        raise ValueError("height_m must be 0 (keep the size) or a positive number of metres")
+
+    scene.import_model(path, args.get("format") or "")
+    meshes = scene.mesh_objects()
+    if not meshes:
+        raise ValueError("the file imported but contains no mesh")
+
+    arm = scene.armature_object()
+    if arm is not None:
+        # Measure the REST pose: a posed character's box is not the model's.
+        arm.data.pose_position = "REST"
+        bpy.context.view_layer.update()
+
+    # A rigged model is measured by what its rig moves. Meshy's rigs carry a
+    # 42-vertex icosphere marker (`fit_rig.py`) that is 2 m across and would set
+    # the height of every character it ships with.
+    skinned = [o for o in meshes if scene.is_skinned(o)]
+    measured = {o.name for o in (skinned or meshes)}
+    lo, hi = _bounds([o for o in meshes if o.name in measured])
+    size = hi - lo
+    up_axis = "xyz"[max(range(3), key=lambda i: size[i])]
+    s = height / size.z if height and size.z > 1e-9 else 1.0
+    base = Vector(((lo.x + hi.x) / 2, (lo.y + hi.y) / 2, lo.z))
+    fit = Matrix.Scale(s, 4) @ Matrix.Translation(-base)
+
+    rigged = [o for o in meshes if arm is not None and o.parent == arm]
+    loose = [o for o in meshes if o not in rigged]
+    rig_scale = -1.0  # not measured: no rig
+    curves = 0
+    if arm is not None:
+        rig_scale, curves = _apply_rig(arm, rigged, fit)
+    baked = _bake_static(loose, fit) + len(rigged)
+
+    # Drop what only carried a transform (the importer's empties, stray
+    # cameras and lights): their transforms are now stale.
+    removed = 0
+    for o in list(bpy.data.objects):
+        if o.type not in ("MESH", "ARMATURE"):
+            bpy.data.objects.remove(o, do_unlink=True)
+            removed += 1
+
+    bpy.context.view_layer.update()
+    lo2, hi2 = _bounds([o for o in scene.mesh_objects() if o.name in measured])
+    if arm is not None:
+        arm.data.pose_position = "POSE"
+
+    scene.export_glb(out_path)
+    return {
+        "out_path": out_path,
+        "height_scale": s,
+        "rig_scale": rig_scale,
+        "offset": [-base.x * s, -base.y * s, -base.z * s],
+        "height_m": hi2.z - lo2.z,
+        "bounds_before": {"min": list(lo), "max": list(hi)},
+        "bounds_after": {"min": list(lo2), "max": list(hi2)},
+        "up_axis": up_axis,
+        "measured_on": "skinned meshes" if skinned else "all meshes",
+        "objects_baked": baked,
+        "objects_removed": removed,
+        "rig_applied": arm is not None,
+        "location_curves_scaled": curves,
+        "external_images_dropped": scene.EXTERNAL_IMAGES_DROPPED,
+    }

package/bench/handlers/prune_clips.py

@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`prune_clips` — keep the clips a game plays, drop the rest, rename survivors.
+
+`creatures.py`'s job, verbatim:
+
+    The pack ships 14 clips; a corridor enemy uses four. Every clip it never
+    plays is pure payload, and animation samplers are most of a rigged GLB.
+
+...and its second half, which is why this is not just a delete:
+
+    Rename survivors to the bare verb so the runtime lookup does not depend on
+    the pack's "AlienArmature|AlienArmature|Alien_Walk" naming.
+
+DELIBERATELY NARROW, AND HERE IS WHAT IT IS NOT.
+
+`funpixel-glb-optimize` already compresses this file family, and it is measured:
+on a real 3.89 MB Meshy character, animation samplers are **55.8%** of the
+bytes, and its two passes — constant-track pruning and sampler quantization —
+reach **~49%** of the file. Geometry is noise by comparison (~1%).
+
+This verb must NOT re-do any of that. It does the ONE thing that crate cannot:
+drop a WHOLE NAMED ANIMATION. The optimizer prunes constant tracks *within* the
+animations a file has; it never decides that `Alien_Dance` is not a clip this
+game plays. That decision needs a name, and only a caller has one.
+
+So the split is: this verb selects clips by name, `optimize_glb` compresses
+what survives. Running it before the optimizer means the optimizer never spends
+work on samplers that were going to be discarded.
+
+MATCHING IS SUFFIX-AND-TAIL, NOT EXACT. A pack names a clip
+`AlienArmature|AlienArmature|Alien_Walk`; a caller asks for `Walk`. Requiring an
+exact match would mean no pack ever matches, and requiring a substring would let
+`Walk` also keep `Walk_Backwards_Old`. The script's rule — split on `|`, then
+match the tail exactly or as a `_`-suffixed word — is the one that works on real
+packs.
+"""
+import os
+
+import bpy
+
+from . import scene
+
+
+def _tail(name):
+    """The part after the last `|` separator a pack uses for its namespaces."""
+    return name.split("|")[-1]
+
+
+def _wanted(name, keep):
+    """Does this action match any requested clip?
+
+    Exact tail, or the tail ending `_<Verb>`. `creatures.py`'s rule.
+    """
+    tail = _tail(name)
+    for k in keep:
+        if tail == k or tail.endswith("_" + k):
+            return k
+    return None
+
+
+def run(args):
+    path = args.get("model_path") or ""
+    out_path = args.get("out_path") or ""
+    keep = args.get("keep") or []
+
+    if not path or not os.path.isfile(path):
+        raise ValueError("model_path does not exist")
+    if not out_path:
+        raise ValueError("out_path is required — this verb writes a new model")
+    if not isinstance(keep, list) or not keep:
+        raise ValueError(
+            "keep must be a non-empty list of clip names — dropping EVERY clip is "
+            "almost certainly not what a caller meant, and an empty list would do "
+            "exactly that silently"
+        )
+
+    scene.import_model(path, args.get("format") or "")
+
+    before = [a.name for a in bpy.data.actions]
+    if not before:
+        raise ValueError("the model carries no animations — there is nothing to prune")
+
+    kept, dropped, renamed, collided = [], [], [], []
+    claimed = set()
+    for action in list(bpy.data.actions):
+        match = _wanted(action.name, keep)
+        if match is None:
+            dropped.append(action.name)
+            bpy.data.actions.remove(action)
+            continue
+
+        # CAUGHT IN REVIEW: two actions can match ONE keep entry — a pack with
+        # `Alien_Walk` and `Robot_Walk` both match "Walk". Renaming both makes
+        # Blender silently mint `Walk.001`, `clips_kept` reports ["Walk","Walk"],
+        # and the runtime lookup for "Walk" gets whichever one won. That is
+        # exactly the naming-dependence this verb exists to REMOVE, so the second
+        # match keeps its ORIGINAL name and is reported, rather than being
+        # renamed onto a name already taken.
+        if match in claimed:
+            collided.append({"name": action.name, "wanted": match})
+            action.use_fake_user = True
+            kept.append(action.name)
+            continue
+
+        # Rename to the bare verb so a runtime lookup does not depend on the
+        # pack's naming. Keep a fake user, or the exporter only sees the one
+        # action currently assigned.
+        if action.name != match:
+            renamed.append({"from": action.name, "to": match})
+            action.name = match
+        claimed.add(match)
+        action.use_fake_user = True
+        kept.append(match)
+
+    if not kept:
+        raise ValueError(
+            "none of %s matched any of the %d clips present: %s"
+            % (", ".join(keep), len(before), ", ".join(before[:8]))
+        )
+
+    missing = [k for k in keep if k not in kept]
+
+    bpy.ops.object.select_all(action="SELECT")
+    scene.export_glb(out_path)
+
+    return {
+        "out_path": out_path,
+        "clips_kept": sorted(kept),
+        "clips_dropped": sorted(dropped),
+        # Requested but absent. Reported rather than fatal: a caller asking for
+        # a standard four-clip set against a pack that has three should get the
+        # three and be TOLD, not refused.
+        "clips_missing": sorted(missing),
+        "renamed": renamed,
+        # Actions that matched a keep entry another action already claimed. Kept
+        # under their ORIGINAL names rather than renamed onto a collision, and
+        # reported so a caller can say which one it meant.
+        "name_collisions": collided,
+        "bytes_before": os.path.getsize(path),
+        "bytes_after": os.path.getsize(out_path),
+    }

package/bench/handlers/raster.py

@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""A NumPy triangle rasterizer: the one piece of machinery under the view and
+projection verbs (`render_views`, `apply_skin`, `apply_texture`).
+
+Two uses, one function:
+
+* in a CAMERA's image plane, with depth — a z-buffer that says which triangle
+  each pixel sees, so a texel is painted only from a view that actually sees
+  it (never projected through the body onto its back);
+* in UV space, without depth — which triangle and where on it each TEXEL
+  lies, so a texel knows its point on the surface.
+
+Why not Blender's renderer: an EEVEE frame says what a pixel looks like, not
+which point of the mesh it is. Projection needs that correspondence exactly,
+and it needs the same answer every time for the same model, which is what
+lets `apply_skin` recompute the cameras `render_views` used instead of
+trusting any sent back.
+
+Triangles are drawn in buckets by pixel size, each bucket as one array
+operation, so a 60K-triangle character costs a handful of NumPy calls per
+view rather than 60K Python iterations.
+"""
+import numpy as np
+
+# Candidate pixels one vectorised batch may hold (triangles × box area).
+BATCH = 4_000_000
+
+
+def _bary(px, py, a, b, c):
+    """Barycentric weights of points (px, py) in triangles (a, b, c), all (M, K)."""
+    v0x, v0y = b[:, 0:1] - a[:, 0:1], b[:, 1:2] - a[:, 1:2]
+    v1x, v1y = c[:, 0:1] - a[:, 0:1], c[:, 1:2] - a[:, 1:2]
+    v2x, v2y = px - a[:, 0:1], py - a[:, 1:2]
+    den = v0x * v1y - v1x * v0y
+    den = np.where(np.abs(den) < 1e-12, 1e-12, den)
+    w1 = (v2x * v1y - v1x * v2y) / den
+    w2 = (v0x * v2y - v2x * v0y) / den
+    return 1.0 - w1 - w2, w1, w2
+
+
+def _candidates(xy, lo, k, width, height):
+    """Pixel centres of a k×k box per triangle, their flat index and validity."""
+    off = np.arange(k)
+    gx = lo[:, 0:1, None] + off[None, None, :]          # (M, 1, k)
+    gy = lo[:, 1:2, None] + off[None, :, None]          # (M, k, 1)
+    gx = np.broadcast_to(gx, (len(lo), k, k)).reshape(len(lo), -1)
+    gy = np.broadcast_to(gy, (len(lo), k, k)).reshape(len(lo), -1)
+    ok = (gx >= 0) & (gx < width) & (gy >= 0) & (gy < height)
+    return gx + 0.5, gy + 0.5, gy * width + gx, ok
+
+
+def rasterize(xy, depth, width, height, want_bary=False):
+    """Draw triangles `xy` (T, 3, 2) in pixel units, nearest `depth` (T, 3)
+    wins (pass zeros for no depth test).
+
+    Returns (zbuf (H*W,), tri (H*W,) int, -1 = empty, bary (H*W, 3) or None).
+    """
+    n = len(xy)
+    zbuf = np.full(width * height, np.inf, dtype=np.float64)
+    tri = np.full(width * height, -1, dtype=np.int64)
+    bary = np.zeros((width * height, 3), dtype=np.float32) if want_bary else None
+    if n == 0:
+        return zbuf, tri, bary
+    lo = np.floor(xy.min(axis=1)).astype(np.int64)
+    hi = np.ceil(xy.max(axis=1)).astype(np.int64)
+    size = np.maximum(hi - lo, 1).max(axis=1)
+    # Nothing to draw: off-screen, or degenerate.
+    live = (hi[:, 0] >= 0) & (hi[:, 1] >= 0) & (lo[:, 0] < width) & (lo[:, 1] < height)
+    k_of = np.maximum(1, 2 ** np.ceil(np.log2(size + 1)).astype(np.int64))
+    k_of = np.minimum(k_of, max(width, height) * 2)
+
+    passes = []
+    for k in np.unique(k_of[live]):
+        idx = np.nonzero(live & (k_of == k))[0]
+        step = max(1, BATCH // int(k * k))
+        for s in range(0, len(idx), step):
+            passes.append((int(k), idx[s:s + step]))
+
+    def cover(k, ids):
+        gx, gy, flat, ok = _candidates(xy[ids], lo[ids], k, width, height)
+        w0, w1, w2 = _bary(gx, gy, xy[ids, 0], xy[ids, 1], xy[ids, 2])
+        inside = ok & (w0 >= -1e-6) & (w1 >= -1e-6) & (w2 >= -1e-6)
+        d = depth[ids]
+        z = w0 * d[:, 0:1] + w1 * d[:, 1:2] + w2 * d[:, 2:3]
+        return flat, inside, z, (w0, w1, w2)
+
+    for k, ids in passes:
+        flat, inside, z, _ = cover(k, ids)
+        np.minimum.at(zbuf, flat[inside], z[inside])
+    # Second pass: the triangle that won each pixel (ties are either one).
+    for k, ids in passes:
+        flat, inside, z, w = cover(k, ids)
+        win = inside & (z <= zbuf[np.where(inside, flat, 0)] + 1e-9)
+        tri_ids = np.broadcast_to(ids[:, None], flat.shape)
+        tri[flat[win]] = tri_ids[win]
+        if want_bary:
+            bary[flat[win]] = np.stack([w[0][win], w[1][win], w[2][win]], axis=1)
+    return zbuf, tri, bary