Files
breeze/scripts/render-sun-salutation-flat.py
T
waozi 55c43639e2 Follow the classic Sun Salutation, with lunges and switching legs
Sun Salutation now moves through the classic sequence: from the fold one
leg steps back into a low lunge with its knee down, then plank, knees,
chest and chin, cobra and down dog, and a lunge with the other knee down
on the way back up. The hands stay beside the feet from the fold until she
stands, and every other round steps back with the other leg, from a second
set of frames. The four steps whose recorded lines no longer fit say only
the breath until new lines are recorded.
2026-10-19 23:54:15 -03:00

877 lines
38 KiB
Python

#!/usr/bin/env python3
"""Animate flat, cleanly drawn characters through Inbe's sun salutation.
The pose timeline, inverse kinematics and hair simulation come from
render-sun-salutation-girl.py and docs/sun-salutation-girl.json; the
characters come from docs/sun-salutation-flat.json. Instead of warping
painted parts, every part is a flat vector shape drawn with Cairo: limbs are
hulls of circles along their bones, the torso, head, hands and feet are
smooth outlines, and parts of one colour are filled as one shape, so they
join without seams. Feet find their own contact with the floor: a standing
foot lies flat, a foot behind the body rises onto tucked toes, and in
upward-facing dog the top of the foot rests on the floor. See
docs/sun-salutation-flat.md.
"""
import argparse
import importlib.util
import json
import math
from pathlib import Path
import subprocess
import tempfile
import cairo
ROOT = Path(__file__).resolve().parents[1]
RIG = ROOT / "docs/sun-salutation-girl.json"
CHARACTERS = ROOT / "docs/sun-salutation-flat.json"
BUILD = ROOT / "build/sun-salutation-flat"
def load_girl_renderer():
spec = importlib.util.spec_from_file_location(
"sun_salutation_girl", ROOT / "scripts/render-sun-salutation-girl.py")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
GIRL = load_girl_renderer()
add, sub, mul, mix = GIRL.add, GIRL.sub, GIRL.mul, GIRL.mix
unit, rotate, wrap, ease, smoothstep = GIRL.unit, GIRL.rotate, GIRL.wrap, GIRL.ease, GIRL.smoothstep
def colour(value):
value = value.lstrip("#")
return tuple(int(value[index:index + 2], 16) / 255 for index in (0, 2, 4))
# Shapes -------------------------------------------------------------------
def circle(center, radius, count=40):
return [add(center, mul(unit(math.tau * index / count), radius)) for index in range(count)]
def hull(points):
"""Convex hull, counter-clockwise in y-down screen space."""
points = sorted(set(points))
if len(points) < 3:
return points
def cross(origin, a, b):
return (a[0] - origin[0]) * (b[1] - origin[1]) - (a[1] - origin[1]) * (b[0] - origin[0])
lower, upper = [], []
for point in points:
while len(lower) >= 2 and cross(lower[-2], lower[-1], point) <= 0:
lower.pop()
lower.append(point)
for point in reversed(points):
while len(upper) >= 2 and cross(upper[-2], upper[-1], point) <= 0:
upper.pop()
upper.append(point)
return lower[:-1] + upper[:-1]
def blob(circles):
"""The hull of (center, radius) circles: a rounded, tapering limb part."""
points = []
for center, radius in circles:
points.extend(circle(center, radius, 32))
return hull(points)
def signed_area(points):
return sum(a[0] * b[1] - b[0] * a[1] for a, b in zip(points, points[1:] + points[:1])) / 2
def oriented(points):
"""Every outline runs the same way, so overlapping parts fill as one."""
return points if signed_area(points) > 0 else list(reversed(points))
def smooth(points, closed=True, samples=8):
"""Dense Catmull-Rom outline through points; a point given as
(x, y, 0) is a sharp corner."""
count = len(points)
result = []
segments = count if closed else count - 1
for index in range(segments):
p1, p2 = points[index], points[(index + 1) % count]
p0 = points[(index - 1) % count] if closed or index > 0 else p1
p3 = points[(index + 2) % count] if closed or index + 2 < count else p2
tension1 = 0.0 if len(p1) > 2 else 1.0
tension2 = 0.0 if len(p2) > 2 else 1.0
c1 = add(p1[:2], mul(sub(p2[:2], p0[:2]), tension1 / 6))
c2 = sub(p2[:2], mul(sub(p3[:2], p1[:2]), tension2 / 6))
for step in range(samples):
t = step / samples
u = 1 - t
result.append(tuple(
u ** 3 * p1[axis] + 3 * u * u * t * c1[axis] + 3 * u * t * t * c2[axis] + t ** 3 * p2[axis]
for axis in (0, 1)))
if not closed:
result.append(points[-1][:2])
return result
def fill(ctx, shapes, rgb, alpha=1.0):
"""Fill several outlines as one shape in one colour."""
for shape in shapes:
if len(shape) < 3:
continue
shape = oriented(shape)
ctx.move_to(*shape[0])
for point in shape[1:]:
ctx.line_to(*point)
ctx.close_path()
ctx.set_source_rgba(*colour(rgb), alpha)
ctx.fill()
def outline_path(ctx, shapes):
for shape in shapes:
shape = oriented(shape)
ctx.move_to(*shape[0])
for point in shape[1:]:
ctx.line_to(*point)
ctx.close_path()
def stroke(ctx, points, rgb, width):
ctx.move_to(*points[0])
for point in points[1:]:
ctx.line_to(*point)
ctx.set_source_rgb(*colour(rgb))
ctx.set_line_width(width)
ctx.set_line_cap(cairo.LINE_CAP_ROUND)
ctx.set_line_join(cairo.LINE_JOIN_ROUND)
ctx.stroke()
def profile(stops, share):
"""Smoothly interpolated value between (share, value) stops."""
for (first, low), (second, high) in zip(stops, stops[1:]):
if share <= second:
amount = (share - first) / max(second - first, 1e-9)
return low + (high - low) * amount * amount * (3 - 2 * amount)
return stops[-1][1]
def place(points, origin, angle):
return [add(origin, rotate(point[:2], angle)) for point in points]
# Character design, in rig units ---------------------------------------------
def shade(value, amount):
"""The colour darkened by amount, or lightened by a negative amount."""
rgb = colour(value)
if amount >= 0:
rgb = [channel * (1 - amount) for channel in rgb]
else:
rgb = [channel + (1 - channel) * -amount for channel in rgb]
return "#" + "".join(f"{round(channel * 255):02x}" for channel in rgb)
def palette(colors):
"""A character's colours with its far limbs, shades and highlights."""
return {
**colors,
"skinFar": shade(colors["skin"], 0.1),
"topFar": shade(colors["top"], 0.2),
"topShade": shade(colors["top"], 0.13),
"pantsFar": shade(colors["pants"], 0.22),
"pantsShade": shade(colors["pants"], 0.14),
"cuffFar": shade(colors["cuff"], 0.2),
"hairLight": shade(colors["hair"], -0.2),
"mouth": shade(colors["skin"], 0.22),
"blush": "#ec9f8f",
}
# Torsos: outlines as (distance up the spine from the hip, forward offset),
# the hem band's top edge, the seat under the top, the base of the head, the
# neck's back and front where they enter the top, and how far the back of
# the hem settles against the hips when she lies with her back up.
TORSOS = {
"tunic": {
"outline": [
(-12, 33, 0), (10, 27), (40, 23), (70, 25.5), (96, 23), (110, 13), (116, 6),
(117.5, -6), (114, -16), (98, -24), (68, -23), (40, -23), (12, -29),
(-14, -36, 0), (-16.5, -2),
],
"hem": [(-9, -50), (-11.5, -2), (-7, 50)],
"seat": ((-2, -8), 20),
"neck": (114, 2),
"neckBase": [(106, -7.5), (104, 8.5)],
"drape": 6,
},
"male": {
"outline": [
(-7, 24, 0), (12, 22), (42, 21), (72, 24.5), (98, 24), (111, 14), (116.5, 6),
(118, -7), (114.5, -18.5), (98, -26), (70, -23), (42, -19.5), (16, -22.5),
(-9, -27.5, 0), (-10.5, -2),
],
"hem": [(-4.5, -50), (-6.5, -2), (-3, 50)],
"seat": ((-2, -9), 18.5),
"neck": (115, 1.5),
"neckBase": [(107, -9), (105, 10)],
"drape": 0,
},
}
# Legs: thigh radii at hip, middle and knee; shin radii at knee and calf;
# where the trousers end (units above the ankle, half width); an optional
# darker band at their end (from, to units above the ankle, half widths).
LEGS = {
"loose": {"thigh": (19.5, 17.5, 14.0), "shin": (14.0, 13.6), "end": (12, 11.5),
"band": (13, 4.5, 9.4, 9.0)},
"trousers": {"thigh": (19.0, 17.0, 13.2), "shin": (13.0, 12.6), "end": (4.5, 10.6),
"band": (10, 4.5, 10.6, 10.6)},
}
# Sleeves: upper arm radii at shoulder, middle and elbow; forearm radius at
# the elbow; where the sleeve ends (units before the wrist, half width); the
# cuff band (from, to units before the wrist, half widths).
SLEEVES = {
"bell": {"upper": (11.2, 10.6, 8.8), "elbow": 8.6, "end": (6, 10.4), "cuff": (6.5, 0.5, 10.3, 11.4)},
"fitted": {"upper": (11.4, 10.8, 8.6), "elbow": 8.4, "end": (1.5, 7.2), "cuff": (5.5, 1.5, 7.3, 7.4)},
}
# Heads, in their own frame: the neck base at the origin, facing +x, up is
# -y; the frame is scaled by "scale" about the neck base. "neck" holds where
# the back and the front of the neck meet the head, inside its outline.
FACES = {
"female": {
"outline": [
(3, -77), (19, -71), (27, -60), (29, -51), (28.5, -46.5), (30, -43.5), (33.2, -38.6),
(29.5, -35.6), (30.2, -32.2), (28.2, -30.4), (29, -28.2), (26.2, -23.4), (19, -19.6),
(8, -21), (-12, -27), (-23, -40), (-22, -62),
],
"scale": 1.22, "neck": [(-5, -29), (9, -24)],
"blush": 0.55, "lash": True, "brow": [(17, -53), (21.5, -55), (26, -53.5)], "browWidth": 1.2,
"mouth": [(28.6, -31.2), (25.6, -31.0)],
},
"male": {
"outline": [
(3, -77), (19, -72), (27, -62), (29.5, -52), (28.8, -47), (31, -43.5), (35, -37.6),
(30.6, -35), (30.8, -31.8), (28.8, -30.2), (29.8, -27.8), (28.8, -22.5), (24, -17.2),
(10, -18.5), (-10, -26), (-23, -40), (-22, -62),
],
"scale": 1.2, "neck": [(-6, -29), (10.5, -22.5)],
"blush": 0.0, "lash": False, "brow": [(16.5, -53), (21.5, -54.5), (26.5, -54)], "browWidth": 2.0,
"mouth": [(29.2, -31.4), (25.8, -31.2)],
},
}
# The shade under the jaw: the head's outline turned down about the back of
# the jaw (head frame, degrees), deepest under the chin, gone at the nape.
JAW_SHADE = ((-12, -27), 12)
EYE = (21, -45.5)
BLUSH = ((16.5, -35.5), 4.6)
CRANIUM = (2, -48)
EAR = [(-1, -49.5), (3, -46), (3.6, -39), (0.5, -33.5), (-3.5, -35.5), (-5, -43)]
EAR_FOLD = [(0.2, -45.5), (1.6, -41), (-0.2, -37)]
# Hair: the cap over the skull, an optional bun (center, radius) with its
# tie, an optional hanging strand (two roots in the head frame, joints, and
# its half width as (share of its length, half width) stops), and whether
# the ear shows.
HAIRS = {
"bunLong": {
"cap": [
(27.5, -61.5), (30.5, -56, 0), (21, -57.5), (13, -53), (7.5, -45), (8, -31.5),
(3.5, -28.5), (-6, -27.5), (-13, -25), (-22, -30), (-29.5, -46), (-25, -68),
(-8, -81), (12, -79),
],
"bun": ((-7.5, -89), 15),
"strand": {"roots": [(-20.5, -40), (-17, -30)], "count": 9,
"width": [(0, 11), (0.5, 7.4), (1, 3.5)]},
"ear": False,
},
"crop": {
"cap": [
(25, -67), (31.5, -64.5, 0), (23, -62), (14, -58), (9, -52), (7.5, -44), (8, -38.5, 0),
(4, -44), (-2, -51), (-9, -46), (-13, -36), (-20, -36.5), (-25.5, -47), (-25.5, -63),
(-12, -81), (8, -84), (21, -78),
],
"bun": None,
"strand": None,
"ear": True,
},
}
# The far arm sits only a little behind the near one, so praying hands overlap.
FAR_ARM = (-3, -1)
# Upright hand, wrist at the origin, fingers up (-y), thumb at the back (-x).
HAND_UPRIGHT = [
(-5.5, 5), (-6.2, -11.5), (-5.1, -24.5), (-1.8, -31), (2.9, -29.8), (5.1, -21),
(9.4, -14), (7.6, -7), (5.5, 5),
]
# The same outline lying flat: (dx from the wrist, dy from the wrist or the
# floor, measured from "wrist" or "floor").
HAND_FLAT = [
((-3, -5), "wrist"), ((13, -9), "floor"), ((24, -7), "floor"), ((33, -3.6), "floor"),
((35, -0.8), "floor"), ((24, 0), "floor"), ((10, 0), "floor"), ((1, 0), "floor"),
((-4.5, -4), "floor"),
]
# Foot, ankle at the origin, standing, toes at +x. The toes bend about BALL.
FOOT_REAR = [(-6, -3), (-10.5, 6.5), (-8.5, 15.5), (-2, 18.2), (14, 17.4), (27, 18.2)]
BALL = (32, 12.5)
TOES = [(0, 5.7), (11, 5.2), (14.2, 3), (12.6, -0.6), (2, -2.6)]
FOOT_TOP = [(18, 4.5), (6.5, -5.5)]
class Figure:
"""One drawn character on the rig's timeline."""
def __init__(self, rig, style, character, width, height, fps):
self.rig = rig
self.timeline = GIRL.Timeline(rig)
self.ground = rig["ground"]
self.bones = rig["bones"]
self.frame_step = 1 / fps
self.width, self.height = width, height
self.background = style["background"]
self.shadow = style["shadow"]
self.character = character
self.colors = palette(character["colors"])
self.torso = TORSOS[character["torso"]]
self.legs = LEGS[character["legs"]]
self.sleeves = SLEEVES[character["sleeves"]]
self.face = FACES[character["face"]]
self.hairstyle = HAIRS[character["hair"]]
self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
self.ctx = cairo.Context(self.surface)
self.hair = None
self.hair_time = None
# Placement ----------------------------------------------------------
def body(self, p, point):
"""A (distance up the spine, forward offset) point in rig space."""
forward = (-math.sin(p.spine), math.cos(p.spine))
return add(add(p.hip, mul(unit(p.spine), point[0])), mul(forward, point[1]))
def body_shape(self, p, points):
return [self.body(p, point) for point in points]
def head_turn(self, p):
head = self.rig["head"]
lift = wrap(p.gaze - p.spine) * head["lift"]
lift = max(math.radians(head["liftMin"]), min(math.radians(head["liftMax"]), lift))
return p.spine + lift + math.pi / 2
def head_point(self, p, point):
scaled = mul(point, self.face["scale"])
return add(self.body(p, self.torso["neck"]), rotate(scaled, self.head_turn(p)))
# Feet ----------------------------------------------------------------
@staticmethod
def foot_outline(angle, bend):
"""Foot outline about the ankle: rear foot turned by angle, toes bent
by bend about the ball."""
ball = rotate(BALL, angle)
toes = [add(ball, rotate(point, angle + bend)) for point in TOES]
return [rotate(point, angle) for point in FOOT_REAR] + toes + [rotate(point, angle) for point in FOOT_TOP]
def lowest(self, angle, bend):
return max(point[1] for point in self.foot_outline(angle, bend))
def solve(self, height, start, end, bend):
"""The angle between start and end at which the foot just touches a
floor `height` below the ankle; the foot sinks as the angle moves
from start to end."""
if self.lowest(start, bend(start)) >= height:
return start
if self.lowest(end, bend(end)) <= height:
return end
low, high = start, end
for _ in range(30):
middle = (low + high) / 2
if self.lowest(middle, bend(middle)) < height:
low = middle
else:
high = middle
return (low + high) / 2
def plant_foot(self, p, ankle, knee, airborne):
"""(ankle, angle, bend) for a foot: lying flat, on tucked toes, or on
its instep, lifted so it never sinks into the floor."""
height = self.ground - ankle[1]
tucked = self.solve(height, 0.0, 1.2, lambda angle: -angle)
instep = self.solve(height, 2.75, 1.6, lambda angle: 0.15)
share = ease(p.instep)
angle = tucked + (instep - tucked) * share
bend = -tucked * (1 - share) + 0.15 * share
if airborne > 0:
shin = math.atan2(ankle[1] - knee[1], ankle[0] - knee[0])
pointed = shin - math.pi / 2 + self.rig["feet"]["pointToes"]
amount = smoothstep(0.0, 0.5, airborne)
angle += wrap(pointed - angle) * amount
bend += (0.1 - bend) * amount
sink = self.lowest(angle, bend) - height
if sink > 0:
ankle = (ankle[0], ankle[1] - sink)
return ankle, angle, bend
# Limbs ----------------------------------------------------------------
def leg(self, p, far, airborne):
offset = tuple(self.bones["farOffset"]) if far else (0, 0)
hip = add(p.hip, offset)
target = add(p.far_ankle if far else p.near_ankle, offset)
knee, _ = GIRL.joint(hip, target, self.bones["thigh"], self.bones["shin"], -1)
target, angle, bend = self.plant_foot(p, target, knee, airborne)
knee, ankle = GIRL.joint(hip, target, self.bones["thigh"], self.bones["shin"], -1)
return hip, knee, ankle, angle, bend
def arm(self, p, far):
offset = FAR_ARM if far else (0, 0)
shoulder = add(p.shoulder, offset)
target = add(p.far_wrist if far else p.near_wrist, offset)
elbow, wrist = GIRL.joint(shoulder, target, self.bones["upperArm"], self.bones["forearm"], 1)
# With her chest on the floor and the hands beside it, that elbow
# would bend down through the floor; it turns up toward her back
# instead. Blending the two bends is the elbow turning out of the
# picture, so the move into the pose stays smooth.
lifted, _ = GIRL.joint(shoulder, target, self.bones["upperArm"], self.bones["forearm"], -1)
sink = elbow[1] - (self.ground - self.sleeves["elbow"])
elbow = mix(elbow, lifted, smoothstep(-24.0, 0.0, sink))
return shoulder, elbow, wrist
@staticmethod
def along(a, b, amount, back=0.0):
"""A point amount of the way from a to b, moved back (to the left of
the bone's direction) by back units."""
direction = GIRL.normalize(sub(b, a))
normal = (direction[1], -direction[0])
return add(mix(a, b, amount), mul(normal, back))
@staticmethod
def band(a, b, start, end, half_start, half_end):
"""A straight band across the bone a→b, from start to end units
before b, half_start and half_end wide."""
direction = GIRL.normalize(sub(b, a))
normal = (direction[1], -direction[0])
first, second = sub(b, mul(direction, start)), sub(b, mul(direction, end))
return [add(first, mul(normal, half_start)), add(second, mul(normal, half_end)),
sub(second, mul(normal, half_end)), sub(first, mul(normal, half_start))]
def leg_shapes(self, hip, knee, ankle):
legs = self.legs
hip_radius, middle_radius, knee_radius = legs["thigh"]
shin_radius, calf_radius = legs["shin"]
end, end_half = legs["end"]
thigh = blob([(hip, hip_radius), (self.along(hip, knee, 0.45, 1.5), middle_radius), (knee, knee_radius)])
shin_end = self.band(knee, ankle, end, end, end_half, end_half)
shin = hull(circle(knee, shin_radius, 32) + circle(self.along(knee, ankle, 0.35, 1.5), calf_radius, 32)
+ [shin_end[0], shin_end[3]])
band = self.band(knee, ankle, *legs["band"]) if legs["band"] else None
ankle_skin = blob([(ankle, 6.4), (self.along(knee, ankle, 0.9), 6.2)])
return [thigh, shin], band, ankle_skin
def arm_shapes(self, shoulder, elbow, wrist):
sleeves = self.sleeves
shoulder_radius, middle_radius, elbow_radius = sleeves["upper"]
end, end_half = sleeves["end"]
upper = blob([(shoulder, shoulder_radius), (self.along(shoulder, elbow, 0.35, 0.8), middle_radius),
(elbow, elbow_radius)])
sleeve_end = self.band(elbow, wrist, end, end, end_half, end_half)
forearm = hull(circle(elbow, sleeves["elbow"], 32) + [sleeve_end[0], sleeve_end[3]])
cuff = self.band(elbow, wrist, *sleeves["cuff"])
return [upper, forearm], cuff
def hand_shape(self, p, elbow, wrist):
forearm = math.atan2(wrist[1] - elbow[1], wrist[0] - elbow[0])
turn = wrap(forearm + math.pi / 2) * (1 - p.upright)
upright = place(HAND_UPRIGHT, wrist, turn)
flat = smoothstep(0.2, 0.9, p.palm) * (1 - smoothstep(16, 34, self.ground - wrist[1]))
if flat <= 0:
return upright
lying = []
for (dx, dy), base in HAND_FLAT:
lying.append((wrist[0] + dx, (wrist[1] if base == "wrist" else self.ground) + dy))
return [mix(a, b, flat) for a, b in zip(upright, lying)]
# Hair -----------------------------------------------------------------
def update_hair(self, p, time):
"""Advance the hanging hair to `time` exactly as the video does: from
rest at 0 s, one step per video frame."""
strand = self.hairstyle["strand"]
if strand is None:
return
if self.hair_time is None or time < self.hair_time - 1e-9:
start = self.timeline.sample(0.0)
self.hair = GIRL.Hair(dict(self.rig["hair"], count=strand["count"]), self.ground)
self.hair.reset(tuple(self.head_point(start, root) for root in strand["roots"]))
self.hair_time = 0.0
frame = round(self.hair_time / self.frame_step)
target = round(time / self.frame_step)
for index in range(frame + 1, target):
self.advance_hair(self.timeline.sample(index * self.frame_step), index * self.frame_step)
if target > frame:
self.advance_hair(p, time)
def advance_hair(self, p, time):
roots = tuple(self.head_point(p, root) for root in self.hairstyle["strand"]["roots"])
self.hair.step(roots, time - self.hair_time, self.back_collider(p))
self.hair_time = time
def back_collider(self, p):
"""Keep the hair outside the back while the body is upright."""
axis = unit(p.spine)
forward = (-math.sin(p.spine), math.cos(p.spine))
strength = 1 - smoothstep(0.2, 0.5, forward[1])
if strength <= 0:
return None
back = sorted((point[0], point[1]) for point in self.torso["outline"] if point[1] < 0)
heights = [point[0] for point in back]
depths = [point[1] for point in back]
def collide(point):
offset = sub(point, p.hip)
height = offset[0] * axis[0] + offset[1] * axis[1]
depth = offset[0] * forward[0] + offset[1] * forward[1]
if not heights[0] <= height <= heights[-1]:
return point
limit = depths[0]
for (h0, d0), (h1, d1) in zip(back, back[1:]):
if h0 <= height <= h1:
limit = d0 + (d1 - d0) * (height - h0) / max(h1 - h0, 1e-9)
break
limit -= 4
if limit < depth < 6:
return add(point, mul(forward, (limit - depth) * strength))
return point
return collide
def hair_shape(self):
stops = self.hairstyle["strand"]["width"]
points = GIRL.spline_points(self.hair.points, 5)
lengths = [0.0]
for a, b in zip(points[:-1], points[1:]):
lengths.append(lengths[-1] + math.dist(a, b))
total = max(lengths[-1], 1e-9)
left, right = [], []
for index, point in enumerate(points):
ahead = points[min(index + 1, len(points) - 1)]
behind = points[max(index - 1, 0)]
direction = GIRL.normalize(sub(ahead, behind))
normal = (direction[1], -direction[0])
share = lengths[index] / total
half = profile(stops, share)
left.append(add(point, mul(normal, half)))
right.append(sub(point, mul(normal, half)))
return [left + list(reversed(right)), circle(points[0], stops[0][1]), circle(points[-1], stops[-1][1])]
# Drawing --------------------------------------------------------------
def ground_shadow(self, ctx, p):
xs = [p.near_ankle[0], p.far_ankle[0], p.near_wrist[0], p.far_wrist[0], p.hip[0]]
left, right = min(xs) - 34, max(xs) + 44
ctx.save()
ctx.translate((left + right) / 2, self.ground + 1)
ctx.scale((right - left) / 2, 6.5)
ctx.arc(0, 0, 1, 0, math.tau)
ctx.restore()
ctx.set_source_rgba(*colour(self.shadow), 0.12)
ctx.fill()
def draw_leg(self, ctx, leg, far):
colors = self.colors
hip, knee, ankle, angle, bend = leg
foot = place(smooth(self.foot_outline(angle, bend), samples=6), ankle, 0.0)
shapes, band, ankle_skin = self.leg_shapes(hip, knee, ankle)
fill(ctx, [foot, ankle_skin], colors["skinFar" if far else "skin"])
fill(ctx, shapes, colors["pantsFar" if far else "pants"])
if band:
fill(ctx, [band], colors["pantsFar"] if far else colors["pantsShade"])
def draw_arm(self, ctx, p, arm, far, torso=None):
colors = self.colors
shoulder, elbow, wrist = arm
hand = smooth(self.hand_shape(p, elbow, wrist), samples=6)
fill(ctx, [hand], colors["skinFar" if far else "skin"])
shapes, cuff = self.arm_shapes(shoulder, elbow, wrist)
if torso is not None:
# The near arm casts a crisp shade on the top where it crosses it.
ctx.save()
outline_path(ctx, [torso])
ctx.clip()
fill(ctx, [[add(point, (-2.4, 3.2)) for point in shape] for shape in shapes], colors["topShade"])
ctx.restore()
fill(ctx, shapes, colors["topFar" if far else "top"])
fill(ctx, [cuff], colors["cuffFar" if far else "cuff"])
def torso_outline(self, p):
"""The top's outline. Lying with her back up, the back of the hem
settles against the hips instead of flaring above them; upside down
it still falls open toward the chest."""
lying = max(0.0, math.cos(p.spine)) * (1 - smoothstep(0.25, 0.5, math.sin(p.spine)))
drape = self.torso["drape"] * lying
points = [(point[0], point[1] + drape * (1 - smoothstep(-14, 20, point[0])), *point[2:])
if point[1] < 0 else point for point in self.torso["outline"]]
return smooth(points)
def draw_torso(self, ctx, p):
torso = self.body_shape(p, self.torso_outline(p))
fill(ctx, [torso], self.colors["top"])
ctx.save()
outline_path(ctx, [torso])
ctx.clip()
band = smooth(self.torso["hem"], closed=False) + [(-60, 40), (-60, -40)]
fill(ctx, [self.body_shape(p, band)], self.colors["topShade"])
ctx.restore()
return torso
def draw_neck(self, ctx, p):
"""The neck bends between the top, where its base turns with the
torso, and the head, where it turns with the skull, so a lifted head
never swings it out of the collar. A shade under the jaw sets the
head on it."""
back_base, front_base = [self.body(p, point) for point in self.torso["neckBase"]]
back_top, front_top = [self.head_point(p, point) for point in self.face["neck"]]
middle = mul(add(add(back_base, front_base), add(back_top, front_top)), 0.25)
def side(start, end):
# Each side curves in a little toward the middle of the neck.
control = mix(mix(start, end, 0.5), middle, 0.12)
return [add(add(mul(start, (1 - t) ** 2), mul(control, 2 * t * (1 - t))), mul(end, t * t))
for t in [index / 8 for index in range(9)]]
# The ends run on inside the head and the top, which cover them.
neck = (side(back_base, back_top) + [self.head_point(p, (1, -42))]
+ side(front_top, front_base) + [self.body(p, (96, 0))])
fill(ctx, [neck], self.colors["skin"])
ctx.save()
outline_path(ctx, [neck])
ctx.clip()
pivot, angle = JAW_SHADE
jaw = [self.head_point(p, add(pivot, rotate(sub(point, pivot), math.radians(angle))))
for point in smooth(self.face["outline"])]
fill(ctx, [jaw], self.colors["skinFar"])
ctx.restore()
def draw_head(self, ctx, p):
colors, face, hairstyle = self.colors, self.face, self.hairstyle
origin, turn = self.body(p, self.torso["neck"]), self.head_turn(p)
def head(points):
return place([mul(point[:2], face["scale"]) for point in points], origin, turn)
fill(ctx, [head(smooth(face["outline"]))], colors["skin"])
if face["blush"]:
center, radius = BLUSH
fill(ctx, [head(circle(center, radius))], colors["blush"], face["blush"])
eye = [(EYE[0] + 4.6 * math.cos(angle), EYE[1] + 3.2 * math.sin(angle))
for angle in [math.radians(value) for value in range(15, 170, 10)]]
stroke(ctx, head(eye), colors["hair"] if face["lash"] else shade(colors["hair"], 0.3), 1.7)
if face["lash"]:
stroke(ctx, head([(EYE[0] - 4.2, EYE[1] + 1.0), (EYE[0] - 6.4, EYE[1] + 2.6)]), colors["hair"], 1.3)
stroke(ctx, head(smooth(face["brow"], closed=False, samples=6)), colors["hair"], face["browWidth"])
stroke(ctx, head(face["mouth"]), colors["mouth"], 1.1)
shapes = [head(smooth(hairstyle["cap"]))]
if hairstyle["bun"]:
center, radius = hairstyle["bun"]
shapes.append(head(circle(center, radius, 48)))
fill(ctx, shapes, colors["hair"])
if hairstyle["bun"]:
self.draw_bun_details(ctx, head)
if hairstyle["ear"]:
fill(ctx, [head(smooth(EAR))], colors["skin"])
stroke(ctx, head(smooth(EAR_FOLD, closed=False, samples=4)), colors["mouth"], 1.0)
def draw_bun_details(self, ctx, head):
"""Wrapped strands across the bun, and the tie where it meets the head."""
colors = self.colors
center, radius = self.hairstyle["bun"]
base = math.degrees(math.atan2(CRANIUM[1] - center[1], CRANIUM[0] - center[0]))
top = base + 180
for offset, size, start, end in ((0.6, 1.13, -42, 42), (0.33, 0.8, -55, 30)):
middle = add(center, mul(unit(math.radians(base)), radius * offset))
arc = [add(middle, mul(unit(math.radians(top + value)), radius * size))
for value in range(start, end + 1, 6)]
stroke(ctx, head(arc), colors["hairLight"], 1.4)
tie = [add(center, mul(unit(math.radians(base + value)), radius - 1)) for value in range(-35, 36, 5)]
stroke(ctx, head(tie), colors["accent"], 2.4 * 2 * self.face["scale"])
def frame(self, time):
ctx = self.ctx
p = self.timeline.sample(time)
feet = self.timeline.feet(p, time)
self.update_hair(p, time)
camera = self.rig["camera"]
ctx.save()
if self.background is None:
# A clear stage, for the app's frames.
ctx.set_operator(cairo.OPERATOR_CLEAR)
ctx.paint()
ctx.set_operator(cairo.OPERATOR_OVER)
else:
ctx.set_source_rgb(*colour(self.background))
ctx.paint()
ctx.scale(self.width / camera["designWidth"], self.height / camera["designHeight"])
ctx.translate(camera["centerX"], camera["groundY"])
ctx.scale(camera["scale"], camera["scale"])
ctx.translate(-camera["rigX"], -self.ground)
self.ground_shadow(ctx, p)
far_leg = self.leg(p, True, feet[True][1])
near_leg = self.leg(p, False, feet[False][1])
# Back to front: far leg and arm, the hanging hair, near leg and
# seat, neck, top, head, near arm.
self.draw_leg(ctx, far_leg, far=True)
self.draw_arm(ctx, p, self.arm(p, True), far=True)
if self.hairstyle["strand"]:
fill(ctx, self.hair_shape(), self.colors["hair"])
self.draw_leg(ctx, near_leg, far=False)
center, radius = self.torso["seat"]
fill(ctx, [self.body_shape(p, circle(center, radius))], self.colors["pants"])
self.draw_neck(ctx, p)
torso = self.draw_torso(ctx, p)
self.draw_head(ctx, p)
self.draw_arm(ctx, p, self.arm(p, False), far=False, torso=torso)
ctx.restore()
self.surface.flush()
return self.surface.get_data()
def load_rig(other_side=False):
"""The rig, for the first round or, with other_side, for the next one,
in which the other leg steps back first and the other knee goes down."""
rig = json.loads(RIG.read_text())
if other_side:
swap = {name: other for name, other in rig["otherSide"].items() if name != "about"}
rig["sequence"] = [swap.get(name, name) for name in rig["sequence"]]
rig["stepping"] = {step: [swap.get(name, name) for name in stops] if step.isdigit() else stops
for step, stops in rig["stepping"].items()}
return rig
def write_chapters(rig, timeline, target):
lines = [";FFMETADATA1", "title=Sun salutation"]
for index, name in enumerate(rig["names"]):
start = index * timeline.period * 1000
end = min(start + timeline.period * 1000, timeline.duration * 1000)
lines.extend(("[CHAPTER]", "TIMEBASE=1/1000", f"START={start:.0f}", f"END={end:.0f}", f"title={name}"))
target.write_text("\n".join(lines) + "\n")
def encode(rig, timeline, target, width, height, fps, frames):
"""Pipe BGRA frames into an H.264 MP4 with the pose chapters."""
target.parent.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory() as directory:
chapters = Path(directory) / "chapters.txt"
write_chapters(rig, timeline, chapters)
run_encoder(target, width, height, fps, chapters, frames)
print(f"Saved {target}", flush=True)
def run_encoder(target, width, height, fps, chapters, frames):
encoder = subprocess.Popen([
"ffmpeg", "-hide_banner", "-loglevel", "error", "-nostdin", "-y",
"-f", "rawvideo", "-pixel_format", "bgra", "-video_size", f"{width}x{height}",
"-framerate", str(fps), "-i", "pipe:0", "-f", "ffmetadata", "-i", str(chapters),
"-map", "0:v:0", "-map_metadata", "1", "-map_chapters", "1", "-an",
"-c:v", "libx264", "-crf", "16", "-preset", "medium", "-threads", "4",
"-pix_fmt", "yuv420p", "-movflags", "+faststart", str(target),
], stdin=subprocess.PIPE)
try:
for data in frames:
encoder.stdin.write(data)
finally:
encoder.stdin.close()
if encoder.wait() != 0:
raise RuntimeError(f"Encoding failed: {target}")
def render(rig, style, character, output, width, height, fps, suffix=""):
figure = Figure(rig, style, character, width, height, fps)
timeline = figure.timeline
frames = (figure.frame(frame / fps) for frame in range(round(timeline.duration * fps)))
encode(rig, timeline, output / f"{character['id']}{suffix}.mp4", width, height, fps, frames)
def render_grid(rig, style, characters, output, width, height, fps, suffix=""):
"""All characters side by side, numbered, to compare them."""
figures = [Figure(rig, style, character, width, height, fps) for character in characters]
columns = min(3, len(figures))
rows = math.ceil(len(figures) / columns)
grid = cairo.ImageSurface(cairo.FORMAT_ARGB32, width * columns, height * rows)
ctx = cairo.Context(grid)
timeline = figures[0].timeline
def frames():
for frame in range(round(timeline.duration * fps)):
ctx.set_source_rgb(*colour(style["background"]))
ctx.paint()
for index, figure in enumerate(figures):
figure.frame(frame / fps)
x, y = index % columns * width, index // columns * height
ctx.set_source_surface(figure.surface, x, y)
ctx.paint()
ctx.select_font_face("Sans", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
ctx.set_font_size(height * 0.045)
ctx.set_source_rgb(*colour(style["shadow"]))
ctx.move_to(x + width * 0.03, y + height * 0.08)
ctx.show_text(f"{index + 1} {figure.character['name']}")
for column in range(1, columns):
ctx.rectangle(column * width - 1, 0, 2, height * rows)
for row in range(1, rows):
ctx.rectangle(0, row * height - 1, width * columns, 2)
ctx.set_source_rgb(*colour(shade(style["background"], 0.08)))
ctx.fill()
grid.flush()
yield grid.get_data()
encode(rig, timeline, output / f"choose-characters{suffix}.mp4", width * columns, height * rows, fps, frames())
def main():
rig = load_rig()
style = json.loads(CHARACTERS.read_text())
characters = {character["id"]: character for character in style["characters"]}
output = rig["output"]
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--character", choices=list(characters), default=style["characters"][0]["id"])
parser.add_argument("--all", action="store_true", help="render every character's video")
parser.add_argument("--grid", action="store_true", help="render all characters side by side at half size")
parser.add_argument("--output", type=Path, default=BUILD)
parser.add_argument("--width", type=int, default=output["width"])
parser.add_argument("--height", type=int, default=output["height"])
parser.add_argument("--fps", type=int, default=output["fps"])
parser.add_argument("--still", type=float, action="append", help="render a PNG at this time in seconds")
parser.add_argument("--other-side", action="store_true",
help="the next round: the other leg steps back first (videos get -other-side)")
options = parser.parse_args()
suffix = ""
if options.other_side:
rig = load_rig(other_side=True)
suffix = "-other-side"
if options.grid:
render_grid(rig, style, style["characters"], options.output,
options.width // 2, options.height // 2, options.fps, suffix)
return
chosen = style["characters"] if options.all else [characters[options.character]]
for character in chosen:
if options.still:
figure = Figure(rig, style, character, options.width, options.height, options.fps)
for still in sorted(options.still):
figure.frame(still)
target = options.output / "stills" / f"{character['id']}{suffix}-{still:g}.png"
target.parent.mkdir(parents=True, exist_ok=True)
figure.surface.write_to_png(str(target))
print(target, flush=True)
else:
render(rig, style, character, options.output, options.width, options.height, options.fps, suffix)
if __name__ == "__main__":
main()