Vidéo de démonstration produit
Transformez des captures d'écran ou des maquettes de produit statiques en une démo animée et soignée — pas d'enregistreur d'écran, pas de curseur réel saccadé, pas de dérive de version UI. Cadrez chaque écran, faites glisser un curseur synthétique jusqu'au pixel exact, faites onduler le clic, puis zoomez sur la partie importante et légendez la fonctionnalité. Parce que l'entrée est statique et le mouvement est codé, chaque valeur est déterministe et se re-rend à l'identique lorsque la capture d'écran change.
Quand l'utiliser
- Démo d'application / SaaS, annonce de fonctionnalité, parcours d'intégration (15–90s).
- Montrer un chemin de clic à travers une UI dont vous n'avez que des captures d'écran/maquettes.
- Mettre en évidence une zone focale d'un tableau de bord dense (zoom sur une région + callout).
Pourquoi les captures d'écran battent les enregistrements d'écran
| Enregistrement d'écran | Piloté par captures d'écran (cette compétence) |
|---|---|
| Le curseur réel dérive, dépasse, saccade | Le curseur suit un chemin fluide vers une cible exacte |
| Ré-enregistrer toute la prise pour corriger une étape | Échanger un PNG, re-rendre le même code |
| L'UI change en cours de prise, la souris cherche | Chaque écran est un asset propre et final |
| Difficile de zoomer sans pixelisation | Exporter les captures d'écran en 2× (DPR 2) → zooms nets |
Capturez les entrées à deux fois la taille d'affichage (retina / deviceScaleFactor: 2) pour qu'un zoom 2× reste net. Voir references/screenshot-demo.md pour un script de capture Playwright.
La boucle de démo
Chaque démo suit le même rythme, répété par fonctionnalité. Maintenez assez longtemps pour lire, déplacez-vous avec intention, posez le clic, révélez le résultat.
| Rythme | Durée | Rôle |
|---|---|---|
| S'installer sur l'écran | 0,5–1s | Laisser le spectateur s'orienter avant tout mouvement |
| Le curseur se déplace vers la cible | 0,4–0,8s | Mouvement fluide (ease-in-out), pas linéaire |
| Ondulation du clic + changement d'état | 0,2–0,3s | Retour tactile ; l'écran réagit sur la même image |
| Zoom sur la région focale | 1–2s d'entrée, maintenir 2–4s | 2× est le point idéal — assez de détails, garde le contexte |
| Légende de la fonctionnalité | maintenir avec le zoom | Une phrase de bénéfice, par ex. « Export en un clic » |
Déplacez la caméra ou le curseur, rarement les deux à la fois — deux mouvements simultanés divisent l'attention.
Cadrer la capture d'écran
Une capture d'écran brute ressemble à un rapport de bug ; une capture cadrée ressemble à un produit. Entourez chaque écran d'un chrome de navigateur ou d'appareil sur un fond de marque.
// Cadre de navigateur — déposez une capture d'écran, obtenez une fenêtre crédible
const BrowserFrame = ({ url, children }) => (
<div style={{ borderRadius: 12, overflow: "hidden", background: "#1e1e22",
boxShadow: "0 40px 80px rgba(0,0,0,.35)" }}>
<div style={{ height: 40, display: "flex", alignItems: "center", gap: 8, padding: "0 14px" }}>
{["#ff5f57", "#febc2e", "#28c840"].map((c) => (
<span key={c} style={{ width: 12, height: 12, borderRadius: "50%", background: c }} />
))}
<div style={{ marginLeft: 12, flex: 1, height: 24, borderRadius: 6, background: "#2b2b30",
color: "#9aa", fontSize: 13, display: "flex", alignItems: "center", padding: "0 10px" }}>
{url}
</div>
</div>
<div style={{ background: "#fff" }}>{children}</div>
</div>
);
Mettez une URL réelle dans la barre d'adresse (authenticité), ajoutez une ombre douce et un fond dégradé. Pour le mobile, remplacez par un cadre de téléphone avec une encoche et des coins arrondis. Gardez le style de cadre dans un seul objet de thème pour que chaque écran corresponde.
Curseur animé + ondulation de clic (le mouvement central)
Conduisez la position à partir de l'image courante, jamais d'une transition CSS ou d'une horloge murale — un rendu vidéo a besoin que chaque image soit une fonction pure du numéro d'image, sinon le curseur se désynchronise et scintille.
import { useCurrentFrame, interpolate, spring, useVideoConfig } from "remotion";
// Trajet fluide de `from` à `to` entre startFrame et startFrame+dur
const useCursor = (from, to, startFrame, dur) => {
const frame = useCurrentFrame();
const t = interpolate(frame, [startFrame, startFrame + dur], [0, 1],
{ extrapolateLeft: "clamp", extrapolateRight: "clamp", easing: (x) => x * x * (3 - 2 * x) }); // smoothstep
return { x: from.x + (to.x - from.x) * t, y: from.y + (to.y - from.y) * t };
};
export const Cursor = ({ from, to, startFrame, dur, clickAt }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const { x, y } = useCursor(from, to, startFrame, dur);
// L'ondulation se déploie une fois, à l'image du clic
const since = frame - clickAt;
const showRipple = since >= 0 && since < 18;
const r = spring({ frame: since, fps, config: { damping: 18 }, durationInFrames: 18 });
return (
<>
{showRipple && (
<div style={{ position: "absolute", left: x, top: y, transform: "translate(-50%,-50%)",
width: 12 + r * 60, height: 12 + r * 60, borderRadius: "50%",
border: "2px solid rgba(80,140,255,.9)", opacity: 1 - r }} />
)}
<svg width="28" height="28" viewBox="0 0 28 28"
style={{ position: "absolute", left: x, top: y, filter: "drop-shadow(0 2px 3px rgba(0,0,0,.4))" }}>
<path d="M3 2 L3 21 L9 15 L13 24 L16 23 L12 14 L20 14 Z" fill="#fff" stroke="#222" strokeWidth="1.4" />
</svg>
</>
);
};
Le curseur utilise smoothstep pour accélérer depuis l'arrêt et décélérer vers la cible (un curseur linéaire semble robotique). Déclenchez l'ondulation et le changement d'état de l'écran sur la même image clickAt pour que la cause et l'effet correspondent. Voir references/screenshot-demo.md pour la composition complète qui chaîne plusieurs clics sur plusieurs écrans.
Zoomer sur une région (Ken Burns pour UI)
Pour zoomer sur un élément focal, mettez à l'échelle l'écran et définissez transform-origin au centre de cet élément, afin que le zoom converge sur lui plutôt que sur le centre du cadre.
const ZoomToRegion = ({ target, scale = 2, startFrame, dur, children }) => {
const frame = useCurrentFrame();
const s = interpolate(frame, [startFrame, startFrame + dur], [1, scale],
{ extrapolateLeft: "clamp", extrapolateRight: "clamp", easing: (x) => 1 - Math.pow(1 - x, 3) }); // easeOutCubic
return (
<div style={{ transform: `scale(${s})`, transformOrigin: `${target.x}px ${target.y}px`,
willChange: "transform" }}>
{children}
</div>
);
};
Limitez le zoom à environ 2× (au-delà de 3×, on perd le contexte et on désoriente). Maintenez l'état zoomé 2–4s — assez longtemps pour lire le détail — puis ressortez en douceur avant de passer à l'écran suivant. Associez le zoom à un callout, jamais brut.
Annotations callout et légendes de fonctionnalités
Annotez l'inflexion, puis laissez-la disparaître. Un callout est une étiquette + un connecteur (flèche, cercle ou soulignement) qui pointe vers l'élément focal.
- Mettez en évidence l'élément avec un anneau doux ou un assombrissement autour (
box-shadow: 0 0 0 9999px rgba(0,0,0,.45)découpe un trou de projecteur). - Légendez un bénéfice par rythme — un court groupe nominal (« Analytics en temps réel »), pas une phrase. Apparaît sur le zoom, disparaît avant l'étape suivante.
- Gardez les légendes dans le tiers inférieur et dans la zone sécurisée pour le titre afin qu'elles survivent aux recadrages en 9:16.
Voir references/annotation-and-transitions.md pour les masques de projecteur, les connecteurs fléchés/circulaires, une piste de légendes typées, et les notes de zone sécurisée multi-aspect.
Transitions entre écrans
Entre les étapes, déplacez les écrans avec un langage cohérent. Choisissez-en un et gardez-le :
| Transition | Sensation | Utilisation |
|---|---|---|
| Pousser / glisser | Mouvement « étape suivante » vers l'avant | Parcours linéaires |
| Zoom croisé | Élan, semblable à une application | Sauter dans une vue détaillée |
| Fondu enchaîné | Calme, neutre | Changement de contexte (paramètres → tableau de bord) |
| Coupure de montage sur un élément commun | Fluide | Même carte persistante entre les écrans |
Maintenez l'écran sortant jusqu'à ce que son clic se résolve, puis transitionnez — ne coupez jamais en plein mouvement. Voir references/annotation-and-transitions.md.
Liste de vérification de sortie
- Entrées capturées en 2× (DPR 2) ; les zooms restent nets à 2×.
- Chaque valeur de curseur/zoom est une fonction pure de
useCurrentFrame()— pas de transitions CSS pour l'état animé. - Le curseur se déplace sur un chemin fluide (smoothstep) ; l'ondulation et le changement d'état se déclenchent sur la même image de clic.
- Chaque écran cadré (navigateur/appareil) avec une URL réelle et un thème cohérent.
- Un mouvement à la fois (caméra ou curseur) ; zoom ≤ 2×, maintenu 2–4s.
- Une légende de bénéfice par rythme, dans le tiers inférieur sécurisé pour le titre ; les transitions utilisent un langage cohérent.
Livrer et vérifier (images fixes rendues → MP4)
Aide packagée (
scripts/) : assemblez vos images fixes avecscripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png, puis validez l'encodage avecscripts/probe-mp4.sh out.mp4 [LxH] [fps]. Voirscripts/README.md.
C'est un niveau lourd : le livrable est un MP4, pas une page live. La démo ingère les assets de l'utilisateur — captures d'écran/maquettes, logo optionnel — donc la vérification consiste surtout à vérifier que la bonne image s'est bien chargée et se trouve dans le cadre.
Contrat de sortie :
- Un projet Remotion avec la composition enregistrée (
<Composition>+ schéma zodschema+defaultProps) ; chaque valeur de curseur/zoom/transition est une fonction pure deuseCurrentFrame()(pas de transitions CSS, de minuteurs, deDate.now()). - Les captures d'écran chargées via
staticFile(), protégées pardelayRender/continueRenderpour que le PNG 2× (et toute police web) soit présent avant le rendu de l'image — sinon l'écran apparaît vide au milieu de la démo. - Livrable = le
out/*.mp4rendu plus le projet (re-rendu lorsque la capture d'écran change).
Boucle de vérification — rendre des images fixes → inspecter → encoder. D'abord des PNG bon marché, la vidéo seulement quand ils sont corrects.
# Images fixes EXACTES À L'IMAGE avec les PROPS QUE VOUS ALLEZ LIVRER (vrais chemins de captures), pas defaultProps
npx remotion still ProductDemo out/f-settle.png --frame=15 --props=demo.json # écran cadré, avant le mouvement
npx remotion still ProductDemo out/f-click.png --frame=90 --props=demo.json # curseur sur la cible + ondulation
npx remotion still ProductDemo out/f-zoom.png --frame=150 --props=demo.json # zoomé sur la région focale + légende
# image de fin = durationInFrames - 1 (npx remotion compositions le lit)
Inspectez chaque PNG pour la fidélité (capture d'écran correcte chargée ; curseur sur le pixel exact ; ondulation du clic et changement d'état sur la même image ; texte de légende correct) ET les artefacts (image vide/non chargée, écran hors cadre, zoom pixelisé ou dépassant le cadre, légende hors du tiers inférieur sécurisé, mauvais rapport hauteur/largeur ou letterboxing).
# Seulement après que les images fixes sont propres :
npx remotion render ProductDemo out/demo.mp4 --props=demo.json
npx remotion render ProductDemo out/demo.gif --props=demo.json --codec=gif # PREUVE DE PREMIER ÉCRAN pour le README
Traitement par lots (un modèle, plusieurs produits) : lors du réhabillage de la démo par produit, vérifiez les props d'UN produit représentatif via des images fixes avant de rendre le catalogue par lots — attrapez un bug d'image vide ou hors cadre une fois, pas N fois.
Avant de terminer :
- Les images fixes se rendent proprement à l'installation / au clic / à la fin — pas d'erreurs, les captures d'écran sont bien chargées (pas vides).
- Le curseur atterrit sur la cible exacte ; l'ondulation + le changement d'état sur la même image ; le texte de légende correct et dans le tiers inférieur sécurisé pour le titre.
- Tout le mouvement est piloté par les images — pas de transitions CSS / minuteurs /
Date.now()/Math.random(). - Les props livrées (vrais chemins de captures d'écran) se rendent correctement, pas seulement
defaultProps. - MP4 complet encodé et lisible ; (optionnel) GIF rendu pour le README.
Fichiers de référence
references/screenshot-demo.md— une démo Remotion complète et exécutable : capture de captures d'écran en 2× avec Playwright, les composants de cadre navigateur/téléphone, une composition multi-étapes qui promène un curseur sur plusieurs écrans avec ondulations de clic, et une commande de rendu.references/annotation-and-transitions.md— masques de projecteur, connecteurs de callout fléchés/circulaires, une piste de légendes de fonctionnalités typées, et les quatre transitions entre écrans avec implémentations pilotées par les images et notes de zone sécurisée multi-aspect (16:9 / 9:16).