The preview pins practices e0950d93 (the figure redrawn in Inner Breeze's own illustration style) and Kryon 8e44f3f8 with its Ziran toolchain, so hands-off playback keeps presenting. The asset script builds her slim Asian build, the mandarin top with collar, frog-knot placket and side slits, gathered silk trousers, black shoes, sleek hair with a high bun and the new face, and leaves out the body hidden under the clothes. The backdrop is scaled once per size instead of every frame, and the preview reports median and 95th percentile milliseconds for each step of a frame: in its log every 240 frames, or headless with --profile.
902 lines
45 KiB
Python
902 lines
45 KiB
Python
#!/usr/bin/env python3
|
|
"""Bake the pinned CC0 MakeHuman surface for the native practice skin rig."""
|
|
import argparse
|
|
import gzip
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import struct
|
|
import numpy as np
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
|
|
# The painted textures and backdrops come from generated watercolor
|
|
# originals kept in OUTPUT/source (provenance.json there): each swatch is
|
|
# moved to the style target's palette, made to tile without a seam and
|
|
# sized for phones.
|
|
SWATCHES = {'skin': ('#f3d2b8', 0.45), 'top': ('#3f9a7e', 0.9), 'trousers': ('#24345e', 0.85),
|
|
'hair': ('#1e1e28', 1.0)}
|
|
BACKDROPS = ('tai-chi', 'sun-salutation', 'workout', 'astral')
|
|
|
|
def prepare_textures(folder):
|
|
from PIL import Image
|
|
source = folder/'source'
|
|
for name, (target, contrast) in SWATCHES.items():
|
|
picture = np.asarray(Image.open(source/f'{name}.webp').convert('RGB').resize((512, 512), Image.LANCZOS),
|
|
dtype=np.float64)
|
|
mean = picture.reshape(-1, 3).mean(axis=0)
|
|
goal = np.array([int(target[at:at+2], 16) for at in (1, 3, 5)], dtype=np.float64)
|
|
light = picture @ np.array([0.30, 0.59, 0.11])
|
|
# Keep the brushwork's light and dark, painted in the target colour,
|
|
# with a little of the swatch's own colour variation.
|
|
shade = (light-light.mean())*contrast
|
|
tinted = goal+shade[:, :, None]+(picture-mean-(light-light.mean())[:, :, None])*0.45
|
|
# A copy offset by half covers the seam at the edges.
|
|
shifted = np.roll(tinted, (256, 256), axis=(0, 1))
|
|
ramp = 1-np.abs(np.arange(512)/511*2-1)
|
|
weight = np.clip(np.minimum.outer(ramp, ramp)*3, 0, 1)[:, :, None]
|
|
tiled = tinted*weight+shifted*(1-weight)
|
|
Image.fromarray(np.clip(tiled, 0, 255).astype(np.uint8)).save(folder/f'{name}.webp', quality=88, method=6)
|
|
# The face painting takes the skin swatch's colour on its cheeks and
|
|
# brow, keeping its own eyes, brows, lips and blush.
|
|
# The trim keeps its own colours: jade silk with cream frog knots.
|
|
Image.open(source/'trim.webp').convert('RGB').resize((256, 256), Image.LANCZOS).save(
|
|
folder/'trim.webp', quality=90, method=6)
|
|
face = np.asarray(Image.open(source/'face.webp').convert('RGB').resize((512, 512), Image.LANCZOS), dtype=np.float64)
|
|
skin = face[135:170, 228:286].reshape(-1, 3).mean(axis=0)
|
|
goal = np.array([int(SWATCHES['skin'][0][at:at+2], 16) for at in (1, 3, 5)], dtype=np.float64)
|
|
face = face*goal/skin
|
|
# The paper beside her small chin becomes skin too, where MakeHuman's
|
|
# wider jaw reaches past the painted one; her hair, eyes and lips stay.
|
|
light = face @ np.array([0.30, 0.59, 0.11])
|
|
warmth = face[:, :, 0]-face[:, :, 2]
|
|
paper = np.clip((light-205)/20, 0, 1)*np.clip((48-warmth)/14, 0, 1)
|
|
face = face*(1-paper[:, :, None])+goal*paper[:, :, None]
|
|
# Outside the painted face (its paper, hair and ears) the painting
|
|
# becomes plain skin, so wherever the mesh's face reaches past it the
|
|
# skin goes on.
|
|
y, x = np.mgrid[0:512, 0:512]
|
|
oval = np.sqrt(((x-257)/140)**2+((y-250)/175)**2)
|
|
keep = np.clip((1.0-oval)/0.18, 0, 1)[:, :, None]
|
|
face = face*keep+goal*(1-keep)
|
|
Image.fromarray(np.clip(face, 0, 255).astype(np.uint8)).save(folder/'face.webp', quality=90, method=6)
|
|
(folder/'backdrops').mkdir(exist_ok=True)
|
|
for name in BACKDROPS:
|
|
picture = Image.open(source/f'backdrop-{name}.webp').convert('RGB')
|
|
picture.thumbnail((1280, 1280), Image.LANCZOS)
|
|
# Richer washes; the near-white paper barely moves.
|
|
pixels = np.asarray(picture, dtype=np.float64)
|
|
light = (pixels @ np.array([0.30, 0.59, 0.11]))[:, :, None]
|
|
pixels = np.clip(light+(pixels-light)*1.3, 0, 255)
|
|
Image.fromarray(pixels.astype(np.uint8)).save(folder/'backdrops'/f'{name}.webp', quality=85, method=6)
|
|
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument('--output', type=Path, required=True)
|
|
parser.add_argument('--textures-only', action='store_true',
|
|
help='only rebuild the painted textures and backdrops from OUTPUT/source')
|
|
args = parser.parse_args()
|
|
if args.textures_only:
|
|
prepare_textures(args.output.resolve())
|
|
raise SystemExit(0)
|
|
source_file = ROOT / 'design/astral-projection/three/assets/makehuman-base.obj.gz'
|
|
vertices, groups, group = [], {}, ''
|
|
for line in gzip.open(source_file, 'rt'):
|
|
if line.startswith('v '):
|
|
vertices.append(list(map(float, line.split()[1:4])))
|
|
elif line.startswith('g '):
|
|
group = line.strip()[2:]
|
|
groups[group] = []
|
|
elif line.startswith('f '):
|
|
groups[group].append([int(item.split('/')[0]) - 1 for item in line.split()[1:]])
|
|
all_vertices = np.asarray(vertices, dtype=np.float64)
|
|
# MakeHuman's base mesh is its gender-neutral average. She is a slim young
|
|
# Chinese woman: MakeHuman's own CC0 young-adult female macro shape, mostly
|
|
# its Asian target, with the weight slider at 0.15, muscle at 0.30, height
|
|
# at 0.65 and ideal proportions, mixed as MakeHuman mixes its macro targets
|
|
# (each weight-and-muscle pair by the product of their shares).
|
|
def apply_target(name, share):
|
|
target = ROOT / f'design/astral-projection/three/assets/makehuman-{name}.target.gz'
|
|
for line in gzip.open(target, 'rt'):
|
|
if line.strip() and not line.startswith('#'):
|
|
index, dx, dy, dz = line.split()
|
|
all_vertices[int(index)] += np.array([float(dx), float(dy), float(dz)])*share
|
|
|
|
for race, share in (('asian', 0.9), ('caucasian', 0.1)):
|
|
apply_target(f'{race}-female-young', share)
|
|
BODY_WEIGHT, BODY_MUSCLE, BODY_HEIGHT, BODY_PROPORTIONS = 0.15, 0.30, 0.65, 1.0
|
|
for muscle, muscle_share in (('minmuscle', 1-BODY_MUSCLE/0.5), ('averagemuscle', BODY_MUSCLE/0.5)):
|
|
for weight, weight_share in (('minweight', 1-BODY_WEIGHT/0.5), ('averageweight', BODY_WEIGHT/0.5)):
|
|
pair = muscle_share*weight_share
|
|
if (muscle, weight) != ('averagemuscle', 'averageweight'):
|
|
apply_target(f'universal-female-young-{muscle}-{weight}', pair)
|
|
apply_target(f'proportions-female-young-{muscle}-{weight}-idealproportions', pair*BODY_PROPORTIONS)
|
|
# MakeHuman's four maxheight targets for these pairs are the same file.
|
|
apply_target('height-female-young-maxheight', (BODY_HEIGHT-0.5)/0.5)
|
|
|
|
# MakeHuman's own CC0 rig weights for this mesh (folded onto this figure's
|
|
# bones further on).
|
|
weights_file = ROOT / 'design/astral-projection/three/assets/makehuman-default-weights.mhw.gz'
|
|
rig = json.loads(gzip.open(weights_file, 'rt').read())
|
|
assert rig['license'] == 'CC0'
|
|
|
|
def rig_share(accept):
|
|
share = np.zeros(len(all_vertices))
|
|
for name, entries in rig['weights'].items():
|
|
if accept(name):
|
|
for vertex, weight in entries:
|
|
share[vertex] += weight
|
|
return np.clip(share, 0, 1)
|
|
|
|
def helpers(prefix):
|
|
return sorted({index for group, faces in groups.items() if group.startswith(prefix) for face in faces
|
|
for index in face})
|
|
|
|
def group_centre(name):
|
|
return all_vertices[sorted({index for face in groups['joint-'+name] for index in face})].mean(axis=0)
|
|
|
|
# Graceful hands and feet: each a little smaller about the wrist or ankle,
|
|
# with its finger and toe joints, so the rig still fits.
|
|
metres = 1.7/np.ptp(all_vertices[sorted({i for f in groups['body'] for i in f})][:, 1])
|
|
for side in ('L', 'R'):
|
|
prefix = 'l' if side == 'L' else 'r'
|
|
for pivot_name, stems, joint_prefix, factor in (
|
|
('hand', ('wrist', 'metacarpal', 'finger'), f'joint-{prefix}-finger', 0.90),
|
|
('ankle', ('foot', 'toe'), f'joint-{prefix}-toe', 0.92)):
|
|
pivot = group_centre(f'{prefix}-{pivot_name}')
|
|
share = rig_share(lambda name: name.endswith('.'+side) and name.split('.')[0].startswith(stems))
|
|
all_vertices += (pivot-all_vertices)*((1-factor)*share)[:, None]
|
|
tips = helpers(joint_prefix)
|
|
all_vertices[tips] = pivot+(all_vertices[tips]-pivot)*factor
|
|
# A longer neck: everything the head carries rises a little, fading in up
|
|
# the neck and away from the shoulders.
|
|
neck_base, skull = group_centre('neck'), group_centre('head')
|
|
rise = np.clip((all_vertices[:, 1]-neck_base[1])/(skull[1]-neck_base[1]), 0, 1)
|
|
rise = rise*rise*(3-2*rise)*np.clip(1-(np.abs(all_vertices[:, 0])-0.05/metres)/(0.05/metres), 0, 1)
|
|
all_vertices[:, 1] += rise*0.014/metres
|
|
ids = sorted({index for face in groups['body'] for index in face})
|
|
lookup = {old: index for index, old in enumerate(ids)}
|
|
body = all_vertices[ids]
|
|
scale = 1.7 / np.ptp(body[:, 1])
|
|
origin = np.array([0, body[:, 1].min(), 0])
|
|
positions = (body - origin) * scale
|
|
|
|
def joint(name):
|
|
indices = sorted({index for face in groups['joint-' + name] for index in face})
|
|
return (all_vertices[indices].mean(axis=0) - origin) * scale
|
|
|
|
bones = []
|
|
|
|
def bone(role, side, start, end, parent=-1, finger=0, segment=0):
|
|
index = len(bones)
|
|
bones.append(dict(role=role, side=side, origin=np.array(start), tip=np.array(end),
|
|
parent=parent, finger=finger, segment=segment))
|
|
return index
|
|
|
|
# The arm and finger chains match the preview's anatomical joints; native
|
|
# standing and floor practices also need the pelvis, spine, head and legs.
|
|
bone(0, 0, joint('pelvis'), joint('spine-3'))
|
|
bone(1, 0, joint('spine-3'), joint('spine-1'), 0)
|
|
bone(2, 0, joint('spine-1'), joint('neck'), 1)
|
|
bone(3, 0, joint('neck'), joint('head-2'), 2)
|
|
arm_sets, leg_sets = [], []
|
|
for side, prefix in enumerate(('l', 'r')):
|
|
arm = []
|
|
parent = 2
|
|
for role, start, end in [(4, 'shoulder', 'elbow'), (5, 'elbow', 'hand'),
|
|
(6, 'hand', 'finger-3-1')]:
|
|
parent = bone(role, side, joint(prefix+'-'+start), joint(prefix+'-'+end), parent)
|
|
arm.append(parent)
|
|
hand = parent
|
|
for finger in range(1, 6):
|
|
parent = hand
|
|
for segment in range(3):
|
|
parent = bone(7, side, joint(f'{prefix}-finger-{finger}-{segment+1}'),
|
|
joint(f'{prefix}-finger-{finger}-{segment+2}'), parent, finger, segment)
|
|
arm.append(parent)
|
|
arm_sets.append(arm)
|
|
leg = []
|
|
parent = 0
|
|
for role, start, end in [(8, 'upper-leg', 'knee'), (9, 'knee', 'ankle'),
|
|
(10, 'ankle', 'toe-3-3')]:
|
|
parent = bone(role, side, joint(prefix+'-'+start), joint(prefix+'-'+end), parent)
|
|
leg.append(parent)
|
|
leg_sets.append(leg)
|
|
|
|
weights = np.zeros((len(ids), 4), dtype=np.float64)
|
|
joints = np.zeros((len(ids), 4), dtype=np.uint8)
|
|
for index, point in enumerate(positions):
|
|
side = 0 if point[0] >= 0 else 1
|
|
shoulder = joint(('l' if side == 0 else 'r') + '-shoulder')
|
|
hip = joint(('l' if side == 0 else 'r') + '-upper-leg')
|
|
candidates = list(range(4)) + arm_sets[side]
|
|
# Blend branch eligibility across the torso instead of cutting the mesh
|
|
# at an X/Y line: adjacent elbow/finger vertices must move together.
|
|
arm_gain = max(np.clip((abs(point[0])-0.25)/0.08, 0, 1),
|
|
np.clip((point[1]-joint('spine-3')[1])/0.15, 0, 1))
|
|
if point[1] < hip[1] + 0.06:
|
|
candidates = [0, 1] + leg_sets[side]
|
|
arm_gain = 1.0
|
|
distances = []
|
|
for at in candidates:
|
|
start, end = bones[at]['origin'], bones[at]['tip']
|
|
delta = end-start
|
|
along = np.clip(np.dot(point-start, delta) / np.dot(delta, delta), 0, 1)
|
|
distances.append(np.linalg.norm(point-start-along*delta))
|
|
scores = 1 / np.maximum(np.asarray(distances), 0.008)**4
|
|
for candidate, at in enumerate(candidates):
|
|
if at >= 4 and bones[at]['role'] <= 7:
|
|
scores[candidate] *= arm_gain*arm_gain
|
|
order = np.argsort(-scores)[:4]
|
|
raw = scores[order]
|
|
raw /= raw.sum()
|
|
joints[index, :len(order)] = np.asarray(candidates)[order]
|
|
weights[index, :len(order)] = raw
|
|
|
|
# MakeHuman's own CC0 rig weights for this mesh, folded onto these 46 bones.
|
|
# The procedural weights above remain only for vertices the rig leaves out.
|
|
def rig_bones(name):
|
|
side = 0 if name.endswith('.L') else 1
|
|
base = 4 + side*21
|
|
stem = name.split('.')[0]
|
|
if stem in ('root', 'pelvis', 'spine05', 'spine04'):
|
|
return [(0, 1.0)]
|
|
if stem in ('spine03', 'spine02'):
|
|
return [(1, 1.0)]
|
|
if stem in ('spine01', 'breast', 'clavicle'):
|
|
return [(2, 1.0)]
|
|
if stem == 'shoulder01':
|
|
return [(2, 0.5), (base, 0.5)]
|
|
if stem.startswith('upperarm'):
|
|
return [(base, 1.0)]
|
|
if stem.startswith('lowerarm'):
|
|
return [(base+1, 1.0)]
|
|
if stem in ('wrist',) or stem.startswith('metacarpal'):
|
|
return [(base+2, 1.0)]
|
|
if stem.startswith('finger'):
|
|
finger, segment = map(int, stem[6:].split('-'))
|
|
return [(base+3+(finger-1)*3+segment-1, 1.0)]
|
|
if stem.startswith('upperleg'):
|
|
return [(base+18, 1.0)]
|
|
if stem.startswith('lowerleg'):
|
|
return [(base+19, 1.0)]
|
|
if stem == 'foot' or stem.startswith('toe'):
|
|
return [(base+20, 1.0)]
|
|
return [(3, 1.0)] # neck, head, jaw, eyes and face
|
|
|
|
for index, (at, side) in enumerate(((0, 0), (0, 1))):
|
|
assert bones[4+side*21]['role'] == 4 and bones[4+side*21+18]['role'] == 8
|
|
gathered = [dict() for _ in ids]
|
|
for name, entries in rig['weights'].items():
|
|
targets = rig_bones(name)
|
|
for vertex, weight in entries:
|
|
if vertex in lookup:
|
|
for target, share in targets:
|
|
gathered[lookup[vertex]][target] = gathered[lookup[vertex]].get(target, 0.0)+weight*share
|
|
for index, influence in enumerate(gathered):
|
|
strongest = sorted(((target, weight) for target, weight in influence.items() if weight > 0.004),
|
|
key=lambda item: -item[1])[:4]
|
|
total = sum(weight for _, weight in strongest)
|
|
if total < 0.5:
|
|
continue
|
|
joints[index] = 0
|
|
weights[index] = 0.0
|
|
for slot, (target, weight) in enumerate(strongest):
|
|
joints[index, slot] = target
|
|
weights[index, slot] = weight/total
|
|
|
|
# MakeHuman hands the groin and buttock from pelvis to thigh within a few
|
|
# millimetres, which tears the surface open in a forward fold or a deep
|
|
# stance. Diffuse that hand-over across the surface around the hips, and the
|
|
# shoulder's chest-to-arm hand-over the same way for arms raised overhead;
|
|
# other bones' shares, the hands and the fingers stay as rigged.
|
|
face_triangles = np.array([[lookup[face[0]], lookup[face[at]], lookup[face[at+1]]]
|
|
for face in groups['body'] for at in range(1, len(face)-1)], dtype=np.int64)
|
|
pairs = np.concatenate([face_triangles[:, [0, 1]], face_triangles[:, [1, 2]], face_triangles[:, [2, 0]]])
|
|
pairs = np.unique(np.concatenate([pairs, pairs[:, ::-1]]), axis=0)
|
|
degree = np.bincount(pairs[:, 0], minlength=len(ids)).astype(np.float64)
|
|
dense = np.zeros((len(ids), len(bones)))
|
|
for slot in range(4):
|
|
np.add.at(dense, (np.arange(len(ids)), joints[:, slot]), weights[:, slot])
|
|
arm_share = dense[:, [at for at, item in enumerate(bones) if 5 <= item['role'] <= 7]].sum(axis=1)
|
|
|
|
def diffuse(members, zone, steps):
|
|
shares = dense[:, members]
|
|
mass = shares.sum(axis=1)
|
|
active = zone & (mass > 0.02)
|
|
for _ in range(steps):
|
|
total = np.zeros_like(shares)
|
|
np.add.at(total, pairs[:, 0], shares[pairs[:, 1]])
|
|
mean = total/np.maximum(degree, 1)[:, None]
|
|
mixed = shares*0.5+mean*0.5
|
|
scale = mass/np.maximum(mixed.sum(axis=1), 1e-12)
|
|
shares[active] = mixed[active]*scale[active, None]
|
|
dense[:, members] = shares
|
|
|
|
hips_y = (joint('l-upper-leg')[1]+joint('r-upper-leg')[1])/2
|
|
hip_zone = (positions[:, 1] > hips_y-0.24) & (positions[:, 1] < hips_y+0.07) & (arm_share < 0.01)
|
|
thighs = [4+18, 4+21+18]
|
|
diffuse([0]+thighs, hip_zone, 120)
|
|
# The thighs never reach above the hip crease: a lifted or spread leg must
|
|
# not drag the waist out with it.
|
|
fade = np.clip((hips_y+0.07-positions[:, 1])/0.09, 0, 1)
|
|
for thigh in thighs:
|
|
removed = dense[:, thigh]*(1-fade)
|
|
dense[:, thigh] -= removed
|
|
dense[:, 0] += removed
|
|
for side in (0, 1):
|
|
shoulder = joint(('l' if side == 0 else 'r')+'-shoulder')
|
|
near = np.linalg.norm(positions-shoulder, axis=1) < 0.16
|
|
diffuse([1, 2, 4+side*21], near & (arm_share < 0.01), 40)
|
|
for index in range(len(ids)):
|
|
strongest = np.argsort(-dense[index])[:4]
|
|
shares = dense[index, strongest]
|
|
shares[shares < 0.004] = 0.0
|
|
joints[index] = strongest
|
|
weights[index] = shares/shares.sum()
|
|
|
|
# The middle waist belongs to the trunk even when a hand passes near it.
|
|
waist = (positions[:, 1] > joint('pelvis')[1]+0.06) & (positions[:, 1] < joint('spine-3')[1]) & (np.abs(positions[:, 0]) < 0.25)
|
|
arm_roles = np.array([4 <= item['role'] <= 7 for item in bones])
|
|
assert not np.any(arm_roles[joints[waist]] & (weights[waist] > 0)), 'Waist cannot follow an arm'
|
|
# Distal fingers must never cross back into the trunk-only region. The
|
|
# shoulder's outward slope is capped before the hand and thumb surface.
|
|
hands = (np.abs(positions[:, 0]) > 0.40) & (positions[:, 2] > 0.20)
|
|
assert np.all(np.sum(weights[hands] * (joints[hands] < 4), axis=1) < 0.1), 'Fingers cannot follow the trunk'
|
|
|
|
triangles = []
|
|
for face in groups['body']:
|
|
for index in range(1, len(face)-1):
|
|
triangles.append([lookup[face[0]], lookup[face[index]], lookup[face[index+1]]])
|
|
triangles = np.array(triangles, dtype=np.int64)
|
|
normals = np.zeros_like(positions)
|
|
face_normals = np.cross(positions[triangles[:, 1]]-positions[triangles[:, 0]],
|
|
positions[triangles[:, 2]]-positions[triangles[:, 0]])
|
|
for corner in range(3):
|
|
np.add.at(normals, triangles[:, corner], face_normals)
|
|
normals /= np.maximum(np.linalg.norm(normals, axis=1)[:, None], 1e-12)
|
|
uvs = np.column_stack((positions[:, 0]*3+0.5, positions[:, 1]*3))
|
|
# Regions keep the same surface and skin weights: skin, tunic, trousers, hair.
|
|
hip_height = joint('pelvis')[1]
|
|
neck_height = joint('neck')[1]
|
|
head = joint('head')
|
|
cuffs = [abs(joint(prefix+'-hand')[0])-0.025 for prefix in ('l', 'r')]
|
|
ankles = [joint(prefix+'-ankle')[1]+0.02 for prefix in ('l', 'r')]
|
|
|
|
eye_height = joint('l-eye')[1]
|
|
|
|
def hairline(points):
|
|
"""Positive on the hair: a hairline high on the forehead, lower over
|
|
the temples, behind the ears and down to the nape; the ears stay bare."""
|
|
points = np.atleast_2d(points)
|
|
x, y, z = points[:, 0], points[:, 1], points[:, 2]
|
|
turn = np.degrees(np.arctan2(np.abs(x), z-0.02))
|
|
height = eye_height+np.interp(turn, [0, 20, 45, 65, 85, 105, 125, 180],
|
|
[0.056, 0.055, 0.047, 0.030, 0.010, 0.000, -0.022, -0.045])
|
|
value = y-height
|
|
ears = (y < eye_height+0.002) & (np.abs(x) > 0.070)
|
|
value = np.where(ears, np.minimum(value, 0.070-np.abs(x)), value)
|
|
return np.where(y < 1.44, -1.0, value)
|
|
|
|
def neckline(points):
|
|
"""Positive below the mandarin top's round neckline, a little lower in
|
|
front, where its stand-up collar begins."""
|
|
points = np.atleast_2d(points)
|
|
x, y, z = points[:, 0], points[:, 1], points[:, 2]
|
|
front = 0.012*np.clip(1-np.abs(x)/0.07, 0, 1)*np.clip((z-0.02)/0.04, 0, 1)
|
|
return (neck_height-0.008-front)-y
|
|
|
|
def region_of(points):
|
|
points = np.atleast_2d(points)
|
|
x, y, z = points[:, 0], points[:, 1], points[:, 2]
|
|
regions = np.zeros(len(points), dtype=np.uint8)
|
|
# Sleeves continue over the shoulder cap. A horizontal collar cutoff alone
|
|
# leaves isolated bare patches where the arm rises above the neck cutoff.
|
|
regions[(y > hip_height-0.09) & ((neckline(points) > 0) |
|
|
((np.abs(x) > 0.115) & (y < neck_height+0.025)))] = 1
|
|
regions[y <= hip_height-0.04] = 2
|
|
for cuff, ankle in zip(cuffs, ankles):
|
|
# Hands hang below the hips in the bind pose; only arms reach this wide.
|
|
regions[(np.abs(x) > cuff) & (y > 0.5)] = 0
|
|
regions[y < ankle] = 0
|
|
regions[hairline(points) > 0] = 3
|
|
return regions
|
|
|
|
# Clean painted hems: split each triangle that crosses a region boundary
|
|
# exactly along the boundary's plane, then give every region its own copy
|
|
# of the shared hem vertices. Surface and skin stay continuous.
|
|
def plane(axis, value):
|
|
return lambda points: np.atleast_2d(points)[:, axis]-value
|
|
|
|
planes = [(1, hip_height-0.04), (1, neck_height+0.025), (0, 0.115), (0, -0.115)]
|
|
planes += [(0, cuff) for cuff in cuffs] + [(0, -cuff) for cuff in cuffs] + [(1, ankle) for ankle in ankles]
|
|
cuts = [(('plane',)+item, plane(*item)) for item in planes] + [(('neckline',), neckline), (('hairline',), hairline)]
|
|
points, skin_joints, skin_weights = list(positions), list(joints), list(weights)
|
|
surface_normals = list(normals)
|
|
edges = {}
|
|
|
|
def hem_point(a, b, name, cut):
|
|
key = (min(a, b), max(a, b), name)
|
|
if key not in edges:
|
|
da, db = float(cut(points[a])[0]), float(cut(points[b])[0])
|
|
t = da/(da-db)
|
|
points.append(points[a]+(points[b]-points[a])*t)
|
|
normal = surface_normals[a]*(1-t)+surface_normals[b]*t
|
|
surface_normals.append(normal/max(np.linalg.norm(normal), 1e-12))
|
|
mixed = {}
|
|
for chain, share in ((a, 1-t), (b, t)):
|
|
for at, weight in zip(skin_joints[chain], skin_weights[chain]):
|
|
mixed[int(at)] = mixed.get(int(at), 0.0)+weight*share
|
|
strongest = sorted(mixed.items(), key=lambda item: -item[1])[:4]
|
|
total = sum(weight for _, weight in strongest)
|
|
skin_joints.append(np.array([at for at, _ in strongest]+[0]*(4-len(strongest)), dtype=np.uint8))
|
|
skin_weights.append(np.array([weight/total for _, weight in strongest]+[0.0]*(4-len(strongest))))
|
|
edges[key] = len(points)-1
|
|
return edges[key]
|
|
|
|
faces = [list(face) for face in triangles]
|
|
for name, cut in cuts:
|
|
split = []
|
|
for face in faces:
|
|
corners = np.array([points[at] for at in face])
|
|
distance = cut(corners)
|
|
if len(set(region_of(corners))) == 1 or not (np.any(distance > 1e-7) and np.any(distance < -1e-7)):
|
|
split.append(face)
|
|
continue
|
|
side = np.where(np.abs(distance) <= 1e-7, 0, np.sign(distance)).astype(int)
|
|
if 0 in side:
|
|
# One corner lies on the plane: cut the opposite edge once.
|
|
on = int(np.where(side == 0)[0][0])
|
|
a, b, c = face[on], face[(on+1) % 3], face[(on+2) % 3]
|
|
middle = hem_point(b, c, name, cut)
|
|
split += [[a, b, middle], [a, middle, c]]
|
|
continue
|
|
lone = int([at for at in range(3) if list(side).count(side[at]) == 1][0])
|
|
a, b, c = face[lone], face[(lone+1) % 3], face[(lone+2) % 3]
|
|
ab, ac = hem_point(a, b, name, cut), hem_point(a, c, name, cut)
|
|
split += [[a, ab, ac], [ab, b, c], [ab, c, ac]]
|
|
faces = split
|
|
points = np.array(points)
|
|
face_regions = region_of(np.array([points[face].mean(axis=0) for face in faces]))
|
|
# Thumbs sit inside the cuff plane in the bind pose: whatever the hand and
|
|
# fingers carry is skin.
|
|
hand_bones = np.array([item['role'] in (6, 7) for item in bones])
|
|
hand_share = [float(np.sum(skin_weights[at][hand_bones[skin_joints[at]]])) for at in range(len(points))]
|
|
for at, face in enumerate(faces):
|
|
if min(hand_share[corner] for corner in face) > 0.5:
|
|
face_regions[at] = 0
|
|
copies = {}
|
|
order = []
|
|
for face, region in zip(faces, face_regions):
|
|
for corner, at in enumerate(face):
|
|
key = (at, int(region))
|
|
if key not in copies:
|
|
copies[key] = len(order)
|
|
order.append(key)
|
|
face[corner] = copies[key]
|
|
source = np.array([at for at, _ in order])
|
|
regions = np.array([region for _, region in order], dtype=np.uint8)
|
|
positions = points[source]
|
|
normals = np.array(surface_normals)[source]
|
|
joints = np.array(skin_joints)[source]
|
|
weights = np.array(skin_weights)[source]
|
|
triangles = np.array(faces, dtype=np.int64)
|
|
# The head. MakeHuman's own eyeballs sit in the sockets under painted lids;
|
|
# a hair shell rises from nothing at the hairline to a centimetre over the
|
|
# crown; a low bun sits at the back. All follow the head bone alone.
|
|
def outward_faces(vertices, faces, center):
|
|
faces = np.array(faces, dtype=np.int64)
|
|
normal = np.cross(vertices[faces[:, 1]]-vertices[faces[:, 0]], vertices[faces[:, 2]]-vertices[faces[:, 0]])
|
|
flip = np.einsum('ij,ij->i', normal, vertices[faces].mean(axis=1)-center) < 0
|
|
faces[flip] = faces[flip][:, ::-1]
|
|
return faces
|
|
|
|
def vertex_normals(vertices, faces):
|
|
result = np.zeros_like(vertices)
|
|
face = np.cross(vertices[faces[:, 1]]-vertices[faces[:, 0]], vertices[faces[:, 2]]-vertices[faces[:, 0]])
|
|
for corner in range(3):
|
|
np.add.at(result, faces[:, corner], face)
|
|
return result/np.maximum(np.linalg.norm(result, axis=1)[:, None], 1e-12)
|
|
|
|
extras = []
|
|
hair_faces = triangles[np.all(regions[triangles] == 3, axis=1)]
|
|
used = np.unique(hair_faces)
|
|
depth = hairline(positions[used])
|
|
# Sleek black hair combed back close to the head, a little fuller
|
|
# towards the crown where it gathers into the bun.
|
|
top = np.clip((positions[used, 1]-eye_height-0.03)/0.07, 0, 1)
|
|
back = np.clip((joint('head')[2]+0.01-positions[used, 2])/0.08, 0, 1)
|
|
sides = np.clip(np.abs(positions[used, 0])/0.07, 0, 1)
|
|
above = np.clip((positions[used, 1]-eye_height)/0.03, 0, 1)
|
|
thickness = (0.004+0.007*top+0.006*top*back+0.004*sides*above)*np.clip(depth/0.03, 0, 1)**0.8
|
|
shell = positions[used]+normals[used]*thickness[:, None]
|
|
remap = np.full(len(positions), -1, dtype=np.int64)
|
|
remap[used] = np.arange(len(used))
|
|
shell_faces = remap[hair_faces]
|
|
extras.append((shell, vertex_normals(shell, shell_faces), np.full(len(shell), 3), shell_faces))
|
|
rings, segments = 10, 18
|
|
# A neat high bun on the back of the crown.
|
|
crown_ring = positions[used][np.abs(positions[used, 1]-(eye_height+0.095)) < 0.008]
|
|
bun_center = np.array([0.0, eye_height+0.095, crown_ring[:, 2].min()+0.004])
|
|
bun_radii = np.array([0.040, 0.034, 0.038])
|
|
units = np.array([[np.sin(np.pi*ring/rings)*np.cos(2*np.pi*at/segments), np.cos(np.pi*ring/rings),
|
|
np.sin(np.pi*ring/rings)*np.sin(2*np.pi*at/segments)]
|
|
for ring in range(rings+1) for at in range(segments)])
|
|
bun = bun_center+units*bun_radii
|
|
bun_faces = []
|
|
for ring in range(rings):
|
|
for at in range(segments):
|
|
a, b = ring*segments+at, ring*segments+(at+1) % segments
|
|
c, d = a+segments, b+segments
|
|
if ring > 0:
|
|
bun_faces.append([a, b, d])
|
|
if ring < rings-1:
|
|
bun_faces.append([a, d, c])
|
|
bun_faces = outward_faces(bun, bun_faces, bun_center)
|
|
extras.append((bun, vertex_normals(bun, bun_faces), np.full(len(bun), 3), bun_faces))
|
|
for prefix in ('l', 'r'):
|
|
indices = sorted({index for face in groups[f'helper-{prefix}-eye'] for index in face})
|
|
eye_lookup = {old: at for at, old in enumerate(indices)}
|
|
eye = (all_vertices[indices]-origin)*scale
|
|
center = eye.mean(axis=0)
|
|
eye_faces = outward_faces(eye, [[eye_lookup[face[0]], eye_lookup[face[at]], eye_lookup[face[at+1]]]
|
|
for face in groups[f'helper-{prefix}-eye'] for at in range(1, len(face)-1)], center)
|
|
extras.append((eye, vertex_normals(eye, eye_faces), np.zeros(len(eye)), eye_faces))
|
|
head_index = [at for at, item in enumerate(bones) if item['role'] == 3][0]
|
|
body_count = len(positions)
|
|
crown = positions[:, 1].max()
|
|
for vertices, vertex_normal, vertex_region, faces_of in extras:
|
|
base = len(positions)
|
|
positions = np.vstack([positions, vertices])
|
|
normals = np.vstack([normals, vertex_normal])
|
|
joints = np.vstack([joints, np.tile(np.array([head_index, 0, 0, 0], dtype=np.uint8), (len(vertices), 1))])
|
|
weights = np.vstack([weights, np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (len(vertices), 1))])
|
|
regions = np.concatenate([regions, np.asarray(vertex_region, dtype=np.uint8)])
|
|
triangles = np.vstack([triangles, np.asarray(faces_of, dtype=np.int64)+base])
|
|
|
|
# Her Tai Chi silk suit: shells over the body, skinned by the same rig. The
|
|
# mandarin top is fitted over the chest and falls straight from the bust and
|
|
# shoulder blades to below the hips, slit at the sides, with a stand-up
|
|
# collar and a placket of frog-knot buttons; the long sleeves and the
|
|
# trousers fall a little wider towards the wrist and ankle.
|
|
# Regions: 0 skin, 1 top, 2 trousers, 3 hair, 4 trim (the placket's frog buttons).
|
|
role_of = np.array([item['role'] for item in bones])
|
|
|
|
def share(rows, shares, roles):
|
|
return np.sum(shares*np.isin(role_of[rows], roles), axis=1)
|
|
|
|
def smooth(value):
|
|
value = np.clip(value, 0, 1)
|
|
return value*value*(3-2*value)
|
|
|
|
arm = share(joints, weights, [4, 5, 6, 7])
|
|
trunk_points = (np.arange(len(positions)) < body_count) & (arm < 0.15)
|
|
hips_joint = (joint('l-upper-leg')+joint('r-upper-leg'))/2
|
|
armpit_y = (joint('l-shoulder')[1]+joint('r-shoulder')[1])/2-0.09
|
|
hem_y = hips_joint[1]-0.05
|
|
|
|
def slab(height, mask=trunk_points, half=0.012):
|
|
return positions[mask & (np.abs(positions[:, 1]-height) < half)]
|
|
|
|
heights = np.arange(hip_height+0.02, joint('spine-1')[1], 0.005)
|
|
waist_y = heights[int(np.argmin([np.ptp(slab(h, half=0.006)[:, 0]) for h in heights]))]
|
|
grid_y = np.arange(hem_y-0.04, neck_height+0.0001, 0.01)
|
|
centre_z = np.array([(lambda s: (s[:, 2].min()+s[:, 2].max())/2)(slab(h)) for h in grid_y])
|
|
centre_z = np.convolve(np.pad(centre_z, 2, mode='edge'), np.ones(5)/5, mode='valid')
|
|
|
|
def trunk_z(y):
|
|
return np.interp(y, grid_y, centre_z)
|
|
|
|
K = 72
|
|
angles = np.arange(K)*2*np.pi/K
|
|
directions = np.column_stack((np.sin(angles), np.cos(angles)))
|
|
hang = np.zeros((len(grid_y), K))
|
|
for j, h in enumerate(grid_y):
|
|
s = slab(h)
|
|
hang[j] = (np.column_stack((s[:, 0], s[:, 2]-trunk_z(h))) @ directions.T).max(axis=0)
|
|
# Cloth falls straight from the widest place above it, under the armpits.
|
|
top = int(np.searchsorted(grid_y, armpit_y))
|
|
for j in range(top-1, -1, -1):
|
|
hang[j] = np.maximum(hang[j], hang[j+1])
|
|
# Soft cloth settles part of the way back onto her below the widest place.
|
|
hang = 0.65*hang+0.35*np.array([(np.column_stack((s[:, 0], s[:, 2]-trunk_z(h))) @ directions.T).max(axis=0)
|
|
for h, s in ((h, slab(h)) for h in grid_y)])
|
|
for _ in range(3):
|
|
hang = 0.5*hang+0.25*np.roll(hang, 1, axis=1)+0.25*np.roll(hang, -1, axis=1)
|
|
hang[1:-1] = 0.5*hang[1:-1]+0.25*hang[:-2]+0.25*hang[2:]
|
|
|
|
def hanging_radius(theta, y):
|
|
fj = np.clip((y-grid_y[0])/0.01, 0, len(grid_y)-1.001)
|
|
j = fj.astype(int)
|
|
tj = fj-j
|
|
fk = (theta % (2*np.pi))/(2*np.pi)*K
|
|
k = np.floor(fk).astype(int) % K
|
|
tk = fk-np.floor(fk)
|
|
k1 = (k+1) % K
|
|
a = hang[j, k]*(1-tk)+hang[j, k1]*tk
|
|
b = hang[j+1, k]*(1-tk)+hang[j+1, k1]*tk
|
|
return a*(1-tj)+b*tj
|
|
|
|
def arm_progress(points):
|
|
result = np.zeros(len(points))
|
|
for side, prefix in enumerate(('l', 'r')):
|
|
s, e, h = joint(prefix+'-shoulder'), joint(prefix+'-elbow'), joint(prefix+'-hand')
|
|
upper, lower = np.linalg.norm(e-s), np.linalg.norm(h-e)
|
|
mine = (points[:, 0] >= 0) == (side == 0)
|
|
p = points[mine]
|
|
a = np.clip((p-s) @ (e-s)/upper**2, 0, 1)
|
|
b = np.clip((p-e) @ (h-e)/lower**2, 0, 1)
|
|
da = np.linalg.norm(p-(s+a[:, None]*(e-s)), axis=1)
|
|
db = np.linalg.norm(p-(e+b[:, None]*(h-e)), axis=1)
|
|
result[mine] = np.where(da < db, a*upper, upper+b*lower)/(upper+lower)
|
|
return result
|
|
|
|
dense_body = np.zeros((body_count, len(bones)))
|
|
for slot in range(4):
|
|
np.add.at(dense_body, (np.arange(body_count), joints[:body_count, slot]), weights[:body_count, slot])
|
|
|
|
def nearest_weights(points, near=8, low=None, high=None):
|
|
"""Skin weights for cloth away from the surface: the weights of the
|
|
nearest trunk and leg vertices between LOW and HIGH, closer ones counting
|
|
more."""
|
|
low = hem_y-0.12 if low is None else low
|
|
high = waist_y+0.15 if high is None else high
|
|
candidates = np.where(trunk_points[:body_count] & (positions[:body_count, 1] > low) &
|
|
(positions[:body_count, 1] < high))[0]
|
|
result = np.zeros((len(points), len(bones)))
|
|
for at, point in enumerate(points):
|
|
distance = np.linalg.norm(positions[candidates]-point, axis=1)
|
|
order = np.argsort(distance)[:near]
|
|
share_of = 1/np.maximum(distance[order], 0.005)**2
|
|
result[at] = share_of @ dense_body[candidates[order]]/share_of.sum()
|
|
return result
|
|
|
|
def strongest(dense):
|
|
rows = np.argsort(-dense, axis=1)[:, :4]
|
|
shares = np.take_along_axis(dense, rows, axis=1)
|
|
shares[shares < 0.004] = 0.0
|
|
return rows.astype(np.uint8), shares/shares.sum(axis=1)[:, None]
|
|
|
|
def grid_faces(rows, columns, wrap):
|
|
faces = []
|
|
span = columns if wrap else columns-1
|
|
for j in range(rows-1):
|
|
for k in range(span):
|
|
a, b = j*columns+k, j*columns+(k+1) % columns
|
|
faces += [[a, b, b+columns], [a, b+columns, a+columns]]
|
|
return np.array(faces, dtype=np.int64)
|
|
|
|
def facing_out(points, faces, centre_of):
|
|
normal = np.cross(points[faces[:, 1]]-points[faces[:, 0]], points[faces[:, 2]]-points[faces[:, 0]])
|
|
middle = points[faces].mean(axis=1)
|
|
out = middle-centre_of(middle)
|
|
flip = np.einsum('ij,ij->i', normal, out) < 0
|
|
faces[flip] = faces[flip][:, ::-1]
|
|
return faces
|
|
|
|
def trunk_axis(points):
|
|
return np.column_stack((np.zeros(len(points)), points[:, 1], trunk_z(points[:, 1])))
|
|
|
|
cloth = [] # (points, normals, joints, weights, region, faces, source positions or None, hang, UVs or None)
|
|
|
|
# The mandarin top: the body's own surface lifted a little off it, fitted
|
|
# over the chest and along the long sleeves.
|
|
top_faces = triangles[np.all(regions[triangles] == 1, axis=1) & np.all(triangles < body_count, axis=1)]
|
|
top_faces = top_faces[(positions[top_faces][:, :, 1].min(axis=1) > waist_y-0.03) | (arm[top_faces].mean(axis=1) > 0.5)]
|
|
used = np.unique(top_faces)
|
|
p, n = positions[used], normals[used]
|
|
bust_y = slab((waist_y+armpit_y)/2, half=0.06)[:, 1][np.argmax(slab((waist_y+armpit_y)/2, half=0.06)[:, 2])]
|
|
sleeve = smooth((arm[used]-0.2)/0.6)
|
|
lift = np.interp(p[:, 1], [waist_y, bust_y, neck_height-0.04], [0.010, 0.007, 0.004])*(1-sleeve)
|
|
lift += (0.006+0.014*arm_progress(p)**1.5)*sleeve
|
|
q = p+n*lift[:, None]
|
|
rel = np.column_stack((q[:, 0], q[:, 2]-trunk_z(p[:, 1])))
|
|
theta = np.arctan2(rel[:, 0], rel[:, 1])
|
|
push = np.maximum(hanging_radius(theta, p[:, 1])+lift-np.linalg.norm(rel, axis=1), 0)
|
|
push *= (1-sleeve)*np.clip((armpit_y-p[:, 1])/0.06, 0, 1)
|
|
q[:, 0] += np.sin(theta)*push
|
|
q[:, 2] += np.cos(theta)*push
|
|
remap = np.full(len(positions), -1, dtype=np.int64)
|
|
remap[used] = np.arange(len(used))
|
|
faces_of = remap[top_faces]
|
|
top_shell = q
|
|
cloth.append((q, vertex_normals(q, faces_of), joints[used], weights[used], 1, faces_of, p, np.zeros(len(q)), None))
|
|
|
|
# The top's hip-length lower part, from just above the waist to below the
|
|
# hip bones, slit at both sides.
|
|
rows_y = np.linspace(waist_y+0.035, hem_y, 12)
|
|
fall = (rows_y[0]-rows_y)/(rows_y[0]-rows_y[-1])
|
|
skirt = []
|
|
for y, f in zip(rows_y, fall):
|
|
r = hanging_radius(angles, np.full(K, y))+0.010+0.012*f**1.5
|
|
skirt.append(np.column_stack((np.sin(angles)*r, np.full(K, y), trunk_z(y)+np.cos(angles)*r)))
|
|
skirt = np.vstack(skirt)
|
|
faces_of = grid_faces(len(rows_y), K, True)
|
|
side = np.abs(np.sin(angles[faces_of[:, 0] % K]+np.pi/K)) > 0.97
|
|
faces_of = facing_out(skirt, faces_of[~(side & (faces_of[:, 0]//K >= len(rows_y)//2))], trunk_axis)
|
|
dense = nearest_weights(skirt).reshape(len(rows_y), K, len(bones))
|
|
for _ in range(2):
|
|
dense = 0.5*dense+0.25*np.roll(dense, 1, axis=1)+0.25*np.roll(dense, -1, axis=1)
|
|
# The hand-over from the pelvis to the thighs spreads down the whole hem,
|
|
# so a lifted leg draws it out gradually instead of tearing a band.
|
|
for _ in range(12):
|
|
dense[1:-1] = 0.5*dense[1:-1]+0.25*dense[:-2]+0.25*dense[2:]
|
|
dense[-1] = 0.5*dense[-1]+0.5*dense[-2]
|
|
rows, shares = strongest(dense.reshape(-1, len(bones)))
|
|
cloth.append((skirt, vertex_normals(skirt, faces_of), rows, shares, 1, faces_of, None, np.repeat(fall, K), None))
|
|
|
|
# The stand-up mandarin collar round the base of her neck, leaning in a
|
|
# little at its top.
|
|
collar_y = neck_height+np.array([-0.012, 0.006, 0.022])
|
|
collar_angles = np.arange(48)*2*np.pi/48
|
|
collar = []
|
|
for y, give in zip(collar_y, (0.005, 0.004, 0.002)):
|
|
s = positions[:body_count][(arm[:body_count] < 0.15) & (np.abs(positions[:body_count, 1]-y) < 0.006)]
|
|
middle = (s[:, 2].min()+s[:, 2].max())/2
|
|
reach = (np.column_stack((s[:, 0], s[:, 2]-middle)) @ np.column_stack((np.sin(collar_angles), np.cos(collar_angles))).T).max(axis=0)
|
|
collar.append(np.column_stack((np.sin(collar_angles)*(reach+give), np.full(48, y), middle+np.cos(collar_angles)*(reach+give))))
|
|
collar = np.vstack(collar)
|
|
faces_of = facing_out(collar, grid_faces(3, 48, True), lambda m: np.column_stack((np.zeros(len(m)), m[:, 1], np.full(len(m), collar[:, 2].mean()))))
|
|
rows, shares = strongest(nearest_weights(collar, low=neck_height-0.05, high=neck_height+0.05))
|
|
cloth.append((collar, vertex_normals(collar, faces_of), rows, shares, 1, faces_of, None, np.zeros(len(collar)), None))
|
|
|
|
# The placket down her front with its frog-knot buttons, just over the top.
|
|
front = np.vstack([top_shell[np.abs(top_shell[:, 0]) < 0.01], skirt[np.abs(skirt[:, 0]) < 0.01]])
|
|
front = front[np.argsort(front[:, 1])]
|
|
placket_y = np.arange(neck_height-0.012, hem_y+0.004, -0.01)
|
|
reach = np.array([front[np.abs(front[:, 1]-y) < 0.012][:, 2].max() for y in placket_y])
|
|
placket = np.vstack([[[side*0.015, y, z+0.0025] for side in (-1, 1)] for y, z in zip(placket_y, reach)])
|
|
faces_of = facing_out(placket, grid_faces(len(placket_y), 2, False), trunk_axis)
|
|
rows, shares = strongest(nearest_weights(placket, low=hem_y-0.12, high=neck_height+0.02))
|
|
placket_hang = np.repeat(np.clip((rows_y[0]-placket_y)/(rows_y[0]-rows_y[-1]), 0, 1), 2)
|
|
placket_uv = np.column_stack((np.tile([0.0, 1.0], len(placket_y)), np.repeat((placket_y[0]-placket_y)/0.045, 2)))
|
|
cloth.append((placket, vertex_normals(placket, faces_of), rows, shares, 4, faces_of, None, placket_hang, placket_uv))
|
|
|
|
# The trousers: the legs' surface lifted off them, falling wide in soft
|
|
# silk and gathered again at the ankle.
|
|
leg_faces = triangles[np.all(regions[triangles] == 2, axis=1) & np.all(triangles < body_count, axis=1)]
|
|
used = np.unique(leg_faces)
|
|
p, n = positions[used], normals[used]
|
|
down = np.clip((hip_height-0.04-p[:, 1])/(hip_height-0.04-np.mean(ankles)), 0, 1)
|
|
lift = 0.012+0.034*smooth(down/0.75)-0.026*smooth((down-0.85)/0.15)
|
|
q = p+n*lift[:, None]
|
|
remap = np.full(len(positions), -1, dtype=np.int64)
|
|
remap[used] = np.arange(len(used))
|
|
faces_of = remap[leg_faces]
|
|
cloth.append((q, vertex_normals(q, faces_of), joints[used], weights[used], 2, faces_of, p, np.zeros(len(q)), None))
|
|
|
|
# Painted textures follow the form: the trunk and the head are wrapped
|
|
# about the vertical, each arm and leg about its own length, so brush
|
|
# strokes run down the body and along the limbs. Each wrap is mirrored at
|
|
# its back and front, so it has no seam.
|
|
CLOTH_TILE = 0.30
|
|
HAIR_TILE = 0.18
|
|
|
|
def trunk_uv(points):
|
|
turn = np.abs(np.arctan2(points[:, 0], points[:, 2]-trunk_z(points[:, 1])))/np.pi
|
|
return np.column_stack((turn*0.45/CLOTH_TILE, points[:, 1]/CLOTH_TILE))
|
|
|
|
def head_uv(points):
|
|
turn = np.abs(np.arctan2(points[:, 0], points[:, 2]-joint('head')[2]))/np.pi
|
|
return np.column_stack((turn*0.28/HAIR_TILE, points[:, 1]/HAIR_TILE))
|
|
|
|
def limb_uv(points, start, end, half_round):
|
|
axis = (end-start)/np.linalg.norm(end-start)
|
|
forward = np.array([0.0, 0.0, 1.0])-axis*axis[2]
|
|
forward /= np.linalg.norm(forward)
|
|
across = np.cross(axis, forward)
|
|
rel = points-start
|
|
turn = np.abs(np.arctan2(rel @ across, rel @ forward))/np.pi
|
|
return np.column_stack((turn*half_round/CLOTH_TILE, -(rel @ axis)/CLOTH_TILE))
|
|
|
|
def wrapped_uv(points, rows, shares):
|
|
dominant = rows[np.arange(len(rows)), np.argmax(shares, axis=1)]
|
|
roles = role_of[dominant]
|
|
sides = np.array([item['side'] for item in bones])[dominant]
|
|
result = trunk_uv(points)
|
|
head = roles == 3
|
|
result[head] = head_uv(points[head])
|
|
for side, prefix in enumerate(('l', 'r')):
|
|
limb = (roles >= 4) & (roles <= 7) & (sides == side)
|
|
result[limb] = limb_uv(points[limb], joint(prefix+'-shoulder'), joint(prefix+'-hand'), 0.13)
|
|
limb = (roles >= 8) & (sides == side)
|
|
result[limb] = limb_uv(points[limb], joint(prefix+'-upper-leg'), joint(prefix+'-ankle'), 0.25)
|
|
return result
|
|
|
|
# Black cloth shoes: below the trouser hems her feet take the sleek black
|
|
# of her hair.
|
|
shoes = (np.arange(len(positions)) < body_count) & (regions == 0) & (positions[:, 1] <= max(ankles)+1e-6)
|
|
regions[shoes] = 3
|
|
uvs = wrapped_uv(positions, joints, weights)
|
|
hangs = np.zeros(len(positions))
|
|
hair = (regions == 3) & ~shoes
|
|
# Hair strokes run from the hairline back into the bun.
|
|
swept = positions[hair]-bun_center
|
|
uvs[hair] = np.column_stack((np.abs(np.arctan2(swept[:, 0], swept[:, 1]))/np.pi*0.25/HAIR_TILE,
|
|
np.linalg.norm(swept, axis=1)/HAIR_TILE))
|
|
for points, vertex_normal, rows, shares, region, faces_of, source, hanging, given_uv in cloth:
|
|
base = len(positions)
|
|
if given_uv is not None:
|
|
uv = given_uv
|
|
elif source is None:
|
|
uv = trunk_uv(points)
|
|
else:
|
|
uv = wrapped_uv(source, rows, shares)
|
|
positions = np.vstack([positions, points])
|
|
normals = np.vstack([normals, vertex_normal])
|
|
joints = np.vstack([joints, np.asarray(rows, dtype=np.uint8)])
|
|
weights = np.vstack([weights, shares])
|
|
regions = np.concatenate([regions, np.full(len(points), region, dtype=np.uint8)])
|
|
triangles = np.vstack([triangles, faces_of+base])
|
|
uvs = np.vstack([uvs, uv])
|
|
hangs = np.concatenate([hangs, hanging])
|
|
|
|
# The face is painted by face.webp, projected from the front onto the
|
|
# head: its eyes, mouth and the mesh's own match exactly, and the painting
|
|
# fades out towards the ears, the hairline and under the chin.
|
|
FACE = dict(size=(1254, 1254), right_eye=(480, 520), left_eye=(770, 520), mouth=(628, 782))
|
|
face_ready = FACE['right_eye'] != (0, 0)
|
|
mouth_point = np.array([0.0, joint('mouth')[1]-0.027])
|
|
mesh_marks = np.array([joint('r-eye')[:2], joint('l-eye')[:2], mouth_point])
|
|
picture = np.array([FACE['right_eye'], FACE['left_eye'], FACE['mouth']], dtype=np.float64)
|
|
picture = np.column_stack((picture[:, 0]/FACE['size'][0], 1-picture[:, 1]/FACE['size'][1]))
|
|
mapping = np.linalg.solve(np.column_stack((mesh_marks, np.ones(3))), picture)
|
|
details = np.column_stack((positions[:, :2], np.ones(len(positions)))) @ mapping
|
|
x, y = positions[:, 0], positions[:, 1]
|
|
oval = ((x/0.078)**2+((y-eye_height+0.02)/0.100)**2)**0.5
|
|
mask = smooth((normals[:, 2]-0.12)/0.4)*smooth((1.0-oval)/0.25)*smooth(-hairline(positions)/0.012)
|
|
mask *= (role_of[joints[:, 0]] == 3) & (regions == 0) & face_ready
|
|
details[mask <= 0] = 0.0
|
|
# Cloth's detail is how freely it hangs from the waist: 0 at the waist, 1
|
|
# at the top's hem.
|
|
details[regions != 0] = np.column_stack((hangs, np.zeros(len(hangs))))[regions != 0]
|
|
masks = np.rint(np.clip(mask, 0, 1)*255).astype(np.int64)
|
|
|
|
# The body under the top and the trousers never shows: drop it, keeping
|
|
# the skin near the cuffs, the collar and the trouser hems, where it can be
|
|
# seen inside. Fewer triangles to skin, upload and draw every frame.
|
|
corners = positions[triangles]
|
|
body_face = np.all(triangles < body_count, axis=1)
|
|
progress = arm_progress(corners.reshape(-1, 3)).reshape(-1, 3).max(axis=1)
|
|
face_arm = share(joints, weights, [4, 5, 6, 7])[triangles].mean(axis=1)
|
|
leg_down = np.clip((hip_height-0.04-corners[:, :, 1].min(axis=1))/(hip_height-0.04-np.mean(ankles)), 0, 1)
|
|
hidden_top = (regions[triangles[:, 0]] == 1) & ((face_arm < 0.5) | (progress < 0.8)) & \
|
|
(corners[:, :, 1].max(axis=1) < neck_height-0.05) & ((face_arm >= 0.5) | (corners[:, :, 1].min(axis=1) > waist_y))
|
|
hidden_legs = (regions[triangles[:, 0]] == 2) & (leg_down < 0.8)
|
|
triangles = triangles[~(body_face & (hidden_top | hidden_legs))]
|
|
kept = np.unique(triangles)
|
|
renumber = np.full(len(positions), -1, dtype=np.int64)
|
|
renumber[kept] = np.arange(len(kept))
|
|
triangles = renumber[triangles]
|
|
positions, normals, uvs, details = positions[kept], normals[kept], uvs[kept], details[kept]
|
|
joints, weights, regions, masks = joints[kept], weights[kept], regions[kept], masks[kept]
|
|
quantized = np.rint(weights*65535).astype(np.int64)
|
|
quantized[:, 0] += 65535-quantized.sum(axis=1)
|
|
assert np.all(quantized >= 0) and np.all(quantized <= 65535)
|
|
assert np.isfinite(positions).all() and np.isfinite(normals).all() and np.isfinite(uvs).all()
|
|
assert np.max(joints) < len(bones) < 256
|
|
assert np.max(triangles) < len(positions) < 65536
|
|
assert np.all(quantized.sum(axis=1) == 65535)
|
|
assert len(bones) == 46 and np.max(regions) <= 4
|
|
blob = bytearray(struct.pack('<8sIIIf', b'PFIG0002', len(positions), triangles.size, len(bones), 1.7))
|
|
for item in bones:
|
|
blob.extend(struct.pack('<4Bi6f', item['role'], item['side'], item['finger'], item['segment'],
|
|
item['parent'], *item['origin'], *item['tip']))
|
|
for point, normal, uv, detail, influence, weight, region, face in zip(positions, normals, uvs, details, joints,
|
|
quantized, regions, masks):
|
|
blob.extend(struct.pack('<3f3h2f2f4B4HBB', *point, *np.rint(normal*32767).astype(int),
|
|
*uv, *detail, *influence, *weight, int(region), int(face)))
|
|
blob.extend(triangles.astype('<u2').tobytes())
|
|
output = args.output.resolve()
|
|
output.mkdir(parents=True, exist_ok=True)
|
|
(output/'anatomy.bin').write_bytes(blob)
|
|
metadata = {'format':'PFIG0002', 'vertices':len(positions), 'triangles':len(triangles),
|
|
'bones':len(bones), 'bytes':len(blob), 'sha256':hashlib.sha256(blob).hexdigest(),
|
|
'regions':['skin', 'top', 'trousers', 'hair', 'trim'],
|
|
'source':'https://github.com/makehumancommunity/makehuman/blob/a8bc2d54ff0ac92e78ff71431b1023eda42bf482/makehuman/data/3dobjs/base.obj',
|
|
'license':'CC0-1.0', 'bone_names':[f"{b['role']}/{b['side']}/{b['finger']}/{b['segment']}" for b in bones]}
|
|
(output/'anatomy.json').write_text(json.dumps(metadata,indent=2)+'\n')
|
|
print(f"Prepared {len(positions)} vertices, {len(triangles)} triangles, {len(bones)} bones; {len(blob)} bytes")
|
|
# The eyes sit halfway down the head.
|
|
print(f"waist {waist_y:.3f} bust {bust_y:.3f} armpit {armpit_y:.3f} hem {hem_y:.3f}; "
|
|
f"{1.7/(2*(crown-eye_height)):.2f} heads tall")
|