animation/characters/work/lena/30_decimate.py

# Stage 30: decimate the v03 sculpt to the game-body vertex budget and export a clean GLB for the
# retexture / re-atlas lane.
#
#   blender --background --python 30_decimate.py -- <in.blend> <out.glb> [target_verts] [review_dir]
#
# TARGET. Jeremy picked the shipped game body's density: `lena_nude_quatskin_glb_v01.glb` is
# 31,670 v, so that is the number to hit — not a round ratio.
#
# WHY A SEARCH INSTEAD OF A RATIO. Blender's Decimate COLLAPSE ratio is a fraction of FACES, and
# the vertex count that falls out of it depends on the mesh's genus and boundary, so
# verts != faces/2 exactly. Rather than assume, this evaluates the modifier through the depsgraph
# (no destructive apply) and bisects the ratio until the vertex count lands inside tolerance. The
# modifier is applied exactly once, at the end, with the ratio the search settled on.
#
# WHAT IT DELIBERATELY DOES NOT DO. It does not try to protect the UV atlas. The consumer is the
# re-atlas work in this lane (`24_seams.py`), which throws Tripo's 5,870-chart soup away and builds
# ~14 anatomical charts from scratch, so spending decimation quality on preserving the old UVs
# would be wasted. The basecolor/normal/rm are still carried into the GLB so the mesh arrives
# textured and can be eyeballed on its own.
#
# Transforms are applied and the object is left alone in the scene, because that is what
# `24_seams.py` expects of its input.
import bpy, bmesh, sys, os, math, time
import numpy as np
from mathutils import Vector

argv = sys.argv[sys.argv.index("--") + 1:]
BLEND, OUT = argv[0], argv[1]
TARGET_V = int(argv[2]) if len(argv) > 2 else 31670
REVIEW = argv[3] if len(argv) > 3 else ""
t0 = time.time()
TOL = 0.01            # accept within 1% of the target vertex count
UNIT_MM = 1815.0


def log(m):
    print(f"[dec {time.time()-t0:6.1f}s] {m}", flush=True)


bpy.ops.wm.open_mainfile(filepath=BLEND)
ob = max([o for o in bpy.data.objects if o.type == 'MESH'],
         key=lambda o: len(o.data.vertices))
bpy.context.view_layer.objects.active = ob
for o in bpy.data.objects:
    o.select_set(o is ob)
bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
me = ob.data
v0, f0 = len(me.vertices), len(me.polygons)
co0 = np.empty(v0 * 3)
me.vertices.foreach_get("co", co0)
co0 = co0.reshape(-1, 3)
h0 = co0[:, 2].max() - co0[:, 2].min()
log(f"in: {v0}v {f0}f  height {h0:.4f} units ({h0*UNIT_MM/1000:.3f} m equiv)")
log(f"target: {TARGET_V} v (+/-{TOL*100:.0f}%)")

# ---- bisect the collapse ratio against the evaluated mesh ----
mod = ob.modifiers.new("dec", 'DECIMATE')
mod.decimate_type = 'COLLAPSE'
mod.use_collapse_triangulate = False


def verts_at(ratio):
    mod.ratio = ratio
    ob.update_tag()
    dg = bpy.context.evaluated_depsgraph_get()
    ev = ob.evaluated_get(dg)
    m = ev.to_mesh()
    n = len(m.vertices)
    ev.to_mesh_clear()
    return n


lo, hi = 0.001, 1.0
best = None
# seed from the naive verts~faces/2 relation, then bisect
guess = min(1.0, max(0.001, (TARGET_V * 2.0) / f0))
n = verts_at(guess)
log(f"  seed ratio {guess:.5f} -> {n} v")
if abs(n - TARGET_V) / TARGET_V <= TOL:
    best = (guess, n)
else:
    if n > TARGET_V:
        hi = guess
    else:
        lo = guess
    for it in range(24):
        mid = 0.5 * (lo + hi)
        n = verts_at(mid)
        log(f"  it{it:02d} ratio {mid:.6f} -> {n} v")
        if abs(n - TARGET_V) / TARGET_V <= TOL:
            best = (mid, n)
            break
        if n > TARGET_V:
            hi = mid
        else:
            lo = mid
    if best is None:
        best = (0.5 * (lo + hi), verts_at(0.5 * (lo + hi)))
        log(f"  search exhausted; using ratio {best[0]:.6f} -> {best[1]} v")

ratio, got = best
mod.ratio = ratio
log(f"SETTLED ratio {ratio:.6f} -> {got} v (target {TARGET_V})")
bpy.ops.object.modifier_apply(modifier=mod.name)
me = ob.data
v1, f1 = len(me.vertices), len(me.polygons)
log(f"applied: {v0}v/{f0}f -> {v1}v/{f1}f  "
    f"({100.0*v1/v0:.2f}% of verts, {100.0*f1/f0:.2f}% of faces)")

# ---- shape + health checks ----
co1 = np.empty(v1 * 3)
me.vertices.foreach_get("co", co1)
co1 = co1.reshape(-1, 3)
h1 = co1[:, 2].max() - co1[:, 2].min()
print(f"HEIGHT  {h0:.5f} -> {h1:.5f} units  (delta {(h1-h0)*UNIT_MM:+.2f} real mm)")
for ax, nm in ((0, "x"), (1, "y"), (2, "z")):
    print(f"  bbox {nm}: {co0[:,ax].min():+.4f}..{co0[:,ax].max():+.4f} -> "
          f"{co1[:,ax].min():+.4f}..{co1[:,ax].max():+.4f}")

# smooth normals over the new topology, matching the rest of the pipeline
vn = np.empty(v1 * 3, dtype=np.float32)
me.vertices.foreach_get("normal", vn)
if me.has_custom_normals:
    me.normals_split_custom_set_from_vertices(vn.reshape(-1, 3))

bm = bmesh.new()
bm.from_mesh(me)
bnd = len([e for e in bm.edges if len(e.link_faces) == 1])
nm_ = len([e for e in bm.edges if len(e.link_faces) > 2])
tri = len([f for f in bm.faces if len(f.verts) == 3])
quad = len([f for f in bm.faces if len(f.verts) == 4])
ngon = len([f for f in bm.faces if len(f.verts) > 4])
bm.free()
print(f"TOPO  boundary_edges={bnd}  nonmanifold_edges={nm_}  tris={tri} quads={quad} ngons={ngon}")

# flipped faces, same test stage 25 used
fn = np.empty(f1 * 3)
me.polygons.foreach_get("normal", fn)
fn = fn.reshape(-1, 3)
lv = np.empty(len(me.loops), dtype=np.int32)
me.loops.foreach_get("vertex_index", lv)
ls = np.empty(f1, dtype=np.int32)
me.polygons.foreach_get("loop_start", ls)
lt = np.empty(f1, dtype=np.int32)
me.polygons.foreach_get("loop_total", lt)
vn2 = vn.reshape(-1, 3).astype(np.float64)
acc = np.zeros((f1, 3))
for k in range(int(lt.max())):
    sel = lt > k
    acc[sel] += vn2[lv[ls[sel] + k]]
acc /= np.maximum(np.linalg.norm(acc, axis=1, keepdims=True), 1e-12)
print(f"FLIPPED FACES: {int(((fn*acc).sum(axis=1) < 0).sum())} of {f1}")

uvl = me.uv_layers.active
print(f"UV layer: {uvl.name if uvl else None}  "
      f"(carried through decimation; the re-atlas rebuilds it)")
imgs = [i.name for i in bpy.data.images if i.has_data]
print(f"IMAGES carried: {imgs}")
print(f"MATERIALS: {[ms.material.name if ms.material else None for ms in ob.material_slots]}")
print(f"MODIFIERS left: {[m.type for m in ob.modifiers]}")

# ---- export ----
os.makedirs(os.path.dirname(os.path.abspath(OUT)), exist_ok=True)
bpy.ops.export_scene.gltf(
    filepath=OUT,
    export_format='GLB',
    export_image_format='AUTO',
    export_yup=True,
    export_apply=False,
    export_animations=False,
    export_skins=False,
    export_morph=False,
)
log(f"WROTE {OUT} ({os.path.getsize(OUT)/1e6:.2f} MB)")

# ---- optional review renders ----
if REVIEW:
    os.makedirs(REVIEW, exist_ok=True)
    scn = bpy.context.scene
    wd = bpy.data.worlds.new("W")
    wd.color = (0.22, 0.22, 0.24)
    scn.world = wd
    key = bpy.data.objects.new("Key", bpy.data.lights.new("Key", 'SUN'))
    key.data.energy = 3.0
    key.data.use_shadow = False
    bpy.context.collection.objects.link(key)
    fl = bpy.data.objects.new("Fill", bpy.data.lights.new("Fill", 'SUN'))
    fl.data.energy = 1.0
    fl.data.use_shadow = False
    bpy.context.collection.objects.link(fl)
    cam = bpy.data.objects.new("Cam", bpy.data.cameras.new("Cam"))
    cam.data.lens = 85
    bpy.context.collection.objects.link(cam)
    scn.camera = cam
    scn.render.engine = 'BLENDER_EEVEE' if bpy.app.version >= (4, 2) else 'BLENDER_EEVEE_NEXT'
    scn.render.resolution_x = scn.render.resolution_y = 1000
    clay = bpy.data.materials.new("Clay")
    clay.use_nodes = True
    nt = clay.node_tree.nodes["Principled BSDF"]
    nt.inputs["Base Color"].default_value = (0.62, 0.60, 0.58, 1)
    nt.inputs["Roughness"].default_value = 0.45
    orig = [ms.material for ms in ob.material_slots]

    def shoot(tag, ctr, span, yaw, use_clay):
        for i, ms in enumerate(ob.material_slots):
            ms.material = clay if use_clay else orig[i]
        y = math.radians(yaw)
        d = span * 3.0
        cam.location = Vector(ctr) + Vector((math.sin(y) * d, -math.cos(y) * d, 0.02))
        cam.rotation_euler = (Vector(ctr) - cam.location).to_track_quat('-Z', 'Y').to_euler()
        key.rotation_euler = (math.radians(62), 0, math.radians(35 + yaw))
        fl.rotation_euler = (math.radians(75), 0, math.radians(yaw - 110))
        scn.render.filepath = os.path.abspath(os.path.join(REVIEW, f"{tag}.png"))
        bpy.ops.render.render(write_still=True)
        log(f"render {tag}")

    shoot("full_clay_0", (0.0, 0.0, 0.50), 0.55, 0, True)
    shoot("full_tex_0", (0.0, 0.0, 0.50), 0.55, 0, False)
    shoot("chest_clay_0", (0.0, 0.0, 0.675), 0.22, 0, True)
    shoot("chest_tex_0", (0.0, 0.0, 0.675), 0.22, 0, False)
    shoot("hip_clay_0", (0.0, 0.0, 0.53), 0.22, 0, True)

print("DEC_DONE")