⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

motion-3d

@kimeur⭐ 13 stars

Make a looping 3D motion-graphics film, 6 to 20 seconds, from a short brief. Real extruded, bevelled 3D type and SVG logos, plus boxes, spheres, tori, cylinders, cones and capsules, lit by a key light with soft shadows on a seamless floor, turning, flipping, hopping and orbiting on springs under a moving camera. Claude writes the film as one self-contained HTML file (a small WebGL2 renderer, no libraries) driven by a pure seek(t), checks it with an automated critique, and renders it to MP4, GIF and poster, square, vertical or wide, with real motion blur and a verified seamless loop. Use it for a 3D logo sting, a 3D title or wordmark reveal, an abstract 3D product teaser, a spinning badge, or a social loop with 3D type. Not for photoreal product renders, imported 3D models or characters. Other styles have their own skills: motion-launch-videos (kinetic type), motion-shapes, motion-cartoon, motion-charts, motion-pixel, motion-particles, motion-ui, motion-photo, motion-captions, motion-overlays and motion-globe.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 13 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

motion-launch-videos

Short launch and social videos made in code with Claude Code, in thirteen styles: kinetic type, flat shapes, cartoons, 3D, data charts, pixel art, particles, app UI, photo reels, captioned clips, overlays for editors, data globes and second-person story shorts. Each film is one self-contained HTML file that can draw any frame from the time alone, rendered to MP4 with real motion blur and a seamless loop that is checked, not hoped for, at 1:1, 9:16 or 16:9, with sound when it needs it and with transparency when it goes over footage.

Kinetic type: a 12 second launch bumper for Crux Kinetic type (motion-launch-videos): big type on springs, misregistration, mask wipes. ExampleFlat shapes: a checkbox draws itself, tasks tick off, a ring fills Shapes (motion-shapes): icons that draw on, pop and ripple, wipes, SVG logos. Example
Cartoon: Pip the bean hops, waves and holds up a sign Cartoon (motion-cartoon): an original mascot, on twos, with a boiling line. Example3D: the word ACME in extruded letters inside an orbiting ring 3D (motion-3d): extruded type and logos, soft shadows, a moving camera. Example
Charts: a counter, a column chart and a donut from demo data Charts (motion-charts): counters, bars, lines and donuts from sourced data. ExamplePixel art: a hero runs through a parallax landscape Pixel art (motion-pixel): sprites, parallax, a bitmap font, a strict palette. Example
Particles: a swarm forms a word, bursts and reforms Particles (motion-particles): swarms that form words and logos. ExampleApp UI: a phone taps through a travel planner App UI (motion-ui): taps, pushes and toasts in a device frame. Example
Photo: a flask pulls back, floats with tags, slides from graphite to sky, and four colourways slide past Photo (motion-photo): your own images in Ken Burns crops, parallax cutouts, carousels, a before/after slider and tags. ExampleCaptions: words pop in, in time with a voice-over Captions (motion-captions): your voice-over or podcast, every word on the frame it is said. Example, with sound
Overlays: a lower third wipes in at the bottom left, holds and wipes out Overlays (motion-overlays): lower thirds, cards, end screens and corner bugs, delivered with alpha. ExampleGlobe: a dotted Earth, routes arcing between cities, beams rising with HUD cards that count parcels Globe (motion-globe): a data globe from real geography, a flying camera, routes, beams and HUD cards. Example, with sound
Story: a second-person heist story, a car at night, cash bags, a motel, two texts, and the question STAY or RUN Story (motion-story): a 9:16 "you just robbed a bank" dilemma with drawn sets, a synthetic voice, word captions and HUD cards, ending on a question for the comments. Example, with sound

One film, three formats. Every style renders the same film square, vertical or wide (--format 9:16), laid out for each frame rather than cropped:

The chart and the app demo at 1:1, 9:16 and 16:9

The Crux film is a real launch bumper for the author's product: every word on screen is taken from the live site, with sources in its BRIEF.md. The other twelve are each skill's own demo, for fictional products (and, for the story skill, a fictional story), and say so on screen or in their brief. Another film, pixel-buffett-snowball, is a 36 second story on the pixel skill: a runner grows up while a snowball rolls after him and swells at every stop of Warren Buffett's life. Every sprite is drawn in code, every fact is in its BRIEF.md with its source, and it says on screen that it is an unofficial fan animation.

You give it a product and what the film should say, or just a URL, and a style if you have one in mind. Claude reads the product's site, writes 3 to 5 beats of at most four words each, designs every beat on the tempo grid, and writes the whole film as one HTML page. Then it checks the film with the skill's automated critique, renders it frame by frame, and verifies the MP4 it delivers.

The skills

SkillMakesAsk for it like
motion-launch-videosa kinetic-typography bumper or identity sting"Make a 12 second launch bumper for https://example.com"
motion-shapesflat 2D motion graphics: icons, draw-ons, ripples, wipes, an animated SVG logo"Animate our logo drawing itself on", "An explainer-style loop for our three features"
motion-cartoonan original mascot that notices you, hops, waves, talks and shows the product's name"Make a cartoon mascot saying hi for our app"
motion-3dextruded 3D type or a 3D logo with primitives, soft shadows and a moving camera"Make a 3D sting of our wordmark"
motion-chartsanimated charts from sourced data: counters, bars, lines, donuts"Animate these numbers from our launch post"
motion-pixelpixel-art loops: sprites, tiles, parallax, a bitmap font"A retro 8-bit teaser for our game"
motion-particlesparticle swarms that form words and logos, burst and reform"A particle reveal of our name"
motion-uiapp and product UI demos in a device frame, with callouts"An app-store style preview of our booking flow"
motion-photoproduct and photo reels from your own images: Ken Burns crops, parallax cutouts, carousels, before/after sliders, mosaics, price and feature tags"A 9:16 product reel from these shots of our new colours"
motion-captionscaptioned clips from your own voice-over, podcast or interview: pop captions, a karaoke line, subtitles or an audiogram, every word on the frame it is said"Caption this podcast clip for Reels"
motion-overlaystransparent overlays for editors and streamers: lower thirds, title and chapter cards, social handles, end screens, a corner bug, callouts, a LIVE badge"A lower third for our host as a transparent .mov"
motion-globea data globe film of a network worldwide: a dotted Earth from real geography, a camera that dives and flies between regions, routes, beams over each place with HUD cards that count,

// HOW IT'S BUILT

// FILES

21 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • plugins/motion-launch-videos/skills/motion-3d/SKILL.md9.4 KBf5041235e0dfupstream ↗
    ---
    name: motion-3d
    description: Make a looping 3D motion-graphics film, 6 to 20 seconds, from a short brief. Real extruded, bevelled 3D type and SVG logos, plus boxes, spheres, tori, cylinders, cones and capsules, lit by a key light with soft shadows on a seamless floor, turning, flipping, hopping and orbiting on springs under a moving camera. Claude writes the film as one self-contained HTML file (a small WebGL2 renderer, no libraries) driven by a pure seek(t), checks it with an automated critique, and renders it to MP4, GIF and poster, square, vertical or wide, with real motion blur and a verified seamless loop. Use it for a 3D logo sting, a 3D title or wordmark reveal, an abstract 3D product teaser, a spinning badge, or a social loop with 3D type. Not for photoreal product renders, imported 3D models or characters. Other styles have their own skills: motion-launch-videos (kinetic type), motion-shapes, motion-cartoon, motion-charts, motion-pixel, motion-particles, motion-ui, motion-photo, motion-captions, motion-overlays and motion-globe.
    ---
    
    # Motion 3D
    
    Chunky extruded type and simple solids in a clean studio: a floor that melts into the background, one key light, soft shadows, a camera that drifts. The whole film is one HTML file that can draw any moment from the time alone, so it previews in Chrome, renders frame-exact, and loops without a seam.
    
    The skill folder is `${CLAUDE_SKILL_DIR}`; the reference files call it `<skill>`. If the variable shows up literally or empty in your shell (you opened this file directly, as a subagent or from a copy), it is the folder that holds this SKILL.md: put that absolute path in every command below.
    
    A film lives in the user's project at `videos/<film>/` (`BRIEF.md`, `DESIGN.md`, `src/film.html`, `fonts/`, the built `<film>.html`, `stills/`, `renders/`).
    
    ## Ground rules
    
    - **True claims only.** Every word on screen comes from the product's own live pages and is logged with its URL in `BRIEF.md`. A product with no live site takes its words from the user's brief only. See [reference/brief.md](reference/brief.md).
    - **Only what is the user's to extrude.** Type from an open font, the user's own SVG logo, and primitives. Never another company's logo or a model of someone else's product.
    - **Four words a beat, one call to action.**
    - **`seek(t)` is pure.** No timers, `Date`, `Math.random`, state or CSS animation; seeded randomness only. Geometry is built once, after the fonts load.
    - **One file.** Fonts embedded as base64; the renderer is inline; nothing loads over the network. The build enforces it.
    - **The loop is seamless.** The default is a cycle loop: every spin and orbit turns a whole number of times, every keyed move comes back (a full turn counts), and `loopcheck` finds the seam as smooth as any other instant.
    - **Look before you ship.** Numbers pass while frames look wrong; read the stills and the decoded frames.
    - **The user decides what leaves the machine.** Get a yes before any commit, push or upload.
    
    ## Workflow
    
    0. **Once per machine.** `node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" doctor` checks Node 20+, playwright-core, a Chromium, ffmpeg with libx264, ffprobe, npm and tar, and prints the exact command for anything missing. WebGL2 runs on the GPU, or on Chromium's software renderer when there is none (slower, same pixels every time). Re-run it until it says `DOCTOR OK`.
    1. **Brief intake.** Name the video type first (a launch bumper, a feature highlight, a testimonial, an event promo...): [reference/video-types.md](reference/video-types.md) gives each type its length, formats, beats and the styles that fit. Read the product's live site, then ask at most one round of questions (the word or logo to build, the message, which formats to deliver (1:1, 4:5, 9:16, 16:9), duration, palette). Defaults: 1080 x 1080 only, 10 s, 60 fps, 120 BPM, cycle loop, the template's palette or the brand's colours. For a logo, ask for the SVG. Fill [templates/BRIEF.md](templates/BRIEF.md) into `videos/<film>/BRIEF.md`. See [reference/brief.md](reference/brief.md).
    2. **Copy and staging.** 1 to 3 beats: the hero (the word or the logo), what moves round it, a call to action in flat labels. At most 4 words of 3D type. Show the user and proceed unless they object; when nobody can answer, write them into BRIEF.md and proceed.
    3. **Design spec.** Fill [templates/DESIGN.md](templates/DESIGN.md) into `videos/<film>/DESIGN.md`: palette and materials, the light, the camera and its moves, every object with its size, place, material and motion on the tempo grid, the loop, and what changes in each other format. Read [reference/3d-design.md](reference/3d-design.md), [reference/engine.md](reference/engine.md) and [reference/springs.md](reference/springs.md).
    4. **Build and frame.** Copy [templates/film.html](templates/film.html) to `videos/<film>/src/film.html` and transcribe DESIGN.md into its `FILM` block (edit nothing below it). Fetch the fonts, build, and check the framing:
       ```bash
       node "${CLAUDE_SKILL_DIR}/scripts/fonts.mjs" videos/<film>
       node "${CLAUDE_SKILL_DIR}/scripts/build.mjs" videos/<film>
       node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" layout videos/<film>    # triangles, on-screen boxes at 0 s
       node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" at videos/<film> 0 2.5 5 7.5   # sharp stills to look at
       ```
       Move the camera (target, distance, pitch) until the hero sits in the live area with room to move. For each other format, add `--format 9:16` (or `16:9`, `4:5`) to `layout` and `at`, and write its patch in `FILM.formats`: the camera fits the hero by itself, the patch redesigns the rest (engine.md, Formats). See [reference/fonts.md](reference/fonts.md) and [reference/core.md](reference/core.md).
    5. **Stills and critique.** `node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" stills videos/<film>` runs the automated critique (glyph coverage, words, the 3D type inside the live area through the loop and big enough to read, mesh counts, label contrast and placement, the loop and its cycles, the composition's balance) and writes stills at every key moment plus `stills/contact.png`. Run it once per delivered format, with `--format 9:16` and so on (stills land in `stills/9x16/`). Read them for silhouettes, intersections, shadows and legibility; fix and repeat. See [reference/review.md](reference/review.md).
    6. **Render and verify.**
       ```bash
       node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" loopcheck videos/<film>   # purity 0, the seam continuous
       node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" render videos/<film>      # MP4, GIF, poster (start it in the background)
       node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" verify videos/<film>      # ffprobe facts, tags, decoded pixels
       node "${CLAUDE_SKILL_DIR}/scripts/render.mjs" mp4frames videos/<film>   # decoded review frames + PSNR
       ```
       Run `loopcheck`, `render`, `verify` and `mp4frames` once per delivered format, with the same `--format` (the outputs carry it: `renders/<film>-9x16.mp4`, `preview-9x16.gif`, `poster-9x16.png`). Look at `stills/mp4/contact.png` and a strip of the whole film. Report the files, their sizes and the verify, loopcheck and mp4frames lines. See [reference/render.md](reference/render.md) and [reference/loops.md](reference/loops.md).
    
    ## Pass criteria
    
    - The hero reads in every frame of every delivered format: 3D type inside the live area at every sampled moment, its cap height at least 60 px on screen, front faces light against the background.
    - The composition row passes at every delivered format, and each format looks designed for its frame, not a square picture floating in it.
    - Nothing passes through anything: no ring through a letter, no orb through the floor, no letter through its neighbour while it flips.
    - One key light, soft shadows grounding every object on the floor; the floor meets the background with no visible horizon.
    - Every spin and orbit a whole number of turns per loop; every keyed value back where it started.
    - Motion blur on moving frames; flat labels sharp.
    - The deliverable MP4 is H.264, yuv420p, BT.709-tagged in the stream, faststart, exactly DUR x FPS frames.
    
    ## Known pitfalls
    
    - A torus spinning about its own axis looks still; tilt it and orbit it (`loop: { orbit: [1, 0] }`) so the tilt turns.
    - Anything whose lowest point dips below the floor is cut by it. Keep `pos.y` at least the object's lower extent.
    - The palette gate is not run for 3D: shading, antialiasing and motion blur make in-between colours at every silhouette. The lighting is hue-preserving (a surface is its colour times a light level, plus white), so surfaces keep their hue.
    - Thin strokes and small counters in a light face extrude into slivers and break the bevel; use heavy display faces (Unbounded 800 to 900, Archivo Black).
    - A letter flipping about x sweeps through its neighbours if the tracking is tight; give flipping type +30 to +60 tracking.
    - The software renderer is slow: without a GPU, a 1080 x 1080 subframe with 4x MSAA and soft shadows takes 0.1 to 0.3 s, so the 10 s demo renders in 4 to 8 minutes (slow drifts take 2 subframes, fast flips up to 9). Keep scenes under about 100k triangles, and moves that need dozens of subframes rare.
    - In a narrower format the camera's distance is multiplied by the fit, keys included: a patch sets `camera.dist` as it would be at 1:1, and a patch that sets `pitch` or `target` changes the fit too (it is measured from the rest camera).
    - Contrast is checked on the material colours, but the lit front face is darker than its colour by up to a third: keep light type on a dark background or the reverse.
    
  • plugins/motion-launch-videos/skills/motion-3d/scripts/build.mjs5.2 KBcf98a599e4afupstream ↗
    #!/usr/bin/env node
    // Build the film's single self-contained HTML file.
    //
    //   node <skill>/scripts/build.mjs <filmDir> [--src src/film.html]
    //
    // Reads <filmDir>/src/film.html, replaces every __FONT:<file>__ token with the base64 of
    // <filmDir>/fonts/<file> and every __ASSET:<path>__ token with a data: URL of <filmDir>/<path>
    // (images, audio, subtitles), adds a comment crediting each embedded font under its OFL, and writes
    // <filmDir>/<name>.html, where <name> is the folder's name. It fails when a font file is missing,
    // when a token is left over, or when the page would load anything over the network.
    // It also copies FILM.title, FILM.palette.bg and FILM.W x FILM.H into the page's <title>, its CSS
    // background and the <canvas> size, so the file reads right before its script runs (and to
    // anything that reads the HTML without running it). Only literal values are copied.
    import fs from 'node:fs';
    import path from 'node:path';
    import { fileURLToPath } from 'node:url';
    
    export function build(filmDir, srcRel = path.join('src', 'film.html')) {
      const dir = path.resolve(filmDir);
      const name = path.basename(dir);
      const srcPath = path.join(dir, srcRel);
      if (!fs.existsSync(srcPath)) throw new Error(`no ${srcPath}. Copy <skill>/templates/film.html there first.`);
      let html = fs.readFileSync(srcPath, 'utf8');
      html = syncHead(html);
    
      const credits = [];
      html = html.replace(/__FONT:([A-Za-z0-9._-]+\.woff2)__/g, (_, file) => {
        const f = path.join(dir, 'fonts', file);
        if (!fs.existsSync(f)) throw new Error(`missing fonts/${file}. Run: node <skill>/scripts/fonts.mjs ${filmDir}`);
        const pkg = file.replace(/-(latin|latin-ext|cyrillic|greek|vietnamese)(-ext)?-\d+-(normal|italic)\.woff2$/, '');
        const ofl = path.join(dir, 'fonts', `OFL-${pkg}.txt`);
        const line = fs.existsSync(ofl) ? fs.readFileSync(ofl, 'utf8').split('\n')[0].split(/(?<=\.)\s/)[0].trim() : 'licence text not found';
        credits.push(`${file}: ${line}`);
        return fs.readFileSync(f).toString('base64');
      });
    
      // __ASSET:<path>__ becomes a data: URL of <filmDir>/<path> (images, audio, subtitles, JSON): the user's own
      // screenshots, photos, voice-over or music, embedded like the fonts so nothing loads at runtime
      html = html.replace(/__ASSET:([A-Za-z0-9._\/-]+)__/g, (_, rel) => {
        const f = path.resolve(dir, rel);
        if (!f.startsWith(dir + path.sep)) throw new Error(`asset ${rel} is outside the film folder`);
        if (!fs.existsSync(f)) throw new Error(`missing asset ${rel} (put it in ${dir})`);
        const mime = ASSET_TYPES[path.extname(f).slice(1).toLowerCase()];
        if (!mime) throw new Error(`asset ${rel}: unknown type (${Object.keys(ASSET_TYPES).join(', ')})`);
        return `data:${mime};base64,${fs.readFileSync(f).toString('base64')}`;
      });
    
      const left = html.match(/__(?:FONT|ASSET)[^_]*__/);
      if (left) throw new Error(`unreplaced token ${left[0]} in ${srcRel}`);
      const external = [
        /<(?:script|link|img|iframe|video|audio|source)\b[^>]*\b(?:src|href)\s*=\s*["']?(?:https?:)?\/\//i,
        /url\(\s*["']?(?:https?:)?\/\//i,
        /@import\b/i,
        /\bfetch\s*\(/,
      ].find((re) => re.test(html));
      if (external) throw new Error(`${srcRel} loads something over the network (${external}); the film must be one self-contained file`);
    
      if (credits.length) {
        const note = `<!-- Fonts embedded under the SIL Open Font License 1.1:\n     ${credits.join('\n     ')} -->\n`;
        html = html.replace(/^(<!doctype html>\s*)/i, `$1${note}`);
      }
      const out = path.join(dir, `${name}.html`);
      fs.writeFileSync(out, html);
      return out;
    }
    
    const ASSET_TYPES = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', webp: 'image/webp', gif: 'image/gif', svg: 'image/svg+xml',
      mp3: 'audio/mpeg', m4a: 'audio/mp4', aac: 'audio/aac', wav: 'audio/wav', ogg: 'audio/ogg', opus: 'audio/ogg',
      json: 'application/json', srt: 'text/plain', vtt: 'text/vtt', txt: 'text/plain' };
    
    // the static head follows FILM: <title>, the page background and the canvas size
    function syncHead(html) {
      const at = html.search(/\bconst FILM\s*=\s*\{/);
      if (at < 0) return html;
      const film = html.slice(at);
      const str = (key) => {
        const m = new RegExp(`\\b${key}:\\s*(['"\`])((?:(?!\\1)[^\\\\]|\\\\.)*)\\1`).exec(film);
        return m && !/\$\{/.test(m[2]) ? m[2].replace(/\\(.)/g, '$1') : null;
      };
      const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
      const title = str('title');
      if (title != null) html = html.replace(/<title>[^<]*<\/title>/i, `<title>${esc(title)}</title>`);
      const bg = str('bg');
      if (bg && /^#[0-9A-Fa-f]{3}(?:[0-9A-Fa-f]{3})?$/.test(bg)) html = html.replace(/(html,\s*body\s*\{[^}]*?background:\s*)#[0-9A-Fa-f]{3,8}/i, `$1${bg}`);
      const wh = /\bW:\s*(\d+)\s*,\s*H:\s*(\d+)\b/.exec(film);
      if (wh) html = html.replace(/<canvas id="c" width="\d+" height="\d+">/, `<canvas id="c" width="${wh[1]}" height="${wh[2]}">`);
      return html;
    }
    
    if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
      const args = process.argv.slice(2);
      if (!args.length) { console.error('usage: node build.mjs <filmDir> [--src src/film.html]'); process.exit(2); }
      const i = args.indexOf('--src');
      const out = build(args[0], i > 0 ? args[i + 1] : undefined);
      console.log(`wrote ${out} (${fs.statSync(out).size} bytes)`);
    }
    
  • plugins/motion-launch-videos/skills/motion-3d/scripts/cmap.mjs5.2 KBb742391bc947upstream ↗
    #!/usr/bin/env node
    // Which characters does a WOFF2 font really contain? Reads its cmap (Unicode -> glyph) table.
    //
    //   node <skill>/scripts/cmap.mjs <font.woff2> "TEXT TO CHECK"
    //
    // The browser cannot answer this: a missing glyph silently falls back to another font. So the
    // render script reads the cmap of every embedded face and checks the film's text against it.
    // No dependencies: WOFF2 is a Brotli stream, and Node's zlib decodes Brotli.
    import fs from 'node:fs';
    import path from 'node:path';
    import zlib from 'node:zlib';
    import { fileURLToPath } from 'node:url';
    
    const KNOWN = ['cmap', 'head', 'hhea', 'hmtx', 'maxp', 'name', 'OS/2', 'post', 'cvt ', 'fpgm', 'glyf', 'loca', 'prep', 'CFF ', 'VORG', 'EBDT', 'EBLC', 'gasp', 'hdmx', 'kern', 'LTSH', 'PCLT', 'VDMX', 'vhea', 'vmtx', 'BASE', 'GDEF', 'GPOS', 'GSUB', 'EBSC', 'JSTF', 'MATH', 'CBDT', 'CBLC', 'COLR', 'CPAL', 'SVG ', 'sbix', 'acnt', 'avar', 'bdat', 'bloc', 'bsln', 'cvar', 'fdsc', 'feat', 'fmtx', 'fvar', 'gvar', 'hsty', 'just', 'lcar', 'mort', 'morx', 'opbd', 'prop', 'trak', 'Zapf', 'Silf', 'Glat', 'Gloc', 'Feat', 'Sill'];
    
    function tablesOfWoff2(buf) {
      if (buf.toString('latin1', 0, 4) !== 'wOF2') throw new Error('not a WOFF2 file');
      if (buf.toString('latin1', 4, 8) === 'ttcf') throw new Error('font collections are not supported');
      const numTables = buf.readUInt16BE(12), compressed = buf.readUInt32BE(20);
      let off = 48;
      const base128 = () => { let v = 0; for (let i = 0; i < 5; i++) { const b = buf[off++]; v = v * 128 + (b & 0x7f); if (!(b & 0x80)) return v; } throw new Error('bad UIntBase128'); };
      const dir = [];
      for (let i = 0; i < numTables; i++) {
        const flags = buf[off++], idx = flags & 0x3f, ver = flags >> 6;
        const tag = idx === 63 ? buf.toString('latin1', off, (off += 4)) : KNOWN[idx];
        const orig = base128();
        const transformed = tag === 'glyf' || tag === 'loca' ? ver === 0 : ver !== 0;
        const len = transformed ? base128() : orig;
        dir.push({ tag, len });
      }
      const data = zlib.brotliDecompressSync(buf.subarray(off, off + compressed));
      const tables = {};
      let p = 0;
      for (const t of dir) { tables[t.tag] = data.subarray(p, p + t.len); p += t.len; }
      return tables;
    }
    
    export function woff2Cmap(file) {
      const cmap = tablesOfWoff2(fs.readFileSync(file)).cmap;
      if (!cmap) throw new Error(`${file} has no cmap table`);
      const n = cmap.readUInt16BE(2), subs = [];
      for (let i = 0; i < n; i++) subs.push({ pid: cmap.readUInt16BE(4 + i * 8), eid: cmap.readUInt16BE(6 + i * 8), off: cmap.readUInt32BE(8 + i * 8) });
      const rank = (s) => { const f = cmap.readUInt16BE(s.off); return (f === 12 ? 10 : f === 4 ? 5 : 0) + (s.pid === 3 ? 1 : 0); };
      const best = subs.filter((s) => [4, 12].includes(cmap.readUInt16BE(s.off))).sort((a, b) => rank(b) - rank(a))[0];
      if (!best) throw new Error(`${file}: no Unicode cmap subtable (format 4 or 12)`);
      const set = new Set(), o = best.off, fmt = cmap.readUInt16BE(o);
      if (fmt === 12) {
        const groups = cmap.readUInt32BE(o + 12);
        for (let g = 0; g < groups; g++) {
          const s = cmap.readUInt32BE(o + 16 + g * 12), e = cmap.readUInt32BE(o + 20 + g * 12), gid = cmap.readUInt32BE(o + 24 + g * 12);
          for (let c = s; c <= e; c++) if (gid + (c - s) !== 0) set.add(c);
        }
      } else {
        const seg = cmap.readUInt16BE(o + 6) / 2;
        const ends = o + 14, starts = ends + seg * 2 + 2, deltas = starts + seg * 2, ranges = deltas + seg * 2;
        for (let i = 0; i < seg; i++) {
          const end = cmap.readUInt16BE(ends + i * 2), start = cmap.readUInt16BE(starts + i * 2);
          const delta = cmap.readInt16BE(deltas + i * 2), ro = cmap.readUInt16BE(ranges + i * 2);
          for (let c = start; c <= end && c !== 0xffff; c++) {
            let gid;
            if (ro === 0) gid = (c + delta) & 0xffff;
            else { const at = ranges + i * 2 + ro + (c - start) * 2; gid = at + 1 < cmap.length ? cmap.readUInt16BE(at) : 0; if (gid) gid = (gid + delta) & 0xffff; }
            if (gid) set.add(c);
          }
        }
      }
      return set;
    }
    
    export function missingChars(file, text) {
      const have = woff2Cmap(file);
      return [...new Set(Array.from(text))].filter((c) => !/\s/.test(c) && !have.has(c.codePointAt(0)));
    }
    
    // @font-face rules of a film source: family + weight -> embedded woff2 file name
    export function fontFaces(html) {
      const out = [];
      for (const m of html.matchAll(/@font-face\s*{([^}]*)}/g)) {
        const body = m[1];
        const fam = /font-family\s*:\s*["']?([^;"']+)["']?/.exec(body), wt = /font-weight\s*:\s*(\d+)/.exec(body), file = /__FONT:([A-Za-z0-9._-]+\.woff2)__/.exec(body);
        if (fam && file) out.push({ family: fam[1].trim(), weight: wt ? wt[1] : '400', file: file[1] });
      }
      return out;
    }
    
    if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
      const [file, text] = process.argv.slice(2);
      if (!file) { console.error('usage: node cmap.mjs <font.woff2> ["text"]'); process.exit(2); }
      const set = woff2Cmap(file);
      console.log(`${path.basename(file)}: ${set.size} characters`);
      if (text) {
        const miss = missingChars(file, text);
        console.log(miss.length ? `MISSING ${miss.map((c) => `"${c}" U+${c.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')}`).join(', ')}` : 'all present');
        if (miss.length) process.exitCode = 1;
      }
    }
    
  • plugins/motion-launch-videos/skills/motion-3d/scripts/fonts.mjs4.9 KB22c02a7ff1a2upstream ↗
    #!/usr/bin/env node
    // Fetch the film's fonts as WOFF2 subsets from Fontsource, with their OFL texts.
    //
    //   node <skill>/scripts/fonts.mjs <filmDir> [--face <package>:<weight>[:<style>]]... [--subset latin]
    //
    // With no --face, it fetches every face <filmDir>/src/film.html embeds: each @font-face token
    // __FONT:<package>-<subset>-<weight>-<style>.woff2__ names one (a film with no tokens needs none).
    // Without a src/film.html yet, it fetches the kinetic-type defaults:
    //   archivo-black:400   display
    //   syne:800            label
    //   ibm-plex-mono:500   mono
    //
    // Each face comes from `npm pack @fontsource/<package>@5` (the registry tarball, nothing is
    // installed), and lands in <filmDir>/fonts/ as <package>-<subset>-<weight>-<style>.woff2, next to
    // OFL-<package>.txt. The build step embeds the WOFF2 as base64; nothing loads at runtime.
    // Needs Node >= 20, npm and tar on PATH, and network access to the npm registry.
    import fs from 'node:fs';
    import os from 'node:os';
    import path from 'node:path';
    import crypto from 'node:crypto';
    import { execFileSync } from 'node:child_process';
    import { missingChars } from './cmap.mjs';
    
    const args = process.argv.slice(2);
    if (!args.length || args[0].startsWith('--')) {
      console.error('usage: node fonts.mjs <filmDir> [--face archivo-black:400] [--subset latin]');
      process.exit(2);
    }
    const filmDir = path.resolve(args[0]);
    const faces = [];
    let subset = null;
    for (let i = 1; i < args.length; i++) {
      if (args[i] === '--face') faces.push(args[++i]);
      else if (args[i] === '--subset') subset = args[++i];
      else throw new Error(`unknown argument ${args[i]}`);
    }
    const SUBSETS = 'latin|latin-ext|cyrillic|cyrillic-ext|greek|greek-ext|vietnamese';
    const src = path.join(filmDir, 'src', 'film.html');
    if (!faces.length && fs.existsSync(src)) {               // the faces the film's source embeds
      const re = new RegExp(`__FONT:([a-z0-9-]+?)-(${SUBSETS})-(\\d+)-(normal|italic)\\.woff2__`, 'g');
      for (const m of fs.readFileSync(src, 'utf8').matchAll(re)) {
        const spec = `${m[1]}:${m[3]}:${m[4]}:${subset || m[2]}`;
        if (!faces.includes(spec)) faces.push(spec);
      }
      if (faces.length) console.log(`faces from ${path.relative(process.cwd(), src) || src}: ${faces.map((f) => f.split(':').slice(0, 2).join(':')).join(', ')}`);
      else { console.log(`no __FONT:...__ tokens in ${path.relative(process.cwd(), src) || src}: the film embeds no fonts, nothing to fetch`); process.exit(0); }
    }
    if (!faces.length) faces.push('archivo-black:400', 'syne:800', 'ibm-plex-mono:500');
    
    const outDir = path.join(filmDir, 'fonts');
    fs.mkdirSync(outDir, { recursive: true });
    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mlv-fonts-'));
    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
    
    const packed = new Map();                                 // one tarball per package, however many faces
    function pack(pkg) {
      if (packed.has(pkg)) return packed.get(pkg);
      const dest = path.join(tmp, pkg);
      fs.mkdirSync(dest);
      const json = execFileSync(npm, ['pack', `@fontsource/${pkg}@5`, '--json', '--pack-destination', dest], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit'] });
      const info = JSON.parse(json)[0];
      execFileSync('tar', ['-xzf', path.join(dest, info.filename), '-C', dest]);
      packed.set(pkg, { dest, info });
      return packed.get(pkg);
    }
    
    try {
      for (const spec of faces) {
        const [pkg, weight = '400', style = 'normal', sub = subset || 'latin'] = spec.split(':');
        if (!/^[a-z0-9-]+$/.test(pkg)) throw new Error(`bad package name "${pkg}"`);
        const { dest, info } = pack(pkg);
        const file = `${pkg}-${sub}-${weight}-${style}.woff2`;
        const src = path.join(dest, 'package', 'files', file);
        if (!fs.existsSync(src)) {
          const have = fs.readdirSync(path.join(dest, 'package', 'files')).filter((f) => f.startsWith(`${pkg}-${sub}-`) && f.endsWith('.woff2'));
          throw new Error(`@fontsource/${pkg}@${info.version} has no ${file}. Available: ${have.join(', ') || 'none for this subset'}`);
        }
        fs.copyFileSync(src, path.join(outDir, file));
        const lic = ['LICENSE', 'LICENSE.md', 'OFL.txt'].map((f) => path.join(dest, 'package', f)).find((f) => fs.existsSync(f));
        if (!lic) throw new Error(`@fontsource/${pkg} ships no LICENSE file; check its licence before using it`);
        const text = fs.readFileSync(lic, 'utf8');
        if (!/SIL OPEN FONT LICENSE/i.test(text)) console.warn(`warning: ${pkg} is not under the SIL OFL; read ${lic} before shipping`);
        fs.writeFileSync(path.join(outDir, `OFL-${pkg}.txt`), text);
        const buf = fs.readFileSync(src);
        const md5 = crypto.createHash('md5').update(buf).digest('hex');
        const miss = missingChars(path.join(outDir, file), '€É×’–—·');
        console.log(`${file.padEnd(44)} ${String(buf.length).padStart(7)} B  md5 ${md5}  (@fontsource/${pkg}@${info.version})${miss.length ? `  lacks ${miss.join(' ')}` : ''}`);
      }
      console.log(`fonts in ${outDir}`);
    } finally {
      fs.rmSync(tmp, { recursive: true, force: true });
    }
    
  • plugins/motion-launch-videos/skills/motion-3d/scripts/render.mjs61 KBd514cb2c6e0fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • plugins/motion-launch-videos/skills/motion-3d/package.json475 Bcbbdfe1e5fc3upstream ↗
    {
      "name": "motion-3d-scripts",
      "private": true,
      "description": "Scripts for the motion-3d skill: fetch fonts, build one self-contained HTML film, render it to MP4 with motion blur, verify the loop.",
      "type": "module",
      "license": "MIT",
      "engines": { "node": ">=20" },
      "scripts": {
        "fonts": "node scripts/fonts.mjs",
        "build": "node scripts/build.mjs",
        "render": "node scripts/render.mjs"
      },
      "dependencies": {
        "playwright-core": "1.63.0"
      }
    }
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/3d-design.md5.3 KB683b18f057c8upstream ↗
    # 3D design: a clean studio, one hero, a camera that breathes
    
    Step 3. What makes simple 3D read as designed: a hero object, a light that models it, a floor that grounds it, and motion that respects weight.
    
    ## The hero
    
    - **One hero per film**: the word, or the logo. Everything else (rings, orbs, cubes) orbits it, frames it or points at it, and is smaller, quieter in colour, and further back.
    - **Heavy type extrudes best.** Unbounded 800 to 900 or Archivo Black: thick strokes make solid walls and a clean bevel. A light weight turns into slivers.
    - **Depth about half the cap height, bevel about a twentieth.** Deep enough that the walls show at an angle, shallow enough that the letters stay a word. Track flipping type open (+30 to +60).
    - **Two colours on the type**: a light face and a saturated side (`side`). The side colour carries the brand; the face carries legibility.
    - **A logo as it is.** Paste the user's SVG path into a `path` object; extrude it; check its silhouette against the flat logo. Never redraw a mark from memory.
    
    ## Light
    
    - **One key light from above, in front and to one side** (`dir` with a strong -y and a -z toward the camera's side). It models the bevels and puts the shadow behind and beside the hero, where it grounds it without covering the floor in front.
    - **Ambient 0.3 to 0.4**, so shadowed sides keep their colour instead of going black.
    - **Gloss for small things, matte for big ones.** Spheres and rings at 0.5 to 0.7 get a clean highlight; type at 0.3 to 0.4 stays readable.
    - **Rim 0.1 to 0.2** separates dark objects from a dark background.
    - **Shadows soft and not too dark** (floor `shadow` 0.35 to 0.5, `soft` 1.5 to 2).
    
    ## The floor and the background
    
    The floor is a shadow catcher: drawn in the background colour and darkened only where shadowed, so the scene sits in an infinite studio with no horizon line. Choose a background that is not the hero's colour: a deep violet under cream and coral type, a warm off-white under ink and red. A dark background makes glossy highlights sing; a light one reads as clay.
    
    ## Camera
    
    - **A three-quarter view** (yaw 12 to 25 degrees, pitch 10 to 20) shows the type's walls and its shadow; straight on, extrusion is invisible.
    - **A long lens** (field of view 25 to 35) keeps the type from distorting; move the camera back instead of widening it.
    - **Move slowly and continuously.** A sway of 8 to 12 degrees once per loop and a dolly of 5 to 10 % on DOLLY make the scene breathe. Fast camera moves read as a mistake unless they are the point.
    - **Frame for the whole loop.** Check stills across the loop: orbiting things leave the frame at the sides (fine), the hero never does.
    
    ## Formats
    
    The camera frames the other formats by itself (engine.md, Formats): in a narrower frame it pulls back until the hero keeps its width; in a wider one it keeps the height. That keeps the hero inside the live area. Designing the format is still yours:
    
    - **9:16 (1080 x 1920).** The hero fills the width, and the height is spare. A ring or an orbit wider than the hero would be cut at one side and not the other, which reads as a mistake: name it in `camera.contain` so it stays whole. Look down more steeply (pitch 25 to 35) so a ring or a floor pattern opens into a tall shape, let supporting objects rise and fall through the extra height, and keep the labels with the hero, under it (no pin), rather than at the bottom edge, where platform captions sit and where the scene would lean.
    - **16:9 (1920 x 1080).** The hero keeps its height and the frame gains width. Bring the camera closer (dist 10 to 20 % less) so the scene spans half to two thirds of the width, or give the sides something to do: orbits that swing wide, a second object. Labels under the hero as at 1:1.
    - **4:5 (1080 x 1350).** The fit alone is usually enough.
    
    Check every format you deliver with `stills --format`: the type must stay in the live area, and the composition row balanced.
    
    ## Motion with weight
    
    - **Letters one at a time.** A stagger of a 16th across the glyphs turns a move into a wave: a flip (`rx: -360` on FLIP), a hop (`dy` up on HOP, down on LAND), a turn (`ry: 360`).
    - **Big things move slowly.** A cube tumbles on SETTLE, a sphere bobs a fraction of its size.
    - **Orbits and spins are whole cycles per loop**, so the loop closes by construction. One or two turns per 10 s is calm; four is busy.
    - **Overlap** one object's move with another's settle; nothing waits.
    - **Something moves on every beat**, but the hero moves on the big ones: a flip on bar 1, a hop on bar 3.
    
    ## Composition
    
    - The hero's optical centre slightly above the frame centre; flat labels (the domain, small print) under it on the 8 px grid, in the live area.
    - Leave air: the hero at 50 to 70 % of the frame's width.
    - Orbiting objects pass in front of the hero only briefly and never cover its words. A ring round a word belongs near the floor: at mid-height its near arc slices across the letters whenever its tilt turns toward the camera.
    
    ## Things that look good in a still and bad in motion
    
    - A ring through a letter: it flickers as the depth test decides which is in front.
    - A spin about a symmetric object's own axis: it looks still, so the eye reads it as a stall.
    - A shadow that pops when an object leaves the shadow box: keep everything within `shadowBox` of the centre.
    - A camera move and a hero move in the same direction at once: the hero seems to stand still.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/audio.md13 KBa694676656b6upstream ↗
    # Audio: sound effects from cues, a music track, loudness
    
    A film is silent unless `FILM.audio` is set. With it, the page synthesises sound effects from **cues** placed on the timeline, and, with `bed`, a score of its own under them; `render.mjs` mixes them with an optional **track** (the user's own music or voice-over), normalises the mix to a target loudness and muxes it into the MP4 as AAC. A film without `FILM.audio` renders exactly as before, with no audio stream.
    
    ```js
    audio: {
      track: 'assets/music.mp3',   // optional: a file in the film folder
      gain: -3,                    // the track's gain in dB
      fadeIn: 0, fadeOut: 0.5,     // the track's fades, in s
      offset: 12.0,                // where in the track the film starts, in s
      sfx: 0,                      // the cue mix's gain in dB, or false for no sound effects
      loudness: -16,               // the target integrated loudness in LUFS
      auto: true,                  // a cue per accent and per cut (below)
      cues: [{ t: beat(4), kind: 'hit' }, { t: bar(3), kind: 'riser', dur: 1.5 }],
      bed: { key: 'D minor' },     // music without a track: a pad, drone, bass, air and glints (below)
      space: { rt60: 2.6 },        // the reverb the bed and the tonal cues send to; false for none
    },
    ```
    
    ## Music you may use
    
    Only audio the user has the right to put in this video:
    
    - **Their own** music, recordings or voice-over.
    - **Licensed** music whose licence covers this use: online video and, for a launch or an ad, commercial use (stock libraries sell exactly this; keep the licence).
    - **Public domain** recordings: the composition and the recording must both be free. A new recording of an old piece is usually not.
    - **Creative Commons** tracks that allow commercial use and changes (CC0, CC BY, CC BY-SA): trimming, looping and fading are changes. Credit CC BY and CC BY-SA tracks where the video is published. Not NC (non-commercial) or ND (no derivatives) for a launch video.
    
    Never a commercial song, however short the clip. Write where the track came from and its licence in BRIEF.md, next to the fonts. Put the file in `videos/<film>/assets/`; `track` is a path inside the film folder. The track is mixed by ffmpeg at render time and is not embedded in the HTML (the preview plays the cue mix only).
    
    ## Cues
    
    A cue is a sound at a time. The engine places cues in `build()` with `cue(t, kind, opts)`, the same way it registers accents and cuts; `FILM.audio.cues` adds cues by hand; `auto` derives them. Every sound is synthesised in the page (oscillators, filters, and noise from a seeded buffer), so the same film always gives the same samples, and nothing is downloaded.
    
    | Kind | Sound | Use it for |
    |---|---|---|
    | `pop` | a short falling blip | something appearing, a scale-in, a bubble |
    | `hit` | a punchy low thump with a crack | a slam, a stamp, a word landing |
    | `thud` | a deep soft thump | a heavy landing, a drop onto the floor |
    | `whoosh` | filtered noise swelling into t and panning across | a cut, a wipe, a fast move (peaks on t) |
    | `swish` | a short high whoosh | a small quick move, a card flick |
    | `riser` | rising noise and tone that ends on t | the build before a reveal (`dur`, default 1.2 s) |
    | `tick` | a tiny bright tick | a counter, a clock, a checkbox |
    | `tap` | a soft wooden tap | a UI tap, a key press |
    | `click` | a crisp click | a button, a toggle |
    | `snap` | a finger snap | a snap cut, a pose change |
    | `blip` | a two-note square blip | pixel art, a game UI |
    | `coin` | the two-note pickup | a coin, a point scored |
    | `boing` | a sine that wobbles | a squash and stretch, a bounce |
    | `drop` | a falling sine | something falling away, an exit |
    | `chime` | a bell with a long tail | the lockup, a success |
    | `sparkle` | five quick high pings | a shimmer, a sparkle |
    | `boom` | a sub hit gliding down onto its note, with a long tail; the bed ducks under it | the film's structural beats: the world forming, the drop, the pull back, the lockup (3 or 4 a film) |
    | `swell` | reversed noise and the chord's tones swelling into t and cut hard on it, the low end dropping out before it | the tension before a boom (`dur`, default 1 s; 0.5 for a short lift, 2 for an intro) |
    | `arc` | a noise swell peaking on t with a sine rising a perfect fifth, panned along the move | a flight, a long camera move, an arc across the screen (`dur`, default 1.4 s; `from`, `to` pans) |
    | `ping` | three partials chirping down 20 % with a wet tail | a pin, a reticle locking, a card arriving |
    | `data` | a seeded burst of tiny blips in the key | typing (`regular: true`, `rate` = characters a second), a counter rolling, a data stream (`dur`, default 0.6 s) |
    | `lock` | a quiet two-tone confirmation | a status turning complete, a region locking |
    | `pad` | one chord of the bed's pad | a chord placed by hand (`chord: 'VI maj7'`, `dur`) |
    | `drone` | a sustained low note with slow beating | a drone placed by hand (`note: 'D2'`, `dur`) |
    
    Options, all optional: `gain` (dB), `pitch` (a factor: 2 is an octave up), `pan` (-1 left to 1 right), `dur` (whoosh, swish, riser, boom, swell, arc, data, pad, drone), `seed`, `vary`. Repeats of one kind vary by up to 2 % in pitch and 1 dB in level, seeded by their order, so a row of pops does not sound like a machine; `vary: 0` turns that off. Two cues of one kind within 40 ms sound once.
    
    The last eight kinds are **tonal**: their pitch is a note, and `vary` changes only their level, so a chord never goes out of tune. `note` sets it (`'A5'`, `'F#4'`, or a frequency in Hz); without one, and with a bed, a tonal cue takes the tone of the chord sounding at t nearest its default (a ping near 2.2 kHz, an arc near 2.1 kHz, a lock near 1.76 kHz, a boom on the key's tonic in octave 1), and a `chime` moves into the key too. Without a bed they sit on their defaults. More options: `crack: true` (boom, a short bright crack on top), `gap: false` (swell, keep the low end under it), `rate`, `regular`, `lo`, `hi` (data, the blips' range in Hz), `chord`, `key` (pad without a bed). `riser` takes `shape: 'exp'`: the reverse-exponential swell of `swell`, cut hard on t (`'lin'`, the default, is the riser as it always was).
    
    **`auto`**: `true` adds a `pop` at every accent (`accentAt`) and a `whoosh` at every cut (`cutAt`), so every engine gets sound without a line of code. `auto: { accent: 'tick', cut: 'swish', accentGain: -4, cutGain: -2 }` picks other kinds and levels; a kind of `false` turns that half off. An engine that knows its film better (a cartoon's hops, a UI's taps) places its own cues.
    
    Place cues on the beat grid (`beat(n)`, `bar(n)`) and on the frames things happen: a `hit` on the frame a word lands, not when it starts moving. `critique` reports the cues by kind in its `audio` row.
    
    ## A bed: music without a track
    
    `bed` turns the cue mix into a small score: a pad, a drone, a bass, air and glints in one key, changing chord on the film's sections, with the cues on top in the same key. It is music the film owns (nothing is sampled or downloaded), so it needs no licence, and it gives the loudness something to stand on: a film of sparse cues alone is hard to normalise (below).
    
    ```js
    bed: {
      key: 'D minor',             // a tonic and a mode: major, minor, dorian, lydian, mixolydian, sus
      chords: [[0, 'i add9'], [7.86, 'VI maj7'], [24.66, 'VI maj9'], [27.66, 'I']],   // optional: [time, chord]
      end: 'calm',                // without chords: the last section resolves 'lift' (to major), 'calm' (sus2) or 'dark'
      gain: 0,                    // dB, the bed against its calibrated level
      brightness: 0.5,            // 0 dark .. 1 bright: the pad's low-pass
      movement: 0.5,              // 0 still .. 1 lively: filter drift, breathing, pan drift
      layers: { pad: 1, drone: 1, bass: 1, air: 0.2, glints: 0.3 },   // 0 removes a layer, other values scale it
      pulse: false,               // or { from, to, bpm, kick: 0, hats: 0 }: a kick on the beat, hats on 16ths (dB)
      fadeIn: 2.3, fadeOut: 0.9,  // s, loop: 'none' only: a dB-linear fade in, a linear fade out ending 0.05 s before DUR
      seed: 1,
    },
    ```
    
    - **Chords** are roman numerals in the key with a quality: `''` (the numeral's case decides major or minor), `m`, `add9`, `maj7`, `7`, `maj9`, `9`, `11`, `6`, `sus2`, `sus4`, `5`, `dim`; a `b` or `#` before the numeral moves its root (`bVII`), a slash sets the bass (`IV maj7/V`). Or the notes themselves: `['D3', 'A3', 'E4', 'F4']`. The first chord starts at 0.
    - **Without `chords`**, the bed changes chord on every section the engine registers with `sectionAt(t, what)` (or on `bed.at: [times]`, or on the film's cuts): a minor key cycles i add9, VI maj7, III maj7, VII add9, iv9, VI maj9 and resolves on the last section (the lockup) as `end` says; a major key cycles I add9, vi7, IV maj7, V sus4, ii9, IV maj9 and ends on I add9.
    - **The layers.** The pad: three sawtooths a chord tone, detuned -18, 0 and +18 cents and panned wide, low-passed at `brightness`, with a glass octave of the root and fifth on top; chords crossfade over 0.8 s, or 0.25 s when a `boom` lands on the change. The drone: the chord's bass note in octave 2 with two slowly beating triangles, gliding 0.3 s to each new bass note, and a sub in octave 1 that arrives with the first boom. The bass: the bass note, articulated on each chord (and on each beat of a pulse). Air: filtered noise high up. Glints: sparse high blips of the key's pentatonic scale, 20 a second before the first boom and 6 after. Below 120 Hz everything is mono and dry.
    - **The cues duck it.** A `boom` dips the pad and the low end by 5 dB and the air and glints by 14 dB, recovering over 0.6 s; a `swell` takes the low end down 12 dB over its last 0.6 s (a gap before the hit); a pulse's kick pumps the bed by 3 dB. The ducking is arithmetic on the summed buses, so it costs nothing and stays bit-exact.
    - **Space.** Voices that send to it (the pad, glass, air, glints, `ping`, `arc`, `data`, `lock`) ring in one reverb: a feedback delay network computed in plain JS over the summed sends, deterministic like everything else. `space: { rt60: 2.6, damp: 5500, level: -6 }` sets its decay (s), its damping (Hz) and its level (dB); `space: false` keeps every sound dry. The reverb tail wraps round in a loop like any other tail.
    - **Loops.** In a `hold` or `cycle` loop the bed has no fades: its first chord crossfades in across the seam from the last, every slow modulation runs whole cycles per loop and a pulse's tempo is snapped to whole beats per loop. End the progression on the chord it starts with, or the critique warns that it wraps through a crossfade.
    - **The critique** adds an `audio bed` row: the key, the chords with their times, the layers, pulse and space; it warns when a loop's last chord is not its first and when a boom lands within 2 s of the end of a `loop: 'none'` film (the fade would cut its tail).
    
    A bed's film is mastered like music: normalise it to -14 LUFS for YouTube and social, -16 on a page next to other sound. Booms are the loudest moments: at `gain: -2` to `-4` they stay clear of the limiter after normalising. Place the structural hits where the picture changes for good (the world appearing, a region locking, the pull back, the lockup), a `swell` into each, an `arc` on each flight, a `ping` per pin, `data` under typing and counting, a `lock` on each confirmation.
    
    ## Loops: tails wrap round
    
    In a `hold` or `cycle` loop, the cue mix is rendered from before 0 to after DUR and folded: a whoosh that swells into a cut at 0.1 s starts at the end of the file, and a chime at 9.5 s in a 10 s loop rings on into the first second. Played on repeat, the audio loops with the picture and never clicks at the seam. A `loop: 'none'` film drops whatever falls outside 0 to DUR.
    
    A music track does not wrap: it is trimmed to the film (or looped when it is shorter), from `offset`. In a loop, choose a section that loops musically (whole bars at the film's BPM, cut on the downbeat) or fade it in and out briefly; a long `fadeOut` in a loop makes a dip every pass.
    
    ## Loudness
    
    `render` normalises the finished mix (cues plus track) to `loudness` in LUFS, integrated over the film (EBU R128, measured with ffmpeg's `ebur128`): one gain that brings it to the target, re-measured and corrected until it is within 0.2 LU. When that gain would push the peaks past -1.5 dBTP, a limiter at -2.5 dBFS holds them. It then encodes AAC at 48 kHz, 192 kb/s, stereo. `verify` measures the MP4 again and passes within 1.5 LU of the target.
    
    | Where it plays | Target |
    |---|---|
    | web and social video (the default) | -16 LUFS |
    | a film with a bed (web and social, YouTube) | -14 LUFS (-16 on a page next to other sound) |
    | YouTube, Spotify, most streaming (they turn louder files down) | -14 LUFS |
    | Apple podcasts and Apple Music | -16 LUFS |
    | broadcast (EBU R128; ATSC A/85 is -24) | -23 LUFS |
    
    A film of a few sparse cues and no track has little sound for the loudness to be measured over: normalising it to -16 turns every cue up by 15 dB or more and the limiter flattens their attacks (`render` prints the gain and whether it limited). Give such a film a quieter target (-20 or -23), or turn on `bed`.
    
    ## Preview
    
    Open the built file and press **M** (or click the canvas) to hear the cue mix; while it plays, the audio clock drives the picture, so they stay in sync. Space pauses both. The track is not in the page.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/brief.md5.2 KB5c8407b54c00upstream ↗
    # Brief: what the film says, and proof that it is true
    
    Steps 1 and 2 of every motion-* workflow. The output is `videos/<film>/BRIEF.md`, filled from [../templates/BRIEF.md](../templates/BRIEF.md). The style changes from skill to skill; these rules do not.
    
    ## Intake: ask little, default the rest
    
    A short film needs five things: the subject (a product, an event, a brand), the message, the palette, the format and the duration. Read before you ask; the product's live site usually answers the first three.
    
    1. **Read the product first.** Fetch the live home page and the pages it links to (about, how it works, pricing, FAQ) with `curl -sL` or WebFetch. Note the name as the site writes it, what it does, who it is for, and the call to action on its buttons.
    2. **Ask at most one round of questions**, and only what the site cannot answer. Use AskUserQuestion, and build each option from what you read rather than a stock choice:
       - the one message the film must land (2 or 3 lines taken from the site's own headlines)
       - format: 1:1 (1080 x 1080, the default), 9:16 (1080 x 1920) or 16:9 (1920 x 1080)
       - duration: 8, 10, 12 or 15 seconds (the skill's default is in its SKILL.md)
       - palette: the brand colours you found, or the template's
    3. **If the user says "go" or does not answer, use the defaults** and say which you used. When nobody can answer at all (a subagent, a scripted run), use the brief as given plus the defaults, and record every choice under "Open questions" in BRIEF.md.
    
    ## No live site: a demo, a fictional or an unreleased product
    
    - **Do not fetch a domain just because it matches the product's name.** It may belong to someone else.
    - **Log the brief itself as the source.** The Source column says `the user's brief` and the date; the wording is the brief's own.
    - **Say nothing the brief does not say**: no prices, numbers, ratings or features it does not state.
    - **Mark a fictional product on screen** (`DEMO COPY, FICTIONAL PRODUCT`, as every template's demo does) and use a reserved domain (`example.com`, `.example`, `.test`) or one the user owns.
    - **An unreleased real product** keeps its real name; anything the brief marks as not final (a price, a date) goes under "Not on screen".
    
    ## Facts: every claim has a source
    
    Write each fact into the Facts table with the exact wording, the URL where it appears, and the date you read it. Every word and number on screen, including small print, may only say what a row says.
    
    - **Only the live site (or the user's own data) counts.** Not a draft, a pitch deck, your memory of the product, or a competitor's page. If the site and the user disagree, ask.
    - **No numbers the source does not show.** No prices, trial lengths, discounts, user counts, ratings or benchmarks unless the source states them today. A pricing page that says billing is not open yet makes any price a promise the product cannot keep.
    - **Record what you left out and why** under "Not on screen". It saves the next person from adding it back.
    - **Brand colours from the source.** Read the site's CSS custom properties and `theme-color` meta tags; convert `oklch()` to sRGB hex; record the token and the file it came from.
    
    ## Nothing that is not the user's to use
    
    - **No real people's likeness, no other company's logo, mascot, character or product shot**, and no platform's trademarks (app store badges, social logos) unless the user owns them or says they have permission. A cartoon is an original character, a pixel sprite an original sprite, a UI mockup the user's own product.
    - **No imitation of a studio's house style closely enough to pass as theirs.** Borrow principles (squash and stretch, flat colour, low-poly), not a look someone owns.
    
    ## Copy: four words a beat
    
    - **At most 4 words of display type per beat**, where a beat is one idea a viewer reads in about a second. The stills critique fails a scene with more. Small print (typed crumbs, labels, sources) is not counted, but keep it under about 30 characters and sourced.
    - **The classic order:** hook (a tension the viewer feels), what it does, proof, call to action. Merge or swap beats if the product's story is different; do not add a fifth idea.
    - **One call to action, at the end.** Usually the domain, with the button's own words if there is room. Never two destinations.
    - **The product's words, not ours.** Lift phrases from the site's headlines. No hype: no "revolutionary", "AI-powered", "10x", "the best", "effortless", no claims about competitors, no implied endorsements.
    - **Check the characters.** Curly apostrophes, en dashes and the euro sign are in the Latin subset; arrows other than ↑ ↓, check marks and most non-Latin letters are not. The stills critique reads each font's cmap.
    
    ## Timing
    
    Any duration works if it is a whole number of beats (at 120 BPM, a multiple of 0.5 s); a whole number of bars (2 s) is easiest to cut on. Give each beat at least a second fully landed before it leaves, and the last scene at least 1.5 s from its first entrance to the end, so it lands, breathes and holds.
    
    ## What the user sees at this point
    
    Show the Facts table and the beats before designing: one message with the beats, the call to action, and anything you chose to leave out. Proceed unless they object. When there is no one to show them to, they are already in BRIEF.md; proceed.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/core.md15 KBfc69f8611339upstream ↗
    # Core: the runtime every engine shares
    
    Every template in this skill is one HTML file in three parts: the `FILM` block you edit, the **core** (between `CORE BEGIN` and `CORE END`, the same in every motion-* skill), and the **engine** for this vertical. You never edit the core inside a film; this file says what it guarantees and what it gives an engine or a custom drawing hook.
    
    ## The contract
    
    - **`seek(t)` is a pure function of `t mod DUR`.** Same t, same pixels, whatever was drawn before. No timers, no `Date`, no `Math.random`, no `requestAnimationFrame` inside it, no state carried between calls. The page's CSS switches transitions and animations off.
    - **Everything that measures happens once**, in the engine's `build()`, after the fonts load: text layout, geometry, spring events, decks of random numbers. Never measure inside `draw`.
    - **Continuous motion reads the exact `t`; discrete state reads the quantised `q`.** `q` is the output frame's own time (`ceil(t x FPS) / FPS`, wrapped so the last subframes of the loop belong to frame 0). Typing, drawings held on twos, sprite frames, line boil, scramble glyphs and blinking cursors read `q`, so motion blur never averages two different drawings.
    - **Randomness is seeded**: `hash(a, b, c)` (three integers to a number in [0, 1)) and `mulberry32(seed)`. Key the hash by what it decides (particle index, frame, axis), never by call order.
    - **The canvas is pinned to the CPU** (`willReadFrequently: true` from the first call). Chrome otherwise moves a canvas to the GPU and back after repeated reads, and its antialiasing changes mid-render.
    - **The canvas has an alpha channel**, though every frame is filled opaque (unless the film is transparent, below). On an opaque canvas Chromium draws text with LCD subpixel antialiasing, red and blue fringes on every glyph, whatever the command line says; with an alpha channel text is antialiased in grey, the same on every machine. An engine that draws into canvases of its own gives them an alpha channel too (the default).
    - **A cache is allowed only when it is a pure function of its key** (the blurred-glyph sprite cache is keyed by font, glyph, colour and quantised blur, so a hit and a miss give the same pixels).
    
    ## What the page exposes
    
    | Name | What it is |
    |---|---|
    | `window.ready` | a promise; resolves once fonts, layout and timeline are built |
    | `seek(t)` | draws the sharp frame at t |
    | `renderFrame(n)` | draws output frame n with motion blur; returns the number of subframes used |
    | `motionAt(n)` | `{ samples, disp }`: how far things move across frame n's shutter |
    | `critique()` | the automated pre-pass checks (see review.md) |
    | `stillsPlan()` | the frames worth looking at: each scene in and at rest, each accent |
    | `layoutTable()` | measured sizes, boxes, cuts, accents, warnings (`render.mjs layout` prints it) |
    | `accentFrames()`, `offPalette(frames, mode, strict)`, `textByFace()` | the analysis behind the gates |
    | `renderAudio()`, `audioCues()` | with `FILM.audio`: the cue mix (a promise of Float32 stereo PCM at 48 kHz, base64, or null) and the cues it sounds (audio.md) |
    | `DURATION`, `FPS`, `WIDTH`, `HEIGHT`, `FILM_META` | film facts for the scripts, including `loop`, `blur` and the engine's name |
    
    Open the built file in Chrome to preview it: it plays in real time, Space pauses, the arrow keys step one frame, `?t=3.5` opens paused at 3.5 s. With `FILM.audio`, M (or a click on the film) plays the cue mix in sync. `?capture=1` turns the preview off (the scripts use it).
    
    ## FILM fields every engine reads
    
    | Field | Meaning |
    |---|---|
    | `title`, `alt` | page title; the canvas's accessible label (write the whole script in `alt`) |
    | `W`, `H`, `FPS`, `DUR`, `BPM` | size in px, frame rate, duration in s, tempo. `beat(n)` and `bar(n)` convert to seconds |
    | `loop` | `'hold'` (default): the film ends on a still copy of frame 0. `'cycle'`: it keeps moving through the seam and must be continuous there. `'none'`: not a loop. See loops.md |
    | `blur` | `false` turns motion blur off (one sample per frame): cartoon and pixel-art looks |
    | `palette` | `{ role: '#RRGGBB' }`; every colour the film draws is a role. `bg` fills every frame (in a transparent film, the backdrop it is judged against) |
    | `transparent` | `true`: every frame starts transparent instead of filled with `bg`, for an overlay an editor lays over footage (below) |
    | `audio` | sound: a music track and sound-effect cues, mixed and normalised to a loudness (audio.md). Without it the film is silent |
    | `fonts` | `{ role: { family, weight } }`; each must match an `@font-face` rule in the page head |
    | `grid` | `{ margin, unit }`: live-area inset (104 px at 1080 by default) and baseline unit (8) |
    | `springs` | optional extra springs, `{ NAME: [zeta, omega] }` |
    | `poster` | time of the poster frame |
    
    ## Formats: one film, several aspect ratios
    
    A film is authored in its base format (`W`, `H`, usually 1080 x 1080) and renders at any other ratio with `--format`:
    
    ```bash
    node <skill>/scripts/render.mjs stills videos/<film> --format 9:16     # stills/9x16/
    node <skill>/scripts/render.mjs render videos/<film> --format 16:9     # renders/<film>-16x9.mp4, preview-16x9.gif, poster-16x9.png
    ```
    
    - The page reads `?format=9x16` before anything else and re-sizes the film, keeping the short side: 1:1, 4:5 (1080 x 1350), 9:16 (1080 x 1920), 16:9 (1920 x 1080).
    - `FILM.formats` patches any field for one format: `formats: { '9:16': { titles: [{ id: 'HOOK', y: 420 }] } }`. Objects merge; an array whose items all carry an `id` merges item by item (so a patch moves one title without repeating the others); anything else is replaced. A patch may set `W` and `H` itself.
    - Positions stay authored in the base format. The engine maps them with the helpers below and a **pin**: with no pin an element keeps its offset from the centre (content stays centred in any frame); `t` or `b` keeps its distance from the top or bottom edge, `l` or `r` from the left or right. `'tl'`, `'b'`, `'r'` combine as expected. Sizes scale with the short side (`fmtSz`), which is 1 between the standard formats of a 1080 film.
    - Backgrounds and stages fill the whole canvas (`W` x `H`), whatever the format.
    - The critique runs at the format being checked, including the composition row (below), so check every format you deliver.
    
    | Helper | Maps |
    |---|---|
    | `FMT` | `{ key, W, H, BW, BH, s, aspect }`: the format in use, the base size, the scale, and `'square'`, `'vertical'` or `'horizontal'` |
    | `fmtX(x, pin)`, `fmtY(y, pin)`, `fmtPos(x, y, pin)` | an authored position to this format's canvas |
    | `fmtSz(v)` | an authored size |
    
    **Composition** (a core check): the critique draws every review still and measures where the ink sits, against the background and the roles an engine lists as `backdrop` (a stage or a sky that fills the frame). The lean on an axis is the difference between the empty margins on its two sides, or twice the ink's centre of mass off the middle (a small footer stretches the box but barely moves the mass), whichever is larger. When the average lean over the stills passes a fifth of the canvas, it warns; past 30 %, it fails. A lean the design means (a title screen whose title rides high over its world) is declared with `FILM.composition = { lean: 'top', why: 'the title rides over the world' }`, per format through `FILM.formats` if need be: a warning in that direction then passes and prints the reason. A lean past 30 % still fails. It catches content authored for a square left in the top of a 9:16 frame or the left of a 16:9 one.
    
    ## Assets: the user's own images and audio
    
    `build.mjs` replaces every `__ASSET:<path>__` token with a data URL of `videos/<film>/<path>`: PNG, JPEG, WebP, GIF and SVG images, MP3, M4A, AAC, WAV and OGG audio, SRT, VTT, JSON and text. Keep them under `videos/<film>/assets/`. The path must stay inside the film folder. An engine loads an image in `build()` (after `await img.decode()`), never while drawing. Only embed what the user owns or may use, and say where each asset came from in BRIEF.md.
    
    ## Transparent films: overlays for editors
    
    `transparent: true` makes a film an overlay: a lower third, a caption, a corner bug, a logo sting laid over footage in an editor.
    
    - Every frame starts cleared to transparent; the engine draws only what belongs to the overlay. A scene or stage that fills the frame (a `bg` on a scene, a full-bleed shape) fills it opaque, so leave those out.
    - `bg` stays in the palette as the **assumed backdrop**: contrast rows measure text against it, the composition and palette checks read each frame composited over it, and the MP4, GIF and contact sheets show the film over it. Set it to the kind of footage the overlay will sit on (a dark or a mid grey).
    - Motion blur averages premultiplied colour: each subframe's colour weighted by its alpha, divided by the summed alpha. A streak fades out in its own colour, not towards black. An engine with its own `accumulate` must do the same.
    - `render` writes `renders/<film>.mov` (ProRes 4444 with alpha) and `renders/<film>.webm` (VP9 with alpha) next to the usual MP4 and GIF, which are composited over `bg`; `poster.png` keeps its alpha (render.md).
    - An overlay sits where the edit needs it, off centre, so the composition row warns at most.
    
    ## Sound
    
    `FILM.audio` gives a film sound (audio.md): the user's own or licensed track, plus sound effects synthesised in the page from cues, and with `bed` a score of its own (a pad, drone, bass, air and glints in a key, under a reverb). An engine places cues in `build()` with `cue(t, kind, opts)` (`pop`, `hit`, `whoosh`, `swish`, `tick`, `tap`, `click`, `riser`, `boing`, `coin`, `chime`, `thud`, `snap`, `blip`, `drop`, `sparkle`, and the tonal kinds `boom`, `swell`, `arc`, `ping`, `data`, `lock`, `pad`, `drone`) and marks the film's structural beats with `sectionAt(t, what)`, where a bed changes chord; `audio: { auto: true }` adds a pop at every accent and a whoosh at every cut, so every engine has sound without code. Synthesis runs in `renderAudio()`, never in `seek`, and is deterministic. `render` mixes, normalises to `audio.loudness` (-16 LUFS by default) and muxes AAC; a film without `FILM.audio` renders exactly as before, and a film without a bed or the tonal kinds sounds exactly as it did before they existed.
    
    ## Helpers an engine (or a custom `draw` hook) may use
    
    | Helper | What it does |
    |---|---|
    | `new Prop(v0, name)` | a value made of springs: `.to(t, v, 'LAND')` adds a spring to a new target, `.set(t, v)` jumps, `.at(t)` reads it, `.vel(t)` its speed per second |
    | `S(tau, sp)`, `dS(tau, sp)`, `settle(sp)`, `landT(sp)`, `spring(name)` | the closed-form step response, its derivative, when it snaps to 1, when it visibly lands |
    | `cyc(t, n, phase)`, `wave(t, n, phase)` | the phase and sine of n whole cycles per loop: exact at the seam |
    | `loopNoise(t, n, seed)` | smooth noise in [-1, 1] that loops exactly (three whole harmonics, seeded phases) |
    | `hash(a, b, c)`, `mulberry32(seed)`, `shuffled(arr, seed)` | seeded randomness |
    | `frameOf(t)`, `wrapT(t)`, `typed(q, ts, n)`, `drawing(q, fps)`, `noteSec(16)` | time: the frame a time belongs to, wrap into the loop, characters typed by q, the held drawing's index, a note value in seconds |
    | `layoutText(o)`, `drawText(c, line, color, fx)`, `fillGlyph(...)` | one line of type glyph by glyph (kerning recovered from pair widths, optical pairs, tracking, `fit` to a width, `cap` height), drawn with per-glyph offsets, scale, rotation, opacity and cached blur |
    | `svgPath(d)` | SVG path data to a `Path2D`, its length, its bounding box and evenly spaced points (for trims and morphs) |
    | `role(name)`, `col(name)` | resolve a palette role (register it for the palette check at build time; look it up while drawing) |
    | `rgbOf`, `hexOf`, `mix`, `contrast`, `hueChroma`, `inksClash` | colour maths |
    | `cutAt(t)`, `activeIn(a, b)`, `accentAt(t, what)`, `needContrast(id, fg, bg, min)` | tell the core about a hard cut (motion blur stops at it), a window where something moves outside the Props, an accent frame (stills and palette gate), text that must read |
    | `cue(t, kind, opts)` | a sound effect at t, in `build()`: heard only when `FILM.audio` is set. `opts`: `gain` (dB), `pitch`, `pan`, `dur`, `seed`, `vary` (audio.md) |
    | `sectionAt(t, what)` | a structural beat (a new section of the film), in `build()`: a bed changes chord there (audio.md) |
    | `checkLiveArea(add, id, box)`, `checkSpacing(add, items)` | box checks for an engine's critique |
    
    `W H FPS DUR NFR CX CY U MARGIN UNIT MEASURE LOOP BLUR TRANSPARENT TAU PAL SP` are constants (for the format being rendered). `U` is `min(W, H) / 1080`, the scale for built-in pixel constants.
    
    ## Engine hooks
    
    An engine ends with `boot({ name, springs, build, draw, disp, checks, cycles, lastChange, stills, layout, visible, always, backdrop, minSamples, seamCut, strictPalette, gif, accumulate })`:
    
    | Hook | Called | Must |
    |---|---|---|
    | `build()` | once, after the fonts load | create every Prop and event, measure everything |
    | `draw(c, t, q, nq)` | by `seek` and every subframe | draw from its arguments alone; the core has already filled `bg` |
    | `disp(ta, tb)` | by `motionAt` | return how many screen px anything moves between two times (it sets the subframe count) |
    | `checks(add)` | by `critique` | add `(name, 'PASS' / 'WARN' / 'FAIL', detail)` rows |
    | `cycles()` | in a cycle loop | list `{ what, period }` for everything periodic; each must fit a whole number of times into DUR |
    | `lastChange(see)` | in a hold loop | report discrete changes the Props do not know about (typing, blinking) |
    | `stills(push)`, `layout()`, `visible(t)` | stills plan, layout table, blank-frame check | |
    | `always` | | `true` when something moves on every frame (a cycle loop's drift); otherwise the core decides from the Props and `activeIn` windows |
    | `backdrop` | | palette roles that fill the frame behind the content (a stage, a sky): the composition check treats them as background |
    | `minSamples` | | the fewest subframes a moving frame gets (4 by default). An engine whose every subframe is costly (WebGL) may allow 2; the rule of one subframe per 5 px of movement still holds |
    | `seamCut`, `strictPalette`, `gif` | | a film that deliberately cuts at the loop point; a pixel-art gate that every pixel is exactly a palette colour; GIF settings (`fps`, `width`, `colors`, `scale: 'neighbor'`, `dither: 'none'`) |
    | `accumulate(ctx, times)` | by `renderFrame` | optional: render and average the subframes itself (for an engine that can do it faster than the core). In a transparent film, average premultiplied colour |
    
    The core draws the background (or clears to transparent), runs motion blur (`renderFrame`), and adds its own checks: contrast rows, palette roles, the loop (hold: everything settles before the last frame's shutter; cycle: every Prop ends where it starts and every period is whole), blank frames, timeline warnings, composition and, with `FILM.audio`, the cues by kind.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/engine.md8.4 KB5f93f5095ab1upstream ↗
    # Engine: the FILM config for 3D
    
    Step 4. The film is one HTML file with one canvas. [../templates/film.html](../templates/film.html) holds the whole engine, a small WebGL2 renderer with no libraries; for a new film you copy it to `videos/<film>/src/film.html` and edit only the `FILM` block at the top. The template runs as it is: a 10 s demo of a fictional wordmark. The core it sits on (springs, motion blur, the loop, the page API) is described in core.md; the fields every engine shares (`W H FPS DUR BPM loop blur palette fonts grid springs poster`) are listed there.
    
    World units are arbitrary; y is up and the floor is at y = 0. With the template's camera (30 degree field of view, 16.5 units away) the frame is about 8.8 units tall at the target.
    
    ## World
    
    | Field | Meaning |
    |---|---|
    | `world.light` | `{ dir: [x, y, z], key, ambient, soft }`: the direction the key light travels (from above, front and right: `[-0.38, -0.8, -0.9]`), its strength, the ambient level, and how soft the shadow edges are (texels) |
    | `world.floor` | `{ y, shadow }`, or `false`: a shadow catcher. It is drawn in the background colour and darkened by `shadow` (0 to 1) where shadowed, so floor and background meet with no horizon |
    | `world.rim` | a white edge light on surfaces turned away from the camera, 0 to 0.3 |
    | `world.shadowBox` | half the width of the area that casts shadows, units (default 9) |
    
    Shading keeps hue: a surface is its palette colour times a light level, plus white highlights (gloss) and rim. Nothing tints it toward another colour.
    
    ## Camera
    
    `camera: { fov, target: [x, y, z], dist, yaw, pitch, sway: [n, degrees], orbit: n, keys: [...] }`: an orbit camera looking at `target` from `dist` units, turned `yaw` degrees round the vertical and `pitch` degrees above the horizon. `sway` swings the yaw back and forth n times per loop; `orbit` turns it a whole n times per loop. `keys: [{ at, yaw, pitch, dist, fov, target, spring }]` move it on springs (DOLLY by default); the last key must return every value to where it started. `fit` and `subject` set how the camera frames other formats (below).
    
    ## Objects
    
    | Field | Meaning |
    |---|---|
    | `id`, `kind` | unique name; `text`, `path`, `box`, `sphere`, `torus`, `cylinder`, `cone`, `capsule` |
    | geometry | `text`: `text`, `font` (a role), `cap` (cap height in units), `track`, `pairs`, `depth`, `bevel`. `path`: `d` (SVG path data), `size` (units across its longer side), `depth`, `bevel`, `rule` (`nonzero` or `evenodd`). `box`: `size: [x, y, z]`, `radius` (rounded edges). `sphere`: `r`. `torus`: `r`, `tube`. `cylinder`, `cone`: `r`, `h`. `capsule`: `r`, `h` |
    | `color`, `side` | palette roles: the faces, and (for text and paths) the walls and bevels |
    | `gloss` | 0 (matte) to 1 (glossy highlight) |
    | `toon` | `true`: three flat light bands instead of smooth shading |
    | `pos`, `rot`, `scale` | rest position (units), rotation (degrees about x, y, z, applied z then y then x), scale |
    | `repeat` | copies: `{ radial: n, r, start }` round the vertical axis (each turned to face out), or `{ n, dx, dy, dz }` in a row |
    | `enter`, `keys`, `exit` | motion on springs (below) |
    | `loop` | never-ending motion: `spin: ['y', n]` (n turns per loop about a local axis), `orbit: [n, 0]` (n turns about the world's vertical axis), `bob: [n, units]`, `wobble: [n, degrees]`, `phase: 'index'` (spread copies over the cycle) |
    | `shadow` | `false`: casts no shadow |
    
    A text object is one solid per glyph, so every glyph is a copy with its own springs: a `stagger` runs across the letters, and a glyph turns about its own centre. Type is extruded from the font itself: each glyph is drawn large, traced to outlines, triangulated with its holes, and given walls and a bevel. A `path` goes through the same steps, so any SVG logo becomes a solid.
    
    ### States
    
    `from` and `to` hold `dx`, `dy`, `dz` (units from rest), `rx`, `ry`, `rz` (degrees added) and `scale` (a factor; 0 hides). `enter: { at, from, spring, stagger, order }` holds the `from` state until `at`, then springs to rest; `keys: [{ at, to, spring, stagger, order }]` are later targets in time order; `exit: { at, to, spring }` is the last. A rotation that ends a whole turn from where it started is folded back once it settles, so a flip of -360 closes the loop.
    
    ### Flat labels
    
    `labels: [{ id, text, font, size or cap, track, anchor, x, y, pin, color, on, enter: { at }, exit: { at } }]`: sharp 2D type drawn over the picture, for small print and the call to action. Canvas pixels of the base format, on the 8 px grid, faded in and out on FADE. `pin` says how a label follows another format (below).
    
    ## Formats
    
    One FILM renders at 1:1, 4:5, 9:16 and 16:9 with `--format` (core.md, Formats). The engine adapts three things by itself:
    
    - **Framing.** The field of view is vertical, so a frame narrower than the base (4:5, 9:16) would crop the sides of a scene framed for a square. The camera pulls back until the subject's bounding sphere fills the same share of the frame's narrower side as it did in the base format: the word keeps its width, and the taller frame shows more floor above and below it. The subject is every `text` and `path` object at rest (`camera.subject: ['ACME']` names others); the pull-back multiplies `dist` at every moment, keys included. A frame wider than the base keeps the height of the view and shows more of the world at the sides. `camera.contain: ['RING', 'ORB']` names objects whose whole sweep must stay in the frame (an orbit or a spin about the vertical axis sweeps a disc, a bob adds height), with half a margin to spare at the camera's closest key: the camera pulls back further when the word's fit would crop them. `camera.fit: false` turns all of this off and takes the camera as written.
    - **The floor and the background.** The shadow catcher and the far plane grow with the pull-back, so the floor still reaches past the edge of every frame, and the background fills the canvas. The floor in full shadow counts as background for the composition check (the engine declares it as a `backdrop`), so shadows do not weigh on the balance.
    - **Labels.** Each label's `x` and `y` go through `fmtX` and `fmtY` with its `pin`: none keeps its offset from the centre (it stays with the hero), `'b'` its distance from the bottom edge, `'t'`, `'l'`, `'r'` likewise, `'bl'` both. A baseline moved by the format moves by whole grid units, so it stays on the 8 px grid.
    
    Then design each format with a patch, `formats: { '9:16': {...}, '16:9': {...} }`, whose values are in the same terms as the base (world units, base-format pixels): objects and labels merge by `id`, `camera.keys` is replaced whole. The demo's patches:
    
    | | 9:16 (1080 x 1920) | 16:9 (1920 x 1080) |
    |---|---|---|
    | camera | pitch 30 (the ring opens into a tall ellipse), target y -0.3 (the scene sits a little above the middle), `contain: ['RING', 'ORB']`: pulled back until the ring and the orbs' orbit stay whole and centred | dist 14, dolly to 13: closer, the ring spans two thirds of the width; target y 0.15 |
    | ORB | rest y 1.2, bob 0.8: the orbs rise through the extra height | as at 1:1 |
    | labels | URL y 848, DEMO y 912 (1272 and 1336 in the tall frame), under the ring | as at 1:1 |
    
    Run `stills` and `loopcheck` with `--format` for every format you deliver: the live-area row catches type the framing lost, the composition row a scene that sits to one side.
    
    ## Springs
    
    The core's springs (springs.md) plus these:
    
    | Name | ζ | ω | Settles (s) | Lands (s) | Overshoot | Use |
    |---|---|---|---|---|---|---|
    | FLIP | 0.55 | 12 | 2.424 | 0.215 | 12.6 % | a letter turning over, with a little swing past |
    | HOP | 0.80 | 22 | 0.909 | 0.189 | 1.5 % | a quick lift |
    | SETTLE | 0.62 | 9 | 2.867 | 0.317 | 8.4 % | a heavy object coming to rest |
    | DOLLY | 1 | 3.2 | 5.000 | 1.482 | none | slow camera moves (they carry over the seam in a cycle loop) |
    
    ## The renderer
    
    - A shadow pass renders depth from the light (1024 px, orthographic over `shadowBox`), sampled with 4 filtered taps (16 depth tests) spread by `soft` for soft edges.
    - The main pass draws into a 4x multisampled buffer, resolved and drawn onto the film's canvas, then the flat labels on top.
    - Colours are converted from sRGB to linear for lighting and back to sRGB exactly.
    - Motion blur is the core's: each subframe is a full render, averaged.
    
    ## Adding something the vocabulary lacks
    
    A new primitive is a function returning a mesh (`grid(nu, nv, f)` builds any parametric surface with its normals); add it to `geometryOf`. A new loop behaviour goes in `modelOf`, as a function of `t` with whole cycles per loop, listed in `cycles()`.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/fonts.md3.1 KB4b378cf2c57cupstream ↗
    # Fonts: fetched, embedded, checked
    
    The film embeds its fonts as base64 WOFF2 so the HTML file is complete on its own. Nothing loads at runtime, from Google Fonts or anywhere else; the build refuses a page that would fetch anything over the network.
    
    ## Which faces
    
    Each skill's template names its default faces in `@font-face` rules and in `FILM.fonts` (the skill's engine.md says why each was chosen). Any face from [Fontsource](https://fontsource.org) under the SIL Open Font License works. To change one:
    
    1. Edit the `@font-face` rule in the page head: family, weight, and the token `__FONT:<package>-latin-<weight>-normal.woff2__` (for example `__FONT:space-grotesk-latin-700-normal.woff2__`).
    2. Point the role in `FILM.fonts` at the same family and weight.
    3. Fetch again (below), rebuild, and look: sizes, cap heights and spacing all come from the face.
    
    Check the licence: `fonts.mjs` warns when a package is not under the OFL. A brand's own proprietary face cannot be embedded unless the user holds a licence that allows it; use the closest open face and say so in the brief.
    
    ## Fetch
    
    ```bash
    node <skill>/scripts/fonts.mjs videos/<film>
    ```
    
    With no arguments beyond the film, it reads the `__FONT:...__` tokens in `videos/<film>/src/film.html` (a film with none, such as pixel art in its own bitmap font, needs nothing) and fetches each face with `npm pack @fontsource/<package>@5` (a registry download; nothing is installed). It extracts the WOFF2 subset and the licence text into `videos/<film>/fonts/`, and prints each file's size and md5 and any of € É × ’ – — · the file lacks. `--face <package>:<weight>` fetches a face by hand; `--subset latin-ext` fetches another subset.
    
    Do not commit WOFF2 files to the skill or to an example's source; commit the licence texts next to any built HTML that embeds them.
    
    ## Embed
    
    `node <skill>/scripts/build.mjs videos/<film>` replaces every `__FONT:<file>__` with the file's base64 and writes `videos/<film>/<film>.html`, with an HTML comment at the top naming each embedded font and its copyright line. It fails if a font file is missing, a token is left over, or the page references anything over the network.
    
    Every `@font-face` uses `font-display: block`, and `window.ready` loads each role before anything is measured, then throws if a face did not load. Text is never measured in a fallback font.
    
    ## Coverage: read the font, not the browser
    
    The Latin subset covers U+0000 to U+00FF, Œ œ, curly quotes, dashes, the ellipsis, € and ™, and little else. A character outside it silently falls back to a system font in the browser, and the browser cannot tell you. So `render.mjs stills` reads each embedded face's own cmap table (`scripts/cmap.mjs`, a WOFF2 reader with no dependencies) and checks every character each face must draw. A missing character fails the critique.
    
    ```bash
    node <skill>/scripts/cmap.mjs videos/<film>/fonts/unbounded-latin-700-normal.woff2 "ÉTÉ → 2026"
    ```
    
    For a language outside Latin-1, change the face's token to the subset that covers it (`__FONT:<package>-latin-ext-<weight>-normal.woff2__`), fetch again and check again.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/loops.md5.8 KBc8f5198a6961upstream ↗
    # Motion blur and the seamless loop
    
    Real motion blur comes from rendering several subframes per output frame and averaging them. A seamless loop means the last frame flows into frame 0 with nothing to see at the seam. Both are exact in the core; this file says how, and what breaks them.
    
    ## Subframes are sampled behind the frame
    
    Output frame n shows time `tn = n / FPS`. Its subframes sit on a trailing 270-degree shutter: `k` samples evenly spaced from `tn - 0.75 / FPS` to `tn`, averaged with equal weight and rounded. The frame shows where things are at tn, with a streak behind them, the way a film camera does.
    
    | Motion across the shutter (the engine's `disp`) | Subframes |
    |---|---|
    | nothing changes at all | 1 (exact: the mean of identical samples is the sample) |
    | up to 20 px | 4 |
    | more | `ceil(px / 5)`, up to 64 |
    
    At 10 px apart, copies still show as faint steps on hard edges; at 5 px they read as one streak. "Nothing changes" is decided from the Props' spring events and the declared `activeIn` windows, not from pixels: a custom drawing that moves outside its declared windows is rendered with one sample there and loses its blur.
    
    `FILM.blur: false` renders one sample per frame everywhere. That is right for cartoons (smears and speed lines instead of blur) and pixel art (every pixel exact).
    
    ## Never blur across a hard cut
    
    A subframe that falls before a cut while its frame is after it is clamped to the cut time; otherwise the first frame after a cut is a double exposure of both scenes. Engines register their cuts with `cutAt(t)`; a custom hard change must be registered too.
    
    ## Three kinds of loop
    
    ### `loop: 'hold'` (the default): the film ends on a still copy of frame 0
    
    1. **Frame 0 is the end state at rest**, usually the lockup. It is on screen at t = 0, leaves at once, and is rebuilt at the end.
    2. **Everything settles before the end.** Springs snap to exactly 1 at `16 / (zeta x omega)`; the last settle must come at least `(1 + 0.75) / FPS` before DUR. So must the discrete state: typing and its cursor, blinks, snaps, the frames of an accent. The critique's "loop tail" row reports the last change, what it is, and how many still frames that leaves.
    3. **The camera returns** to the world and zoom it started in.
    
    `loopcheck` then requires every pixel of the seam to match exactly: `seek(0)` against `seek(DUR)`, `seek(DUR - 1 frame)` and `seek(DUR - 1.75 frames)`; `renderFrame(0)` against `seek(0)` and `renderFrame(N - 1)`. Every maximum difference must be 0. It prints how many tail frames equal frame 0.
    
    ### `loop: 'cycle'`: the film keeps moving through the seam
    
    A spinning object, an idle bob, a walk cycle, a drifting swarm: nothing stops, and the seam is continuous instead of still.
    
    1. **Periodic motion runs whole cycles per loop.** Write it with `cyc(t, n)`, `wave(t, n)` or `loopNoise(t, n, seed)`, where `n` is an integer number of cycles in DUR. The engine lists its periods in `cycles()`; the critique fails any that do not fit a whole number of times.
    2. **Every Prop ends where it starts.** A spring still settling when the loop ends carries over the seam into the start of the next pass (only until the Prop's first `set`), so a landing may straddle the loop point. The critique's "loop closes" row fails a Prop whose last target differs from its starting value.
    3. **Discrete state repeats too.** Drawings held on twos, sprite frames and line boil must cycle a whole number of times per loop, or the seam shows a skipped drawing.
    4. **Frame 0's subframes come from the end of the loop**, which is the right motion blur for a periodic film.
    
    `loopcheck` checks purity as for a hold loop, then continuity, twice:
    
    - **Across 0.1 ms**: the film 0.1 ms before the loop point against frame 0 (both read frame 0's discrete state), next to the same 0.1 ms step at the frames either side of the seam and at seven points through the film. The change is the summed change of 32 px block averages, as below, so an image redrawn at a new sub-pixel phase does not read as a jump. A continuous film changes about as much across the seam as elsewhere; a jump changes far more and fails (the limit is 1.5 times the largest reference step). It sees everything that reads the exact t.
    - **Frame by frame**: the output step from frame N-1 to frame 0 (`renderFrame`), against the steps between other consecutive frames. Held drawings, sprites and the boil read the quantised frame, so both sides of the 0.1 ms step fall on the same frame and only a whole-frame step sees them. A step is the summed change of 32 px block averages, so it measures how far things move rather than their texture. The seam passes when it is at most 1.5 times the largest reference step (the steps next to the seam, and a run through each of 8 windows in the film, long enough to catch a drawing change on twos), both over the whole frame and in each of 8 x 8 tiles against the steps next to it. A breath or a sway that does not run whole cycles on the drawings fails it on the character's tile while the rest of the frame scrolls on.
    
    The frame step catches a jump. It cannot see a sprite or drawing cycle that skips to a pose which differs from the last as much as neighbouring poses differ (a run cycle that restarts two drawings early): that is the critique's job, from the periods the engine lists in `cycles()`. A film that deliberately cuts at the loop point declares `seamCut` in its engine, and both checks become information.
    
    ### `loop: 'none'`: not a loop
    
    An in-and-out piece (a title that animates on and off). Only purity is checked.
    
    ## The encode is not bit-exact, and that is fine
    
    H.264 stores frame 0 as a keyframe and the last frame as a predicted one, so decoded, they differ by encoder noise even when the canvas pixels are identical. `verify` reports it for a hold loop as information. The canvas-level check is the one that proves the film.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/render.md11 KBebfc24b65223upstream ↗
    # Render: headless Chromium to MP4, GIF and poster, then verify
    
    `scripts/render.mjs` opens the built film in headless Chromium, pulls exact canvas pixels, and streams them into one ffmpeg process. The same scripts serve every motion-* skill: they read what the film declares (`FILM_META`: its loop kind, whether it blurs, its palette gate) and check accordingly.
    
    ## Requirements
    
    `node <skill>/scripts/render.mjs doctor` checks all of these on the current machine and prints the command that fixes each missing one. Run it once per machine, before the first film.
    
    - **Node 20 or newer.**
    - **playwright-core**, resolved from the film folder (and the folders above it), then the working directory, then the skill folder. Install it once next to the scripts, `npm install --prefix <skill> --no-package-lock`, or add it to the user's project, `npm i -D playwright-core`, which survives a plugin update and serves every motion-* skill at once.
    - **A Chromium.** The script looks, in order, at `$CHROME_PATH`, playwright-core's own browser (after `node <playwright-core folder>/cli.js install chromium`; doctor prints the exact line), the newest `chromium-*` in the Playwright cache (`$PLAYWRIGHT_BROWSERS_PATH`, or the default cache folder), then a system Google Chrome or Chromium. Canvas `letterSpacing` and `ctx.filter` are Chromium features; Firefox and WebKit are not supported. A WebGL film (motion-3d) runs on the GPU when there is one and on SwiftShader, Chromium's software renderer, when there is not; `doctor` prints which (an INFO line, never a failure).
    - **ffmpeg and ffprobe** with libx264, from `$FFMPEG_PATH` / `$FFPROBE_PATH` or PATH (`brew install ffmpeg`, `apt install ffmpeg`). A film with sound needs the AAC encoder (every build has it); a transparent film needs `prores_ks` and `libvpx-vp9` (the Homebrew and apt builds have both). `doctor` reports all three as INFO lines.
    
    ## Modes
    
    ```bash
    node <skill>/scripts/render.mjs doctor                       # once per machine: what is missing, and the fix
    node <skill>/scripts/render.mjs stills    videos/<film>      # critique + review stills + contact sheet
    node <skill>/scripts/render.mjs loopcheck videos/<film>      # seam and purity (see loops.md)
    node <skill>/scripts/render.mjs render    videos/<film>      # renders/<film>.mp4, preview.gif, poster.png
    node <skill>/scripts/render.mjs render    videos/<film> --range 240:420 # a quick partial render: renders/<film>-f240-420.mp4
    node <skill>/scripts/render.mjs verify    videos/<film>      # facts about the files, decoded pixels
    node <skill>/scripts/render.mjs verify    videos/<film> --mp4 videos/<film>/renders/<film>-f240-420.mp4
    node <skill>/scripts/render.mjs mp4frames videos/<film>      # decoded review frames + PSNR vs the canvas
    node <skill>/scripts/render.mjs mp4frames videos/<film> 96 276 363      # chosen frames
    node <skill>/scripts/render.mjs at        videos/<film> 2.5 7.25        # sharp seek() stills
    node <skill>/scripts/render.mjs frame     videos/<film> 150 390         # motion-blurred frames
    node <skill>/scripts/render.mjs layout    videos/<film>      # measured layout as JSON
    ```
    
    Every film mode takes `--format 9:16` (or `16:9`, `4:5`, `1:1`): the film at that aspect ratio (core.md, Formats), its outputs suffixed: `stills/9x16/`, `renders/<film>-9x16.mp4`, `preview-9x16.gif`, `poster-9x16.png`. Run `stills`, `loopcheck`, `render` and `verify` once per format you deliver.
    
    Every film mode rebuilds `<film>.html` first, so what you check is what you ship. `fonts.mjs` fetches the faces the film's `@font-face` tokens name; `build.mjs` embeds them and refuses a page that would load anything over the network.
    
    ## How pixels leave the browser
    
    - Chromium runs with `--force-color-profile=srgb --disable-lcd-text --font-render-hinting=none`, a viewport of exactly W x H at device scale 1, and the page at `?capture=1` (no preview loop). The flag alone does not stop LCD text on an opaque canvas, so the film's canvas has an alpha channel (core.md).
    - Pixels come from `getImageData` on the film's own canvas, never from a screenshot: a screenshot goes through the compositor and colour management.
    - Stills are PNGs of the canvas. The render sends raw RGB to ffmpeg's stdin; no PNG encode per frame.
    - A transparent film (`FILM.transparent`) is read as RGBA. The script composites it over `bg` for the MP4 and GIF (`c x a + bg x (255 - a)`, rounded, the same sum the page's checks use) and sends the RGBA itself to a second ffmpeg for the alpha outputs.
    
    ## Encode
    
    One ffmpeg process makes both deliverables from the same RGB stream:
    
    - **MP4**: `scale=out_color_matrix=bt709:out_range=tv,format=yuv420p`, libx264 `-preset slow -crf 16`, tagged BT.709 in the container and, through `h264_metadata`, in the H.264 stream itself, with `-movflags +faststart`. No audio track, unless the film sets `FILM.audio` (below).
    - **GIF**: every third frame (20 fps), the pixel count of a 480 x 480 GIF at the film's aspect ratio (360 x 640 at 9:16, 640 x 360 at 16:9, 430 x 538 at 4:5; an engine may set its own, and `--gif-width` sets the width), a 64-colour palette built from the whole film, a light Bayer dither. An engine may ask for other settings (pixel art: nearest-neighbour scaling, no dither). Aim for under 4 MB; `--gif-fps 15` or `--gif-colors 32` if it is over.
    - **Poster**: the exact canvas PNG of `FILM.poster` (with its alpha, in a transparent film).
    
    ### Sound (`FILM.audio`)
    
    After the video, the page synthesises the cue mix (`renderAudio()`: Float32 stereo at 48 kHz, exactly DUR long, loop tails already wrapped) and the script writes it to a WAV. ffmpeg mixes it with the track (`track`, trimmed from `offset` to DUR, or looped when shorter, then `gain` in dB and the fades), measures the mix's integrated loudness (EBU R128, `ebur128`) and applies the gain that reaches `loudness` (default -16 LUFS), re-measuring until it is within 0.2 LU; a limiter at -2.5 dBFS comes in only when that gain would push the peaks past -1.5 dBTP. The last pass encodes AAC at 48 kHz, 192 kb/s, stereo, and muxes it next to the video stream, copied untouched, with faststart. A `--range` render gets the matching slice of the audio. See audio.md for cues, music you may use and loudness targets.
    
    ### Alpha (`FILM.transparent`)
    
    A full render of a transparent film also writes, from the same frames:
    
    - `renders/<film>.mov`: ProRes 4444 with alpha, `prores_ks -profile:v 4 -pix_fmt yuva444p10le` (16-bit alpha), BT.709. For Premiere, Resolve, Final Cut and After Effects.
    - `renders/<film>.webm`: VP9 with alpha, `libvpx-vp9 -pix_fmt yuva420p -auto-alt-ref 0 -crf 20`. For the web and for editors that take WebM. ffmpeg's built-in VP9 decoder drops the alpha: decode with `-c:v libvpx-vp9`.
    
    The MP4 and GIF are the film over `bg`, for review. The .mov and .webm are silent; a transparent film with `FILM.audio` also gets `renders/<film>.wav`, the normalised mix (24-bit, 48 kHz), for the editor's timeline.
    
    The explicit BT.709 matrix matters: converting RGB to YUV with the default BT.601 matrix and tagging it BT.709 shifts every colour slightly, and brand colours are exactly what people notice.
    
    ## Time
    
    On an Apple-silicon Mac or a 4-core cloud machine, a 10 s 1080 x 1080 film renders in one to three minutes: a frame where nothing moves costs one draw, the fastest moves up to 64. A 1920 x 1080 film takes about 1.8 times as long per frame. WebGL on SwiftShader, and particle swarms, cost more per draw. Start the full render as a background job and read the stills while it runs.
    
    ## Verify
    
    `verify` checks the delivered files, not the page:
    
    | Check | Pass |
    |---|---|
    | codec, pixel format, size, frame rate | h264, yuv420p, W x H, FPS/1 (real and average) |
    | frame count and duration | exactly DUR x FPS frames, DUR within one frame |
    | colour tags | bt709 matrix, transfer and primaries, tv range |
    | faststart | `moov` before `mdat` |
    | first and last frame vs the canvas | decoded with the BT.709 matrix, PSNR at least 35 dB; a render made smaller with `--crf` above 20 warns instead of failing down to 30 dB (look at the frame full size) |
    | background | every pixel that is the background in the canvas decodes within 2 levels of it (a range mistake lifts #0A0A0A to about #171717). A first frame without a plain background is checked on its most common colour |
    | encoded seam | frame 0 vs the last frame, decoded (information only, hold loops) |
    | GIF and poster | present; GIF under 4 MB |
    | audio (no `FILM.audio`) | no audio stream (a warning) |
    | audio stream (`FILM.audio`) | AAC, 48 kHz, stereo; its duration within one frame of the video's |
    | loudness (`FILM.audio`) | integrated loudness (ffmpeg `ebur128`) within 1.5 LU of `audio.loudness`; loudness range and true peak reported. A warning only, on a partial render |
    | .mov and .webm (`FILM.transparent`) | ProRes 4444 with a `yuva` pixel format; VP9 with `alpha_mode` 1; size and frame count |
    | alpha vs canvas (`FILM.transparent`) | the poster, the review stills and the most motion-blurred frame, decoded: the alpha plane's PSNR against the canvas alpha (at least 45 dB for ProRes, 35 dB for VP9), and the colour over `bg` |
    | poster alpha (`FILM.transparent`) | the PNG has an alpha channel |
    
    Frames are decoded with `scale=in_color_matrix=bt709:in_range=tv:out_range=pc:flags=accurate_rnd+full_chroma_int`. The two flags matter: swscale's default path reads every colour 1 to 3 levels low (white as 253) although the stream holds the exact values.
    
    Then **look at the files yourself**: `mp4frames` decodes the review-stills frames from the MP4 into `stills/mp4/` with a contact sheet and each frame's PSNR against the exact canvas. A number that passes can still hide a frame that looks wrong.
    
    ## Troubleshooting
    
    | Symptom | Cause |
    |---|---|
    | `the film failed to start` | a JavaScript error in FILM (the page error is printed), or a font file missing |
    | `playwright-core not found` | `npm install --prefix <skill> --no-package-lock`, or `npm i -D playwright-core` in the project |
    | `no Chromium found` | set `CHROME_PATH`, or run the install line `doctor` prints |
    | text in the wrong face in a still | the font did not load: the `@font-face` family and weight must match `FILM.fonts` |
    | stepped copies on a fast move | the move is outside anything the engine's `disp` measures, or so fast that 64 subframes still sit more than 5 px apart (`render.mjs frame` prints the count; slow the spring or shorten the move) |
    | a double exposure right after a cut | the cut is not registered (`cutAt`) |
    | `LOOPCHECK FAIL` in a cycle loop | something jumps at the loop point: a Prop that does not return to its start, a period that is not whole (the critique names both). When the frame step fails on one tile, a drawing, sprite or idle cycle there does not fit the loop (loops.md) |
    | `loudness` far from the target | a film of a few short cues and no track: give it a lower `loudness` or a bed under the cues (audio.md) |
    | an overlay with a dark fringe in the editor | the editor reads the .mov as premultiplied: set its alpha to straight (unpremultiplied) |
    | grey background in the MP4 | the RGB-to-YUV range or matrix was changed; keep the `scale` filter above |
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/review.md4.7 KBd7bdf8bfa658upstream ↗
    # Review: the pre-pass critique and the final checklist
    
    Step 5 and the end of step 6. Nothing is rendered in full until the stills pass, and nothing is delivered until the files verify and you have looked at them.
    
    ## Pre-pass: `render.mjs stills`
    
    It prints only the checks that did not pass (set `VERBOSE=1` to see all), writes one PNG per planned frame to `videos/<film>/stills/`, and a labelled `contact.png`. It exits non-zero when anything fails. With `--format 9:16` (or `16:9`, `4:5`) it checks the film in that frame and writes to `stills/9x16/`: run it once per format you deliver.
    
    The planned frames: frame 0, each key move shortly after it starts, each camera move after it lands, the midpoint, and the last frame.
    
    ### Automated checks
    
    | Check | Fails when | Fix |
    |---|---|---|
    | glyphs | a character of the 3D type or a label is not in the face's cmap | change the copy or the face (fonts.md) |
    | words | the 3D type holds more than 4 words | shorter |
    | live area | the 3D type's box on screen leaves the margins at 0, 25, 50 or 75 % of the loop; a label leaves them | move the camera back or up, smaller `cap`; in another format, check `camera.fit` is not `false` and the patch did not bring the camera too close |
    | type size (warn) | the 3D type's cap height is under 60 px on screen | larger `cap` or a closer camera |
    | mesh | a text or path object built no triangles (a glyph the face lacks, an empty path) | the face, the path data |
    | grid (warn), collision, cramped | labels off the 8 px grid, or overlapping or crowding each other | move them |
    | contrast | a label, or the 3D type's face colour, is under its minimum against the background | another role |
    | palette roles | a colour is not a palette role | add the role |
    | loop closes | a keyed value or the camera ends somewhere other than where it started (a whole turn counts as where it started) | add the move back |
    | cycle | a spin, orbit, bob, wobble, sway or camera orbit is not a whole number of cycles per loop | whole numbers |
    | blank frames (warn) | frames show nothing | |
    | composition | averaged over the stills, the picture leans to one side by more than a fifth of the frame (WARN) or 30 % (FAIL); the floor's shadows count as background | a format patch: move the camera `target`, the labels' `y` or `pin`, or give the empty side something to hold (engine.md, Formats) |
    | renderer | information: WebGL2, the multisampling and the shadow map in use | |
    
    The palette gate is not run for 3D: shading and antialiasing make in-between colours at every silhouette by design.
    
    ### By eye, on the contact sheet and the full-size stills
    
    - **Intersections**: a ring through a letter, an orb through the floor, a letter through its neighbour mid-flip.
    - **Grounding**: every object has a shadow under or behind it; nothing floats unless it is meant to.
    - **Faces**: the type's front faces are light and even; the walls show; the bevel catches the light as a thin bright edge.
    - **Shadow acne or detachment**: speckled stripes on surfaces (acne), or a gap between an object and its shadow at the contact point (too much bias).
    - **Tessellation**: faceted curves on big spheres or tori in close-ups (raise the segment counts in the engine).
    - **The horizon**: none. If the floor's edge shows, the camera sees past it; lower the pitch or enlarge the floor.
    - **Motion blur**: fast flips and orbits streak; nothing shows stepped copies (`render.mjs frame` prints subframe counts).
    - **Each format**: at 9:16 the hero fills the width with the labels under it, not a square picture floating in the middle; at 16:9 the scene uses the width. Orbiting objects may leave at the sides; the hero never does.
    
    Fix, rebuild, and run stills again. Show the user the contact sheet and anything you changed on their brief.
    
    ## Before delivering
    
    1. `loopcheck` (with `--format` for each format delivered): every purity difference is 0, and the seam continuity line passes.
    2. `render`: the full film, in the background (a 10 s 1080 x 1080 film takes a few minutes on the software renderer).
    3. `verify`: every check passes; for a film without a plain background at frame 0, the background check uses its most common colour.
    4. **Extract and look**: `mp4frames`, then a strip of the whole film (`ffmpeg -i renders/<film>.mp4 -vf "select=not(mod(n\,10)),scale=180:-1,tile=10x6" -frames:v 1 strip.png`).
    5. Report: the files with sizes, what verify said, the loopcheck line, the lowest mp4frames PSNR, and anything you could not check.
    
    ## What never ships
    
    - A logo or product that is not the user's.
    - A claim that is not in the brief's Facts table.
    - A frame with a glyph from a fallback font, or a glyph that failed to extrude.
    - A loop that jumps at the seam.
    - An MP4 without BT.709 tags, or whose background decodes lighter than the canvas.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/springs.md3.8 KBfb1884d48b1eupstream ↗
    # Springs: closed-form, one per target change
    
    Every moving value is a sum of damped springs evaluated in closed form. No integration, no state: the value at t depends only on t and the event list, which is what makes `seek(t)` pure and the loop exact.
    
    ## The step response
    
    A spring with damping ratio ζ and natural frequency ω, started at time t0 and moving a value by d, contributes `d x S(t - t0)`:
    
    - underdamped (ζ < 1): `S(τ) = 1 - e^(-ζωτ) (cos(ω_d τ) + (ζω / ω_d) sin(ω_d τ))`, with `ω_d = ω √(1 - ζ²)`
    - critically damped (ζ = 1): `S(τ) = 1 - (1 + ωτ) e^(-ωτ)`
    - `S(τ) = 0` for τ ≤ 0.
    
    **Snap.** At `τ ≥ 16 / (ζω)` the residual is under 2e-6 of the move, and `S` returns exactly 1. Without the snap a spring never lands, and the last frame of a hold loop would differ from the first by a fraction of a pixel.
    
    The speed is closed-form too: `dS/dτ = (ω² / ω_d) e^(-ζωτ) sin(ω_d τ)` underdamped, `ω² τ e^(-ωτ)` critically damped. `Prop.vel(t)` sums it; engines use it for squash and stretch, smears and speed lines.
    
    ## A property is a base value plus springs
    
    `new Prop(v0).to(t, v, 'LAND')` adds one spring from the previous target to `v`. Rules:
    
    - **One spring per target change.** A retarget is a new spring whose delta is `v - previous target`, superposed on the ones still settling. Never restart a spring from the current value: that needs state.
    - **Add events in time order.** The delta is computed from the last target added. The core throws if an event is added before an earlier one.
    - **`set(t, v)` is an instant jump** and cancels every earlier spring on the property. Use it only while the element is invisible, at a hard cut, or hidden inside fast motion blur.
    - **In a loop, springs carry over the seam.** A spring still settling at DUR keeps settling into the start of the next pass (until the Prop's first `set`), so the value is continuous at the loop point. The value a Prop ends on must equal the value it starts from.
    
    ## The core's springs
    
    `settle` is when `S` snaps to 1. `lands` is the visible landing: the first crossing of the target when underdamped, 95 % when critically damped.
    
    | Name | ζ | ω | Settles (s) | Lands (s) | Overshoot | Use |
    |---|---|---|---|---|---|---|
    | SLAM | 0.60 | 30.0 | 0.889 | 0.092 | 9.5 % | big elements slamming in from far |
    | LAND | 0.72 | 28.0 | 0.794 | 0.122 | 3.8 % | the default entrance |
    | PUNCH | 0.65 | 31.0 | 0.794 | 0.097 | 6.8 % | camera punch-in on a downbeat |
    | LINE | 0.80 | 15.6 | 1.282 | 0.267 | 1.5 % | slow, heavy moves |
    | FADE | 1 | 32.4 | 0.494 | 0.146 | none | opacity |
    | EXIT | 1 | 32.4 | 0.494 | 0.146 | none | leaving: no bounce on the way out |
    | PAN | 1 | 32.4 | 0.494 | 0.146 | none | camera moves between worlds |
    | DRAW | 1 | 32.4 | 0.494 | 0.146 | none | a rule drawing on |
    | TICK | 1 | 32.4 | 0.494 | 0.146 | none | small marks |
    | FOCUS | 1 | 19.5 | 0.821 | 0.243 | none | blur to sharp |
    | MASK | 1 | 19.5 | 0.821 | 0.243 | none | wipes |
    
    Each engine adds its own (its engine.md lists them), and a film may add more in `FILM.springs` as `NAME: [ζ, ω]`. ζ must be in (0, 1]. Compute the settle time of anything you add: in a hold loop, the film's static tail starts after the last settle.
    
    ## Choosing
    
    - **Entrances overshoot, exits do not.** An underdamped spring coming in reads as weight; one going out reads as a stumble.
    - **Opacity and blur are critically damped**, or an element would flash past full opacity and "un-focus".
    - **Distance sets the spring.** A 640 px slam needs a stiff spring; a 96 px landing on a stiff spring looks jittery.
    - **A value that means something is critically damped.** A bar that overshoots 100 on its way to 100 shows 108 for a moment: a false number.
    - **Never ease with CSS curves or cubic-béziers.** They are not superposable and do not retarget.
    
  • plugins/motion-launch-videos/skills/motion-3d/reference/video-types.md7.2 KB17421265e7a3upstream ↗
    # Video types: what the film is for
    
    Step 1 and 2. A style (kinetic type, shapes, cartoon, 3D, charts, pixel art, particles, app UI, photo, captions, overlays, globe) says how a film looks. A **video type** says what it is for, and that decides its length, its format, its beats and what the brief must hold. Pick the type first, then the style that serves it. Any type below can be made in more than one style; the table suggests the ones that fit best.
    
    ## Choosing
    
    | Type | For | Length | Formats | Styles that fit | Loop |
    |---|---|---|---|---|---|
    | Launch bumper | announcing a product or a release | 8 to 15 s | 1:1, 16:9 | kinetic type, 3D, particles, shapes | hold |
    | Feature highlight | one feature, shown working | 8 to 15 s | 1:1, 9:16 | app UI, shapes, photo | hold |
    | What's new | a release's three changes | 12 to 20 s | 1:1, 16:9 | app UI, shapes, kinetic type | hold |
    | App store preview | the app in use, screen by screen | 15 to 30 s | 9:16 (the store's exact size) | app UI | none |
    | Product reel | a physical or digital product, shot by shot | 10 to 20 s | 9:16, 1:1 | photo, 3D | hold |
    | Milestone | one number that matters, and what it means | 6 to 12 s | 1:1, 9:16 | charts, kinetic type | hold |
    | Data story | a trend, a ranking, a year in review | 12 to 20 s | 16:9, 1:1 | charts | hold |
    | Network or coverage | where a product works, ships or connects, worldwide | 20 to 40 s | 16:9, 9:16, 1:1 | globe | none |
    | Testimonial | a customer's words, attributed | 8 to 15 s | 1:1, 9:16 | kinetic type, photo, shapes | hold |
    | Event promo | what, when, where, who | 10 to 15 s | 9:16, 1:1 | kinetic type, shapes, photo | hold |
    | Countdown | days or hours to a date | 6 to 10 s | 9:16, 1:1 | kinetic type, particles, pixel art | cycle |
    | Explainer loop | how it works, in three steps | 12 to 20 s | 1:1, 16:9 | shapes, cartoon | hold |
    | Mascot or sticker loop | a character saying hi, reacting | 4 to 10 s | 1:1 | cartoon, pixel art | cycle |
    | Logo sting | the identity, alone | 3 to 6 s | 16:9, 1:1 | 3D, particles, shapes, kinetic type | hold |
    | Intro and outro | the open and close of a video series | 3 to 8 s | 16:9 | overlays, 3D, kinetic type | none |
    | Lower thirds and titles | names, chapters and callouts over footage | 3 to 6 s each | 16:9, 9:16, transparent | overlays | none |
    | Captioned clip | a voice-over or podcast cut with captions | 15 to 60 s | 9:16, 1:1 | captions | none |
    | Game teaser | a game's world and title | 8 to 15 s | 16:9, 1:1 | pixel art, 3D, cartoon | cycle |
    | Ad | hook, problem, answer, proof, offer | 6 to 15 s | 9:16, 1:1 | any | hold |
    
    ## Beats by type
    
    Beats are at most four words each; the call to action is one of them. Every word comes from the brief's Facts.
    
    - **Launch bumper:** hook, what it is, proof, call to action (the name and URL).
    - **Feature highlight:** the problem in the user's words, the feature doing it (on screen, not described), the result, call to action.
    - **What's new:** "New in <version>", then change 1, 2 and 3 (each shown, not listed), then call to action. Take the changes from the product's own changelog or release notes, dated.
    - **App store preview:** the core task from start to finish in the app's real UI, one screen per beat, then the app's name. Follow the store's current specification for size, length and content: check it before you start, as it changes.
    - **Product reel:** the hero shot, then three details (material, feature, use), the price or offer only if the product's page states it today, then call to action.
    - **Milestone:** the number (counting up to its exact figure), what it counts, the date or period, thanks or call to action. Source on screen.
    - **Network or coverage:** the world forms (one line of subtitle), two to four regions with a few places each and what is counted there, the pull back to the whole network and its total, the lockup. Places and numbers from the user's own data.
    - **Testimonial:** the quote (their words, never edited for meaning), the name and role, the product, call to action. Only with the person's written permission, recorded in the brief; no photo of them without it.
    - **Event promo:** the event's name, the date and place (or "online"), the headliners or the one reason to come, then how to register. Dates and times with the time zone, as the event page states them.
    - **Countdown:** the date, the number counting, the name. A cycle loop can count seconds forever; a dated count is rendered once per day, or it lies.
    - **Explainer loop:** step 1, step 2, step 3, the outcome. One verb per step.
    - **Logo sting:** the mark arrives, the name locks up, a hold. No copy beyond the name and, if any, the tagline.
    - **Intro and outro:** intro, the series name and episode title; outro, the call to action (subscribe, the next video, the URL) with space left for the platform's end-screen elements.
    - **Lower thirds:** name and role, or a chapter title, in, hold, out. Deliver transparent (overlays).
    - **Captioned clip:** the words of the voice-over, a line or a word at a time, timed to it. The transcript is the brief's Facts; never paraphrase a speaker.
    - **Ad:** a hook (a question or the outcome), the problem, the product as the answer, one proof, the offer, call to action. No fake urgency, no invented discounts or reviews, no competitor named or shown.
    
    ## Formats by platform
    
    | Where | Format | Notes |
    |---|---|---|
    | X, LinkedIn, Bluesky feeds | 1:1 or 16:9 | 1:1 takes the most room in a feed. Most viewers watch muted. |
    | Instagram Reels, TikTok, YouTube Shorts | 9:16, 1080 x 1920 | The platform's buttons and caption cover the bottom and the right edge. Keep text in the middle of the frame, well above the bottom fifth, and do not rely on anything in the bottom quarter. |
    | Instagram and Facebook feed | 4:5 (1080 x 1350) or 1:1 | 4:5 is the tallest the feed shows uncropped. |
    | YouTube, a website hero, a presentation | 16:9, 1920 x 1080 | |
    | App stores | the store's exact preview size | Check the current specification. |
    | Video editors (Premiere, Final Cut, DaVinci Resolve, CapCut) | transparent `.mov` (ProRes 4444) or `.webm` | lower thirds, titles, overlays |
    
    Render a master at the format the brief names, then the others with `--format` (core.md, Formats), and check the composition at every format you deliver.
    
    ## Sound
    
    A film that will play with sound on (YouTube, an intro, an ad, a captioned clip) gets `FILM.audio` (audio.md): the user's own licensed music or voice-over, and sound effects from the film's accents. A feed film is watched muted by most viewers: it must read without sound, so never put information only in the audio.
    
    ## What the brief needs, by type
    
    - Every type needs the Facts table with sources (brief.md).
    - **Testimonial:** the quote's source and the person's permission.
    - **Event promo and countdown:** the date, time and time zone from the event's page.
    - **What's new:** the release notes' URL and date.
    - **Milestone and data story:** the data and its period (charts' brief).
    - **Network or coverage:** each place (city, country, coordinates) and each number with its period, from the user's own data (globe's brief).
    - **Product reel and photo types:** the images, each with its owner (the user's own, or licensed).
    - **Captioned clip:** the audio file and its transcript, with the speaker's permission.
    - **Ad:** the offer exactly as the product's page states it today.
    
  • plugins/motion-launch-videos/skills/motion-3d/templates/BRIEF.md2.0 KB20bcbfdddbebupstream ↗
    # Brief: <product> <kind of film>
    
    Filled in by Claude from the user's answers and the product's own pages. Every word and number on screen must trace back to a row in "Facts". With no live site (a demo, a fictional or unreleased product), the user's brief is the only source.
    
    ## Deliverable
    
    | | |
    |---|---|
    | Product | <name>, <url> (or: no live site, demo / fictional / unreleased) |
    | Style | <the skill: kinetic type, shapes, cartoon, 3D, charts, pixel, particles, UI, photo, captions, overlays, globe> |
    | Format | 1080 x 1080 (1:1) |
    | Duration | <n> s, <hold / cycle> loop |
    | Frame rate | 60 fps |
    | Tempo grid | 120 BPM: a beat is 0.5 s, a bar is 2 s, a 16th is 0.125 s |
    | Sound | none (a muted loop; every beat has to work muted) |
    | Where it plays | <X post, landing page hero, launch tweet, conference screen...> |
    | Deliverables | MP4 (H.264, BT.709), preview GIF (480 px), poster PNG, the single HTML file |
    
    ## Facts
    
    Only what the product's own live pages (or the user's own data) state, in their words. No prices, trial terms, user counts or other numbers unless the source shows them today. With no live site, the Source column says `the user's brief`.
    
    | # | Fact | Exact wording at the source | Source URL | Read on |
    |---|---|---|---|---|
    | F1 | | | | |
    | F2 | | | | |
    | F3 | | | | |
    
    ## Not on screen
    
    Things the film must not say, show or imply, and why: a price the site does not show yet, a roadmap feature, a competitor's name, a logo or character that is not the user's.
    
    - 
    
    ## Message beats
    
    At most 4 words of display type each. One call to action, at the end. Small print (typed crumbs, labels, sources) carries facts too, so it cites a row.
    
    | Beat | On screen | Small print (optional) | What moves | Facts |
    |---|---|---|---|---|
    | Hook | | | | |
    | What it does | | | | |
    | Proof | | | | |
    | CTA | | | | |
    
    ## Palette
    
    From the product's own CSS or brand guide when it has a clear brand colour; otherwise the template's.
    
    | Role | Hex | Source |
    |---|---|---|
    | bg | | |
    | | | |
    
    ## Type
    
    | Role | Face | Use |
    |---|---|---|
    | | | |
    
    ## Open questions
    
    - 
    
  • plugins/motion-launch-videos/skills/motion-3d/templates/DESIGN.md2.3 KB9c7ec14f1153upstream ↗
    # Design: <film>
    
    The spec the film is built from. Numbers here and in the FILM config agree; when one changes, change both.
    
    ## Canvas and loop
    
    - 1080 x 1080, 60 fps, 10.000 s = 600 frames, cycle loop.
    - Tempo 120 BPM: beat 0.5 s, 16th 0.125 s, bar 2 s. Keyed moves start on 16ths.
    - Live area 104 to 976 on both axes: the 3D type stays inside it through the whole loop; labels on the 8 px grid.
    
    ## Palette and materials
    
    | Role | Hex | Used for | Material |
    |---|---|---|---|
    | bg | | background and floor | shadow <0.42> |
    | | | the type's faces | gloss <0.35> |
    | | | the type's walls and bevels | |
    | | | supporting objects | gloss <0.6> |
    
    ## Light
    
    - Key light travelling <[-0.38, -0.8, -0.9]> (from above, front, right), key <0.74>, ambient <0.34>, soft <1.8>, rim <0.18>.
    
    ## Camera
    
    | At (s) | Yaw | Pitch | Distance | Target | Field of view | Spring |
    |---|---|---|---|---|---|---|
    | rest | -16 | 14 | 16.5 | 0, 0.35, 0 | 30 | |
    | 1.00 | | | 15.0 | | | DOLLY |
    | 7.00 | | | 16.5 | | | DOLLY |
    
    Sway: <1> cycle per loop, <10> degrees.
    
    ## Objects
    
    | Object | Kind and size | Rest place and turn | Colours | Motion | Loop |
    |---|---|---|---|---|---|
    | hero | text "<WORD>", cap <1.08>, depth <0.5>, bevel <0.05>, track <40> | 0, 0.02, 0 | face / side | flip at <1.5> (-360 on FLIP, 16ths); hop at <5.0> | |
    | | | | | | orbit <1> |
    
    ## Labels
    
    | Label | Text | Face and size | Baseline | Colour |
    |---|---|---|---|---|
    | | | | | |
    
    ## Loop seam
    
    - Every keyed value returns by <t>; whole turns fold back once they settle.
    - Springs still settling at the end: <the camera's dolly back>, which carries over the seam.
    - Cycles: <ring orbit 1, orbs orbit -1 and bob 4, cube spin 1, camera sway 1>.
    
    ## Formats
    
    Delivered: <1:1, 9:16, 16:9>. The camera fits the hero to each frame's narrower side by itself; the patch in `FILM.formats` redesigns the rest (positions in 1:1 terms).
    
    | Format | Camera | Objects | Labels |
    |---|---|---|---|
    | 9:16 (1080 x 1920) | <pitch 30, target y -0.3, contain the ring and the orbs> | <orbs bob higher: rest y 1.2, bob 0.8> | <under the ring: y 848 and 912, no pin> |
    | 16:9 (1920 x 1080) | <dist 14, dolly to 13> | | <as at 1:1> |
    
    ## Review stills
    
    Written by `render.mjs stills` (and `--format 9:16`, into `stills/9x16/`): each key move, each camera landing, the midpoint, frame 0 and the last frame, plus `contact.png`.
    
  • plugins/motion-launch-videos/skills/motion-3d/templates/film.html143 KBbbdbe948f40bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/kimeur-motion-launch-videos-plugins-motion-launch-videos-skills-motion-3d.md

// REPO STATS

13 stars