@funpixel/tools 0.0.0-stage → 0.1.0

package/bench/README.md

@@ -0,0 +1,10 @@
+# Blender bench scripts
+
+The Python that runs inside Blender for the model bench: `entrypoint.py` and the
+fixed verbs in `handlers/`. The hosted bench (`funpixel-blender`) and
+`funtools model --local` both run these same files.
+
+**Licence: GPL-3.0-or-later** (`LICENSE`). Scripts that use Blender's Python API
+are GPL when distributed, so these are open and ship as plain source beside
+funtools. Only this folder is under the GPL: funtools and the Rust service run
+Blender as a separate program and keep their own licences.

package/bench/entrypoint.py

@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""The ONE Python entrypoint funpixel-blender ever runs.
+
+    blender -b --factory-startup --disable-autoexec -P entrypoint.py -- <verb> <json-args>
+
+THE INVARIANT THIS FILE EXISTS TO ENFORCE: the caller selects a verb by NAME
+from the table below and passes typed arguments. There is deliberately no path
+by which caller-supplied source reaches `exec`, `eval` or Blender's Python
+console. That is what makes it defensible to run this service on our own host
+rather than inside an ephemeral Fly Sprite — see proto/blender.proto. A
+`run_script` handler added here would invalidate that decision on the day it
+lands.
+
+Every handler returns a plain dict and raises on failure. The envelope, the
+framing and the exit code are this file's job, so a handler never has to
+remember them.
+"""
+import json
+import os
+import sys
+import traceback
+
+# Blender's `-P` does NOT put the script's directory on sys.path — unlike
+# `python script.py`, which does. The runner passes an ABSOLUTE entrypoint path,
+# so without this `import handlers` fails with ModuleNotFoundError no matter
+# where the service was started from. Found by running it, not by reasoning
+# about it.
+_HERE = os.path.dirname(os.path.abspath(__file__))
+if _HERE not in sys.path:
+    sys.path.insert(0, _HERE)
+
+# Blender writes its banner, addon chatter and importer warnings to the same
+# stdout we answer on, and no flag reliably silences all of it. So the answer is
+# FRAMED rather than assumed to be the last line — a warning emitted after the
+# handler returns would otherwise be parsed as the result.
+RESULT_BEGIN = "---FUNPIXEL-RESULT-BEGIN---"
+RESULT_END = "---FUNPIXEL-RESULT-END---"
+
+
+def _emit(payload):
+    """Write the framed envelope. The ONLY thing this process promises."""
+    sys.stdout.flush()
+    sys.stdout.write("\n" + RESULT_BEGIN + "\n")
+    json.dump(payload, sys.stdout)
+    sys.stdout.write("\n" + RESULT_END + "\n")
+    sys.stdout.flush()
+
+
+def main():
+    argv = sys.argv
+    if "--" not in argv:
+        _emit({"ok": False, "error": "no -- separator; refusing to guess arguments"})
+        return 1
+    rest = argv[argv.index("--") + 1:]
+    if len(rest) < 2:
+        _emit({"ok": False, "error": "expected <verb> <json-args>"})
+        return 1
+
+    verb, raw_args = rest[0], rest[1]
+
+    # Import handlers lazily and INSIDE the try: `import bpy` at module scope
+    # would make a missing/broken Blender look like a malformed request.
+    try:
+        args = json.loads(raw_args)
+        if not isinstance(args, dict):
+            raise ValueError("arguments must be a JSON object")
+
+        from handlers import HANDLERS  # noqa: E402  (deliberate: see above)
+
+        handler = HANDLERS.get(verb)
+        if handler is None:
+            # Name the alternatives. A typo'd verb should say which ones exist
+            # rather than "not found" — the same courtesy MechanicProbe extends
+            # for a mistyped verb name.
+            raise ValueError(
+                "unknown verb %r; known verbs: %s"
+                % (verb, ", ".join(sorted(HANDLERS)))
+            )
+
+        result = handler(args)
+        _emit({"ok": True, "result": result})
+        return 0
+
+    except Exception as exc:  # noqa: BLE001 - the boundary; everything is reported
+        # A broken asset is an ANSWER, not a broken service. The traceback goes
+        # to stderr (bounded and captured by the runner) while the envelope
+        # carries the human-readable reason.
+        traceback.print_exc(file=sys.stderr)
+        _emit({"ok": False, "error": f"{type(exc).__name__}: {exc}"})
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bench/handlers/__init__.py

@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""The verb table.
+
+Adding a capability is: write `handlers/<verb>.py` exposing `run(args) -> dict`,
+and add one line here. Nothing in the Rust process layer changes — that is the
+whole point of the split, because process handling is where the subtle bugs live
+and a design that edits it per capability rots.
+
+Handlers raise on failure; `entrypoint.py` owns the envelope.
+"""
+from . import apply_skin as _apply_skin
+from . import apply_texture as _apply_texture
+from . import audit_clips as _audit_clips
+from . import author_clips as _author_clips
+from . import bake_emissive as _bake_emissive
+from . import build_level as _build_level
+from . import decimate as _decimate
+from . import fit_rig as _fit_rig
+from . import fracture as _fracture
+from . import inspect as _inspect
+from . import lod as _lod
+from . import merge_clips as _merge_clips
+from . import author_motion as _author_motion
+from . import retarget_clips as _retarget_clips
+from . import mirror_limb as _mirror_limb
+from . import normalize_materials as _normalize
+from . import normalize_transform as _normalize_transform
+from . import prune_clips as _prune_clips
+from . import render as _render
+from . import render_views as _render_views
+
+HANDLERS = {
+    "inspect": _inspect.run,
+    "render_turntable": _render.run,
+    "normalize_materials": _normalize.run,
+    "fit_rig": _fit_rig.run,
+    "author_clips": _author_clips.run,
+    "mirror_limb": _mirror_limb.run,
+    "prune_clips": _prune_clips.run,
+    "merge_clips": _merge_clips.run,
+    "author_motion": _author_motion.run,
+    "retarget_clips": _retarget_clips.run,
+    "audit_clips": _audit_clips.run,
+    "normalize_transform": _normalize_transform.run,
+    "decimate": _decimate.run,
+    "lod": _lod.run,
+    "fracture": _fracture.run,
+    "bake_emissive": _bake_emissive.run,
+    "build_level": _build_level.run,
+    "render_views": _render_views.run,
+    "apply_skin": _apply_skin.run,
+    "apply_texture": _apply_texture.run,
+}

package/bench/handlers/apply_skin.py

@@ -0,0 +1,192 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`apply_skin` — paint exposed skin, consistently (plan g3).
+
+The DECISION of what is skin is not made here: it arrives as grid cells a
+vision pass marked on `render_views`' pictures. This verb does the parts a
+tool can do exactly:
+
+1. PROJECT. The same cameras (recomputed from the model), the same z-buffers.
+   A texel is voted on only by a view that sees it — never through the body —
+   and by how squarely it sees it; the close-ups of face and hands count
+   double, being the closest look. A texel no view saw is left alone.
+2. REFINE. Cells are coarse. Inside the marked texels, only those whose colour
+   is near the skin's own (the median of everything marked) are painted, so
+   eyes, lips, brows and a sleeve's edge caught in a cell keep their colour.
+3. PAINT. One tone for every skin texel, with each texel's light and dark
+   kept (its brightness over the skin's median), shadows warmed toward red —
+   the look light scattering under skin gives, baked into the colour because
+   glTF carries no subsurface. Edges are feathered by a texel or two.
+
+A material with no texture is recoloured whole when enough of what the views
+saw of it was marked and its colour is the skin's. Nothing else about a
+material changes.
+"""
+import os
+
+import numpy as np
+
+from . import render_views, scene, sheet, texels, views
+
+CLOSE_UPS = ("face", "hand_l", "hand_r")
+MATCH = 0.2          # colour distance (0-1 RGB) still counted as the skin's
+FLAT_SHARE = 0.35    # share of a flat material's seen area marked, to recolour it
+LUMA = np.array([0.2126, 0.7152, 0.0722], dtype=np.float32)
+WARM = np.array([0.12, -0.04, -0.12], dtype=np.float32)
+
+
+def _hex(tone):
+    return np.array([int(tone[i:i + 2], 16) / 255.0 for i in (1, 3, 5)], dtype=np.float32)
+
+
+def _to_linear(c):
+    return np.where(c <= 0.04045, c / 12.92, ((c + 0.055) / 1.055) ** 2.4)
+
+
+def _votes(model, cams, masks, size, points, normals):
+    """For surface points: summed weight of views that saw them marked, and
+    of views that saw them unmarked."""
+    pos = np.zeros(len(points), dtype=np.float32)
+    neg = np.zeros(len(points), dtype=np.float32)
+    tol = model.height * 0.01
+    for cam, (zbuf, mask) in zip(cams, masks):
+        seen, flat, facing = views.visible(model, cam, size, zbuf, points, normals, tol)
+        w = np.where(seen, facing, 0.0) * (2.0 if cam["name"] in CLOSE_UPS else 1.0)
+        marked = mask[flat]
+        pos += np.where(marked, w, 0.0)
+        neg += np.where(marked, 0.0, w)
+    return pos, neg
+
+
+def _paint(rgb, idx, tone, median_luma):
+    c = rgb[idx]
+    r = np.clip((c @ LUMA) / max(median_luma, 1e-3), 0.55, 1.35)
+    new = tone[None, :] * r[:, None]
+    shade = np.clip(1.0 - r, 0.0, 1.0)[:, None]
+    return np.clip(new * (1.0 + shade * WARM[None, :]), 0.0, 1.0)
+
+
+def _feather(mask2d):
+    m = mask2d.astype(np.float32)
+    for _ in range(2):
+        m = sum(np.roll(m, (dy, dx), axis=(0, 1)) for dy in (-1, 0, 1) for dx in (-1, 0, 1)) / 9.0
+    return np.maximum(m, mask2d)
+
+
+def run(args):
+    out_path, out_dir = args.get("out_path") or "", args.get("out_dir") or ""
+    if not out_path or not out_dir or not os.path.isdir(out_dir):
+        raise ValueError("out_path and an existing out_dir are required")
+    marks = args.get("marks") or {}
+    if not isinstance(marks, dict) or not any(marks.values()):
+        raise ValueError("no cell was marked as skin")
+    tone_hex = args.get("tone") or ""
+    size = 768
+    model, cams, _, all_slots, lookup = render_views.prepare(dict(args, view_set="skin"))
+    masks = []
+    findings = []
+    for cam in cams:
+        zbuf, tri, _ = views.depth_view(model, cam, size)
+        cells = marks.get(cam["name"]) or []
+        mask = sheet.cell_mask(cells, views.GRID, size)
+        if cells and not (mask & (tri >= 0)).any():
+            findings.append("%s: no marked cell covers the model" % cam["name"])
+        masks.append((zbuf, mask))
+
+    # Vote, per textured slot by texel, per flat slot by triangle.
+    work, samples, flat_marked = [], [], []
+    total = seen_total = skin_total = conflicts = 0
+    for s in all_slots:
+        if s.pixels is not None:
+            flat, pts, nrm = texels.texel_points(model, s)
+            pos, neg = _votes(model, cams, masks, size, pts, nrm)
+            skin = pos > neg
+            conflicts += int(((pos > 0.2) & (neg > 0.2)).sum())
+            total += len(flat)
+            seen_total += int(((pos + neg) > 0).sum())
+            work.append((s, (flat[skin], flat)))
+            samples.append(s.pixels.reshape(-1, 4)[flat[skin], :3])
+        else:
+            corners = model.pos[model.tris[s.tris]]
+            area = np.linalg.norm(np.cross(corners[:, 1] - corners[:, 0], corners[:, 2] - corners[:, 0]), axis=1)
+            pos, neg = _votes(model, cams, masks, size, corners.mean(axis=1), model.normal[s.tris])
+            seen = (pos + neg) > 0
+            marked_area = float(area[seen & (pos > neg)].sum())
+            work.append((s, marked_area / max(float(area[seen].sum()), 1e-12)))
+            if marked_area > 0:
+                flat_marked.append((marked_area, s.flat ** (1 / 2.2)))
+    marked = np.concatenate(samples) if samples else np.zeros((0, 3), dtype=np.float32)
+    if len(marked):
+        median = np.median(marked, axis=0).astype(np.float32)
+    elif flat_marked:
+        # No texture anywhere: the skin is the flat colour most of the marks fell on.
+        median = max(flat_marked, key=lambda m: m[0])[1].astype(np.float32)
+    else:
+        raise ValueError("none of the marked cells landed on a surface a view could see")
+    tone = _hex(tone_hex) if tone_hex else median
+    median_luma = float(median @ LUMA)
+
+    touched, kept_detail = [], 0
+    for s, what in work:
+        if s.pixels is None:
+            near = np.linalg.norm(s.flat ** (1 / 2.2) - median) < MATCH
+            if what >= FLAT_SHARE and not near:
+                kept_detail += 1
+            elif what >= FLAT_SHARE:
+                bsdf = texels._bsdf(s.mat)
+                if bsdf is not None:
+                    bsdf.inputs["Base Color"].default_value = (*_to_linear(tone), 1.0)
+                    findings.append("material '%s' has no texture: recoloured whole" % s.name)
+                    touched.append(s)
+            continue
+        idx, covered = what
+        h, w = s.pixels.shape[:2]
+        rgb = s.pixels[..., :3].reshape(-1, 3).copy()
+        near = np.linalg.norm(rgb[idx] - median, axis=1) < MATCH
+        kept_detail += int((~near).sum())
+        idx = idx[near]
+        if len(idx) == 0:
+            continue
+        skin_total += len(idx)
+        mask = np.zeros(h * w, dtype=bool)
+        mask[idx] = True
+        weight = _feather(mask.reshape(h, w)).ravel()
+        # The gutter round an island (texels no triangle covers) takes the
+        # paint whole, or a filtered lookup at the seam shows the old colour.
+        gutter = np.ones(h * w, dtype=bool)
+        gutter[covered] = False
+        weight[gutter & (weight > 0)] = 1.0
+        edge = np.nonzero(weight > 0)[0]
+        rgb[edge] = rgb[edge] * (1 - weight[edge, None]) + _paint(rgb, edge, tone, median_luma) * weight[edge, None]
+        rgb = rgb.reshape(h, w, 3)
+        texels.replace_image(s, rgb, "skin")
+        s.pixels = np.concatenate([rgb, s.pixels[..., 3:4]], axis=-1)
+        touched.append(s)
+    if not touched:
+        raise ValueError("the marked skin matched no texel's colour closely enough to paint")
+    tone_out = "#%02x%02x%02x" % tuple(int(round(float(c) * 255)) for c in tone)
+    for s in touched:
+        if s.mat is not None:
+            s.mat["funpixel_skin_tone"] = tone_out
+    if total and seen_total < 0.8 * total:
+        findings.append("%d%% of the textured surface no view saw: left as it was"
+                        % round(100 * (1 - seen_total / total)))
+
+    scene.export_glb(out_path)
+    proof = []
+    for cam in cams:
+        if cam["name"] in ("front", "face", "hand_l", "hand_r"):
+            zbuf, tri, bary = views.depth_view(model, cam, 384)
+            proof.append(texels.shade_view(model, cam, 384, lookup, zbuf, tri, bary)[0])
+    proof_path = os.path.join(out_dir, "proof.png")
+    sheet.write_png(sheet.contact(proof), proof_path)
+    return {
+        "out_path": out_path,
+        "proof": proof_path,
+        "skin_share": (skin_total / total) if total else -1.0,
+        "skin_texels": skin_total,
+        "conflict_texels": conflicts,
+        "detail_texels_kept": kept_detail,
+        "tone": tone_out,
+        "materials": sorted({s.name for s in touched}),
+        "findings": findings,
+    }

package/bench/handlers/apply_texture.py

@@ -0,0 +1,195 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`apply_texture` — a new look painted onto the same mesh (plan g3).
+
+The pictures arrive from elsewhere: each is one of `render_views`' four
+`retexture` views, repainted by an image model. This verb puts them back:
+
+1. ALIGN. An image model keeps the composition but not the pixel: the
+   repainted silhouette is found against its own backdrop and fitted onto the
+   rendered silhouette box, so a sleeve lands on the sleeve.
+2. PROJECT. Every texel of every textured slot takes the colour of the views
+   that SEE it (the same z-buffers as the skin verb), weighted by how squarely,
+   and only from inside both silhouettes — a backdrop pixel is never paint.
+3. FILL. What no view saw (under an arm, a UV gutter) grows in from its
+   neighbours rather than keeping a patch of the old look.
+
+A slot with no texture gets one (UVs are unwrapped first if the mesh has
+none) — its material gains an image, never a sibling. Roughness and normal
+maps are derived from the new colour on request: rougher where darker, and a
+gentle relief from its brightness.
+"""
+import os
+
+import bpy
+import numpy as np
+
+from . import render_views, scene, sheet, texels, views
+
+SIZE = 768
+
+
+def _mask_box(mask):
+    ys, xs = np.nonzero(mask)
+    if len(xs) == 0:
+        return None
+    return xs.min(), xs.max(), ys.min(), ys.max()
+
+
+def _align(ours, painted):
+    """`painted` resampled so its subject's box sits on `ours` (S, S) mask's
+    box; returns (colours (S*S, 3), usable (S*S,))."""
+    s = ours.shape[0]
+    border = np.concatenate([painted[0], painted[-1], painted[:, 0], painted[:, -1]])
+    backdrop = np.median(border, axis=0)
+    subject = np.linalg.norm(painted - backdrop, axis=-1) > 0.25
+    a, b = _mask_box(ours), _mask_box(subject)
+    if a is None or b is None:
+        return None, None
+    ys, xs = np.mgrid[0:s, 0:s]
+    sx = (b[1] - b[0]) / max(a[1] - a[0], 1)
+    sy = (b[3] - b[2]) / max(a[3] - a[2], 1)
+    gx = np.clip(((xs - a[0]) * sx + b[0]).round().astype(np.int64), 0, s - 1)
+    gy = np.clip(((ys - a[2]) * sy + b[2]).round().astype(np.int64), 0, s - 1)
+    return painted[gy, gx].reshape(-1, 3), subject[gy, gx].ravel()
+
+
+def _erode(mask, rings=2):
+    m = mask.copy()
+    for _ in range(rings):
+        m = m & np.roll(m, 1, 0) & np.roll(m, -1, 0) & np.roll(m, 1, 1) & np.roll(m, -1, 1)
+    return m
+
+
+def _ensure_uvs():
+    for obj in scene.mesh_objects():
+        if obj.data.uv_layers:
+            continue
+        scene.select_only([obj], obj)
+        bpy.ops.object.mode_set(mode="EDIT")
+        bpy.ops.mesh.select_all(action="SELECT")
+        bpy.ops.uv.smart_project(island_margin=0.02)
+        bpy.ops.object.mode_set(mode="OBJECT")
+
+
+def _give_texture(slot, edge):
+    """A slot drawn in a flat colour gets an image of that colour, wired in."""
+    tree = slot.mat.node_tree
+    bsdf = texels._bsdf(slot.mat)
+    img = bpy.data.images.new(slot.name + "_base", edge, edge, alpha=True)
+    colour = np.clip(slot.flat, 0, 1) ** (1 / 2.2)
+    px = np.ones((edge, edge, 4), dtype=np.float32)
+    px[..., :3] = colour
+    img.pixels.foreach_set(px.ravel())
+    img.pack()
+    node = tree.nodes.new("ShaderNodeTexImage")
+    node.image = img
+    tree.links.new(node.outputs["Color"], bsdf.inputs["Base Color"])
+    slot.node, slot.image, slot.pixels = node, img, px
+
+
+def _data_image(slot, name, rgb):
+    h, w = rgb.shape[:2]
+    img = bpy.data.images.new("%s_%s" % (slot.image.name, name), w, h, alpha=False)
+    img.colorspace_settings.name = "Non-Color"
+    px = np.ones((h, w, 4), dtype=np.float32)
+    px[..., :3] = rgb
+    img.pixels.foreach_set(px.ravel())
+    img.pack()
+    node = slot.mat.node_tree.nodes.new("ShaderNodeTexImage")
+    node.image = img
+    return node
+
+
+def _maps(slot, rgb, roughness, normal):
+    bsdf = texels._bsdf(slot.mat)
+    tree = slot.mat.node_tree
+    luma = rgb @ np.array([0.2126, 0.7152, 0.0722], dtype=np.float32)
+    if roughness:
+        r = np.clip(0.95 - 0.45 * luma, 0.35, 0.95)
+        node = _data_image(slot, "roughness", np.repeat(r[..., None], 3, axis=-1))
+        tree.links.new(node.outputs["Color"], bsdf.inputs["Roughness"])
+    if normal:
+        dx = (np.roll(luma, -1, 1) - np.roll(luma, 1, 1)) * 2.0
+        dy = (np.roll(luma, -1, 0) - np.roll(luma, 1, 0)) * 2.0
+        n = np.stack([-dx, -dy, np.ones_like(luma)], axis=-1)
+        n /= np.linalg.norm(n, axis=-1, keepdims=True)
+        node = _data_image(slot, "normal", n * 0.5 + 0.5)
+        nm = tree.nodes.new("ShaderNodeNormalMap")
+        tree.links.new(node.outputs["Color"], nm.inputs["Color"])
+        tree.links.new(nm.outputs["Normal"], bsdf.inputs["Normal"])
+
+
+def run(args):
+    out_path, out_dir = args.get("out_path") or "", args.get("out_dir") or ""
+    if not out_path or not out_dir or not os.path.isdir(out_dir):
+        raise ValueError("out_path and an existing out_dir are required")
+    painted_paths = args.get("views") or {}
+    if not isinstance(painted_paths, dict) or not painted_paths:
+        raise ValueError("no painted view was given")
+    edge = scene.clamp_int(args.get("texture_size"), 1024, 256, 2048)
+    model, cams, _, all_slots, lookup = render_views.prepare(dict(args, view_set="retexture"),
+                                                             before_arrays=_ensure_uvs)
+    findings, layers = [], []
+    for cam in cams:
+        path = painted_paths.get(cam["name"])
+        if not path:
+            continue
+        if not os.path.isfile(path):
+            raise ValueError("view %s: the picture is missing" % cam["name"])
+        zbuf, tri, _ = views.depth_view(model, cam, SIZE)
+        ours = (tri >= 0).reshape(SIZE, SIZE)
+        colours, usable = _align(ours, sheet.read_png(path, SIZE))
+        if colours is None:
+            findings.append("%s: no subject found in the painted picture; not used" % cam["name"])
+            continue
+        layers.append((cam, zbuf, colours, usable & _erode(ours).ravel()))
+    if not layers:
+        raise ValueError("none of the painted views could be used")
+
+    total = seen_total = 0
+    touched = []
+    tol = model.height * 0.01
+    for s in all_slots:
+        if s.mat is None or texels._bsdf(s.mat) is None:
+            findings.append("material '%s' has no Principled BSDF: left as it was" % s.name)
+            continue
+        if s.pixels is None:
+            _give_texture(s, edge)
+        flat, pts, nrm = texels.texel_points(model, s)
+        acc = np.zeros((len(flat), 3), dtype=np.float32)
+        wsum = np.zeros(len(flat), dtype=np.float32)
+        for cam, zbuf, colours, usable in layers:
+            seen, pix, facing = views.visible(model, cam, SIZE, zbuf, pts, nrm, tol)
+            w = np.where(seen & usable[pix], facing ** 2, 0.0).astype(np.float32)
+            acc += colours[pix] * w[:, None]
+            wsum += w
+        h, w_ = s.pixels.shape[:2]
+        rgb = s.pixels[..., :3].reshape(-1, 3).copy()
+        known = np.zeros(h * w_, dtype=bool)
+        got = wsum > 1e-6
+        rgb[flat[got]] = acc[got] / wsum[got][:, None]
+        known[flat[got]] = True
+        total += len(flat)
+        seen_total += int(got.sum())
+        rgb = texels.fill_unseen(rgb.reshape(h, w_, 3), known.reshape(h, w_))
+        texels.replace_image(s, rgb, "retex")
+        s.pixels = np.concatenate([rgb, s.pixels[..., 3:4]], axis=-1)
+        if args.get("roughness") or args.get("normal"):
+            _maps(s, rgb, bool(args.get("roughness")), bool(args.get("normal")))
+        touched.append(s.name)
+    if not touched:
+        raise ValueError("no material slot could take a texture")
+    share = seen_total / total if total else -1.0
+    if 0 <= share < 0.7:
+        findings.append("%d%% of the surface no view saw: filled from its neighbours"
+                        % round(100 * (1 - share)))
+
+    scene.export_glb(out_path)
+    proof = []
+    for cam in cams:
+        zbuf, tri, bary = views.depth_view(model, cam, 384)
+        proof.append(texels.shade_view(model, cam, 384, lookup, zbuf, tri, bary)[0])
+    proof_path = os.path.join(out_dir, "proof.png")
+    sheet.write_png(sheet.contact(proof), proof_path)
+    return {"out_path": out_path, "proof": proof_path, "seen_share": share,
+            "materials": sorted(set(touched)), "findings": findings}