character-startup-animation

Name: character-startup-animation
Author: 落嵛

Verified@sunset1896/character-startup-animation

Use it in Cohub

Paste this into your agent's chat — it fetches the skill and follows it.

Use the skill: character-startup-animation. Run `npx -y @neta-art/neta-search-cli@latest skills use @sunset1896/character-startup-animation --via site` and follow what it prints. Read its complete output, redirecting it to a temporary file first if necessary, and resolve relative paths from the skill directory it prints.

Use in Neta Studio Open it in Neta Studio and see what people made with it.

Install from a terminal

npx -y @neta-art/neta-search-cli@latest skills use @sunset1896/character-startup-animation

Summary

Turn one character picture into a short entrance clip where the line art draws itself in, with optional colour-up and eye-opening.

Three looks: a line-art draw-on intro, an outfit or form swap on the beat, or an awaken reveal where lines turn to colour and the eyes open.
The line drawing grows in dozens of places at once, with big outlines and hair first and face details last. It runs about 3 seconds by default.
Pick a line style: glowing hologram, gold, sakura, neon, white, ink, pencil or blueprint. Landscape, portrait, square and wide shapes all work.
Get video, web video, GIF or a see-through version to lay over other footage. Loops, speed and end-hold are adjustable.
Works best with one character with a clear look, either a finished illustration or a character sheet. Crowded scenes and busy backgrounds do poorly.

SKILL.md

# Character Startup Animation — a character drawn out of the dark

Give it one character image and get back a short clip (about 3 seconds by default) in which the line art is
"drawn" onto an empty frame.
The effect standard: **dozens of short strokes appear at different places at the same time, each extending along its
own curve** (like After Effects trim paths) — **not** a single pen tip tracing in sequence. Large contours and hair
strands grow first; facial features and eyelashes come last.

## 🟢 Quick start
1. Give one character image (a finished illustration or a character sheet both work).
2. Say the line style ("golden glowing lines" / "ink" / "pencil sketch"…) and the aspect (landscape / portrait).
3. Get the clip (and a transparent-background version when needed).

## When to use / when not to
- ✅ A single character or a single subject; opening titles, entrances, loading animations, poster motion, outfit
  teasers, tutorial covers, stream intros.
- ✅ **Transparent-background lines** to layer over other footage (editing, web, OBS).
- ❌ Crowded multi-person scenes or dense backgrounds (the line art gets messy and the mask is unreliable).
- ❌ Cloning a real person's face from a photo to fake a "drawn" reveal, or selling work built on someone else's IP
  character (warn the user).

## Pipeline (scripts live in `scripts/`)
```bash
pip install -r requirements.txt            # numpy + Pillow; ffmpeg is also required; generation needs the cohub CLI
S=<skill folder>/scripts

# 1 line-art keyframes (finished image → line art, composition unchanged;
#   for a character sheet, first make a composed finished image, then convert it)
python3 $S/make_lineart.py --image art.png --from image --theme gold --out work/raw
python3 $S/make_lineart.py --image sheet.png --from sheet --char "<short English appearance description>" --aspect 9:16 --layout top --theme ink --out work/raw
# 2 normalise size + empty frame K0 (mask the character out, keep the background) + masks + keys.json
python3 $S/prep.py --lineart work/raw/lineart.png --render work/raw/render.png --out work/keys
# 3 AI growth clip (first frame K0 → last frame K1), 2 versions per run
python3 $S/gen_clip.py --keys work/keys --char "<short description>" --theme gold --order organic --n 2 --out work/clips
#   no video model / generation failed: procedural fallback (free)
python3 $S/procedural.py --keys work/keys --order organic --out work/clips/procedural.mp4
# 4 pick a take: automatic score + contact sheet (you must look at the contact sheet yourself)
python3 $S/qc.py pick --keys work/keys --clips work/clips
# 5 clean up + export (drop the model's first frame, trim empty head, stop exactly at the end)
python3 $S/export.py --clip work/clips/lines_1.mp4 --keys work/keys --out work/dist --formats mp4,webm,gif,alpha --hold 1.0
```
One command: `THEME=gold CHAR="..." bash scripts/pipeline.sh art.png work/ [image|sheet]` (existing line art /
clips are skipped automatically).

## Parameters at a glance
| Parameter | Values | What it does |
|---|---|---|
| `--theme` | hologram · gold · sakura · neon · white · ink · pencil · blueprint | Line and background style; `--line-color` / `--bg` customise them |
| `--detail` | clean · rich | Main contours only, or hair strands / folds / hatching too |
| `--eyes` | keep · closed · open | Eye state in the line art (use closed when a later shot opens the eyes) |
| `--aspect` / `--layout` | 16:9 9:16 1:1 4:3 3:4 21:9 / left-title right-title center top full | Composition, only with `--from sheet`; `--from image` keeps the original ratio |
| `--order` | organic · top-down · center-out · outline-first (the procedural version also has left-right) | The order strokes appear in |
| `--pace` | fast · steady · slow | Pacing hint for the AI clip |
| `export --speed` / `--hold` / `--loop` | speed multiplier / seconds to hold the last frame / fade back to empty for a seamless loop | Re-export only, costs nothing |
| `export --formats` | mp4 webm gif alpha prores png | alpha = transparent webm, prores = transparent mov, png = transparent image sequence |

## Check every step
- **After step 1**: look at `lineart.png` — are all contours present, with no colour fills and no stray text? With
  `--from sheet`, is the whole face and headwear inside the frame?
- **After step 2**: `residual_in_k0` in `keys.json` should be close to 0 (no leftover lines in the empty frame);
  with `--render`, `align_render` ≥ 0.2.
- **After step 4**: look at each version's `*_sheet.jpg`. Reject: a single pen tip tracing stroke by stroke, the whole
  image fading in, flashes / glowing rings, or lines whose shapes differ a lot from the final line art. `pick.json`
  is only a hint.
- **After step 5**: `qc.py check --video dist/lineart.mp4` — `stalls_sec` / `bursts_sec` should be empty.

## Fallbacks
| What is missing | What to do |
|---|---|
| No video model / generation failed | `procedural.py`: noise-driven growth at many points at once, paced by line pixels, background fading in whole with no colour blocks |
| The chosen model is unavailable in this environment | The script reads the available list out of the error and switches to an equivalent (e.g. gpt-image-2 → gpt-image-2.5) |
| No cohub CLI | `--dry-run` prints the prompts; run them on any reference-image-editing image model / first-last-frame video model and put the results in the same folder |
| No image-editing model | The user supplies `lineart.png` themselves and you start at step 2 |
| The user only wants transparent lines to overlay | In step 1 add `--bg "pure black, completely empty"` (dark lines) or a blank paper background (light themes); transparent export is cleanest that way |

More: prompt templates in `references/prompts.md`; delivery formats and integration in `references/formats.md`; models
and cost in `references/models.md`; hard-won lessons in `references/pitfalls.md` (**read before the first use**).

## Deliverables
1. `dist/lineart.mp4` (+ webm / gif) and a thumbnail.
2. When needed: `lineart_alpha.webm` (transparent, web / OBS / CapCut), `lineart_alpha.mov` (ProRes 4444, Premiere /
   Final Cut / After Effects), PNG sequence.
3. `lineart_final.png` (the final line-art still).
4. Which take was used, whether a fallback was used, and what it cost.
5. Free adjustments: speed, end hold, looping, alpha gain.

## Inputs and when to ask

Required: one character image, and a line style + aspect (landscape or portrait).
- Counts as given when the image is attached or named, and the style/aspect are stated, or the user says "you choose".
- If the image is missing, ask once for it. If only the style or aspect is missing, pick sensible defaults
  (`--theme gold`, the image's own ratio) and say which defaults you used.
- Everything else (detail, eyes, order, pace) is your call unless the user names it.

## Out of scope

- Do not change world settings, and do not delete existing files or unrelated Works.
- No multi-person scenes, dense backgrounds, or cloning a real person's face from a photo.
- Nothing beyond the clip and its transparent variants: no editing of other people's footage, no third-party assets.

## Reply language
Reply in the user's language. Any text the user sees inside the deliverable follows the user's language.

---

# Mode 2 — Transformation (变身) — outfit/identity swap on the beat

A staged reveal: the character goes `[form A] → build-up → [form B]`, cut on the music/beat. Built from the
**same keyframe chain** as the awaken mode, with a swap instead of a colour-up:

```
K3 (form B final) → K-B (form B, effects dimmed) → K2' (form A line art w/ B's silhouette) → K1' (form A line art) → K0' (form A final)
```

1. **Two anchors, one chain**: generate form A's finished frame first, then edit toward form B
   (each frame edited from the previous one — never two independent generations; that is what keeps
   silhouette and camera aligned). Reference: `scripts/awaken/gen.py keys` does exactly this chain; for the
   transformation use the same command twice, second pass `--ref <form A frame>` with the form-B description.
2. **Build-up clip** (AI, optional): form A → burst → form B silhouette; first/last frame = A-final / B-final.
   No video model → procedural fallback: white-out flash + crossfade with a slow push-in (composite.py's
   crossfade path), plus a radial speed-line overlay generated procedurally.
3. **Timing**: build-up 0.8–1.2 s, flash 2–4 frames, form B hold ≥ 1 s; total ≤ 6 s for social cuts.
4. **Deliverables**: `transformation.mp4` (+ loop + gif), form A/B stills, and the frame chain for re-editing.
5. Use for: outfit swaps, magical-girl/hero transformations, character "costume change" teasers. Do not use
   for face-swap of real people, or identity replacement inside existing footage.

# Mode 3 — Awaken (觉醒 / 登场) — line-art growth → mesh → colour → eyes open

The full `scripts/awaken/` pipeline from a single character sheet:

```bash
S=<skill folder>/scripts/awaken
# one command, scene-aware (scene: birth|gacha|meet|loading|splash|teaser|unlock|feed|screen|qr|stream)
bash $S/pipeline.sh sheet.png "<short English appearance>" birth work/character "[Name]"
#   env: THEME=hologram|gold|sakura|ink  ASPECT=16:9|9:16|1:1|21:9  NOVIDEO=1 (procedural only)  DRAFTS=2
```

Stages (each has its own script; resume-friendly — existing artefacts are skipped):

| Stage | Script | Output | Self-check |
|---|---|---|---|
| 1. keyframes | `gen.py keys` | 4 frames chained K3→K3c→K2→K1 (eyes open → closed → wireframe → line art) | look at all 4: face in frame, title area empty, eyes really closed, contours aligned |
| 2. prep | `prep.py` | normalised size, K0 empty frame, masks, face centre, title safe area | `keyframes.json` `align` ≥ 0.25, no `align_warnings`; else re-gen from the neighbouring frame |
| 3. AI clips | `gen.py clips` | K0→K1 line growth, K3c→K3 eye-open, 2 drafts each | look at `*_sheet.jpg`; reject single-pen tracing, scan bars, face drift |
| 4. composite | `composite.py` | master.mp4: procedural mesh sweep + colour burst from face centre + AI clips | `master.timeline.json` `qc.stalls_sec` empty |
| 5. export | `export.py` | web / short / teaser / loop / feed / gif presets | spot-check each preset |
| 6. pack | `pack.py` | `pack.json` + keys + theme + `<character-awaken>` web component | open `runtime/demo.html` next to the pack |

Phase control (no regeneration needed): `--until lines|mesh|color|eye` and `--from empty|lineart|mesh` on
`composite.py` give gacha tiers (R stops at mesh, SR at colour, SSR full), teasers (stop before colour) and
unlock variants (start from mesh) from one keyframe set. The live web component takes the same controls:
`<character-awaken pack="pack.json" until="mesh">`, `trigger="progress"` with `el.progress = 0..1` binds a real
loading bar. Scene recipes with copy-paste embed code: [references/awaken-scenes.md](references/awaken-scenes.md).

Model fallbacks (baked into `gen.py`): reads the environment's allowed-model list from the error and switches
(image: gpt-image-2 → gpt-image-2.5 → gemini → qwen; video: minimax-h3 → kling → seedance); `--dry-run` prints
all prompts for any external model; `NOVIDEO=1` runs fully procedural (cost = 4 images only).

## Which mode when

| User says | Mode |
|---|---|
| 开场动画 / intro / line-art reveal / draw-on / loading animation | Mode 1 (line-art growth) |
| 变身 / transformation / outfit swap / 形态切换 / costume change | Mode 2 (transformation) |
| 觉醒 / 登场 / awaken / 抽卡揭晓 / gacha reveal / character birth / 苏醒 | Mode 3 (awaken) |
| a plain “character animation” with no qualifier | Mode 1; offer Mode 3 in one line if the character is new-to-viewer |

All three modes share the same quality gates: look at every generated still; reject tracing-style line growth,
silhouette drift between chained frames, and stalls in the final cut (`qc.py check --video <out>`).

Skills

Skills Leaderboard

Built-in

character-startup-animation