Render Sun Salutation in a clean flat style with six characters

scripts/render-sun-salutation-flat.py draws the existing pose timeline as
flat vector shapes: limbs as hulls of circles, one-colour parts filled as
one shape, feet that find their own floor contact. The characters in
docs/sun-salutation-flat.json pick torso, legs, sleeves, face and hair and
give their colours; --grid renders all of them side by side to choose.
This commit is contained in:
waozi committed 2026-10-15 20:05:09 -03:00
1 parent bbd7db97cd
commit bb01ab867d
3 files changed
+952

No files matched your search

+25
View File
@@ -0,0 +1,25 @@
{
"about": "Flat sun salutation characters for scripts/render-sun-salutation-flat.py. Each picks a torso, legs, sleeves, face and hair from the shape tables in that script, and its colours; far limbs, shades and hair highlights are derived from these colours.",
"background": "#eef2ef",
"shadow": "#1e4a40",
"characters": [
{"id": "jade-bun", "name": "Jade bun (new)", "torso": "tunic", "legs": "loose", "sleeves": "bell",
"face": "female", "hair": "bunLong",
"colors": {"skin": "#f1c7a6", "hair": "#2a2238", "top": "#3f8f7a", "pants": "#2e3d63", "cuff": "#2e3d63", "accent": "#f2a65e"}},
{"id": "sunrise-ponytail", "name": "Sunrise ponytail", "torso": "fitted", "legs": "leggings", "sleeves": "fitted",
"face": "female", "hair": "ponytail",
"colors": {"skin": "#f2c9ab", "hair": "#c98a4b", "top": "#6e98a3", "pants": "#8a9a78", "cuff": "#5d8590", "accent": "#f2a65e"}},
{"id": "sage-bun", "name": "Sage bun", "torso": "fitted", "legs": "leggings", "sleeves": "fitted",
"face": "female", "hair": "bun",
"colors": {"skin": "#dfa47c", "hair": "#7f4329", "top": "#efe2cf", "pants": "#6f8f5e", "cuff": "#ddcdb5", "accent": "#f2a65e"}},
{"id": "rust-short", "name": "Rust short hair (male)", "torso": "male", "legs": "leggings", "sleeves": "fittedMale",
"face": "male", "hair": "short",
"colors": {"skin": "#f3c4a3", "hair": "#b06c3b", "top": "#ad5236", "pants": "#4d4a4f", "cuff": "#94452d", "accent": "#f2a65e"}},
{"id": "indigo-crop", "name": "Indigo crop (male)", "torso": "male", "legs": "trousers", "sleeves": "fittedMale",
"face": "male", "hair": "crop",
"colors": {"skin": "#e6aa7c", "hair": "#7a4a2e", "top": "#4f5c94", "pants": "#c4ab78", "cuff": "#424e80", "accent": "#f2a65e"}},
{"id": "lake-short", "name": "Lake short hair (new, male)", "torso": "tunicMale", "legs": "loose", "sleeves": "bellMale",
"face": "male", "hair": "short",
"colors": {"skin": "#d9a07c", "hair": "#2a2238", "top": "#3f6f8f", "pants": "#6e4c36", "cuff": "#6e4c36", "accent": "#f2a65e"}}
]
}
+46
View File
@@ -0,0 +1,46 @@
# Flat Sun Salutation characters
`scripts/render-sun-salutation-flat.py` draws the Sun Salutation in a clean,
flat vector style: flat colours, no textures or gradients, one darker tone
for the far limbs and shades. It reuses the pose timeline, inverse
kinematics and hair simulation of `scripts/render-sun-salutation-girl.py`
and `docs/sun-salutation-girl.json`, so the yoga form is the same as the
painted animation; only the drawing differs.
```sh
python3 scripts/render-sun-salutation-flat.py # first character's video
python3 scripts/render-sun-salutation-flat.py --character sage-bun # one character
python3 scripts/render-sun-salutation-flat.py --all # every character
python3 scripts/render-sun-salutation-flat.py --grid # all side by side, numbered
python3 scripts/render-sun-salutation-flat.py --character sage-bun --still 25.5
```
Videos go straight into `build/sun-salutation-flat/` as `<id>.mp4` and
`choose-characters.mp4` (1536 × 1024, or 768 × 512 cells in the grid, 30 fps,
69 s, one chapter per step). Stills go to `build/sun-salutation-flat/stills/`;
delete them after review. It needs Python 3 with pycairo, FFmpeg with
libx264, and the girl renderer's NumPy and Pillow for its import.
## Characters
`docs/sun-salutation-flat.json` lists the characters. Each picks a torso,
legs, sleeves, face and hair by name and gives its colours: skin, hair, top,
pants, the sleeve cuff and the small light orange accent (hair ties). Far
limbs, shades and hair highlights are derived from those colours.
The shapes behind those names are tables in the script:
- `TORSOS`: the top's outline along the spine, its hem band, the seat and
the neck base (`tunic`, `tunicMale`, `fitted`, `male`).
- `LEGS` and `SLEEVES`: limb radii, where trousers and sleeves end and their
bands (`loose`, `leggings`, `trousers`; `bell`, `fitted` and male widths).
- `FACES`: the profile, scale, neck, blush, brow and mouth (`female`, `male`).
- `HAIRS`: the cap, an optional bun and an optional hanging strand that
swings with the hair simulation (`bunLong`, `ponytail`, `bun`, `crop`,
`short`). Men use short styles without swinging hair.
Limbs are hulls of circles along their bones, and parts of one colour fill as
one shape, so joints never show seams. Feet solve their own floor contact:
flat when standing, on tucked toes behind her in plank, on the instep in
upward-facing dog. `POSE_CHANGES` lowers a few ankles so the drawn feet
reach the floor.
+881
View File
@@ -0,0 +1,881 @@
#!/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))
# The rig's poses were placed for the painted parts. These ankles let the
# drawn feet reach the floor in plank and upward-facing dog.
POSE_CHANGES = {
"plank": {"ankles": [441, 395]},
"low": {"ankles": [441, 395]},
"stepBack": {"farAnkle": [441, 395]},
"upDog": {"ankles": [458, 421]},
}
# 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 and the base of the neck.
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),
},
"tunicMale": {
"outline": [
(-12, 33, 0), (10, 28), (40, 25), (72, 27), (97, 25.5), (110, 14.5), (116.5, 7),
(118, -7), (114.5, -19), (98, -27), (68, -25), (40, -23.5), (12, -29),
(-14, -36, 0), (-16.5, -2),
],
"hem": [(-9, -50), (-11.5, -2), (-7, 50)],
"seat": ((-2, -8), 20),
"neck": (115, 1.5),
},
"fitted": {
"outline": [
(-7, 24, 0), (12, 21), (40, 17.5), (64, 20), (80, 23.5), (98, 18.5), (111, 10),
(116.5, 4), (117.5, -6), (114, -14.5), (98, -21), (70, -19), (42, -17.5),
(16, -22.5), (-9, -27.5, 0), (-10.5, -2),
],
"hem": [(-4.5, -50), (-6.5, -2), (-3, 50)],
"seat": ((-2, -9), 19),
"neck": (114, 2),
},
"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),
},
}
# 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)},
"leggings": {"thigh": (18.0, 15.8, 11.4), "shin": (11.2, 11.9), "end": (3.5, 7.8), "band": None},
"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)},
"bellMale": {"upper": (12.2, 11.6, 9.6), "elbow": 9.4, "end": (6, 11.2), "cuff": (6.5, 0.5, 11.1, 12.2)},
"fitted": {"upper": (10.2, 9.6, 7.6), "elbow": 7.4, "end": (1.5, 6.4), "cuff": (5.5, 1.5, 6.5, 6.6)},
"fittedMale": {"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.
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": [((0.5, 5), 8.2), ((3, -17), 7.6)],
"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": [((0.5, 5), 9.4), ((3, -16), 8.8)],
"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)],
},
}
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)], "tie": False},
"ear": False,
},
"ponytail": {
"cap": [
(26, -63.5), (30.5, -56.5, 0), (22, -58.5), (14, -55.5), (8, -51), (4, -49.5),
(-3, -51.5), (-8, -46), (-12, -35), (-19, -30), (-27, -38), (-30.5, -52),
(-25, -69), (-8, -81), (12, -79.5),
],
"bun": None,
"strand": {"roots": [(-25, -57), (-29.5, -52)], "count": 7,
"width": [(0, 5), (0.08, 5.5), (0.3, 9.5), (0.75, 6), (1, 2.2)], "tie": True},
"ear": True,
},
"bun": {
"cap": [
(26, -63.5), (30.5, -56.5, 0), (22, -58.5), (14, -55.5), (8, -51), (4, -49.5),
(-3, -51.5), (-8, -46), (-12, -35), (-19, -30), (-27, -38), (-30.5, -52),
(-25, -69), (-8, -81), (12, -79.5),
],
"bun": ((-20, -75), 13),
"strand": None,
"ear": True,
},
"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,
},
"short": {
"cap": [
(25, -66), (28, -62.5, 0), (19, -62), (12, -57), (8.5, -50), (7.5, -44), (8, -39, 0),
(4, -44), (-2, -51), (-9, -46), (-13, -36), (-20, -36.5), (-25.5, -47), (-25.5, -63),
(-12, -80.5), (8, -82), (20, -77),
],
"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)
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 draw_torso(self, ctx, p):
torso = self.body_shape(p, smooth(self.torso["outline"]))
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):
neck = [mul(point, self.face["scale"]) for point in blob(self.face["neck"])]
fill(ctx, [place(neck, self.body(p, self.torso["neck"]), self.head_turn(p))], self.colors["skin"])
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)
strand = hairstyle["strand"]
if strand and strand["tie"]:
# The tie wraps the strand a little below where it leaves the head.
points = self.hair.points
direction = GIRL.normalize(sub(points[2], points[1]))
normal = (direction[1], -direction[0])
center = add(points[1], mul(direction, 1.5))
half = strand["width"][1][1] - 1.2
stroke(ctx, [add(center, mul(normal, half)), sub(center, mul(normal, half))],
colors["accent"], 4.4)
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()
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():
rig = json.loads(RIG.read_text())
for name, changes in POSE_CHANGES.items():
rig["poses"][name].update(changes)
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):
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']}.mp4", width, height, fps, frames)
def render_grid(rig, style, characters, output, width, height, fps, columns=3):
"""All characters side by side, numbered, to choose between them."""
figures = [Figure(rig, style, character, width, height, fps) for character in characters]
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 / "choose-characters.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")
options = parser.parse_args()
if options.grid:
render_grid(rig, style, style["characters"], options.output,
options.width // 2, options.height // 2, options.fps)
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']}-{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)
if __name__ == "__main__":
main()