Le skill animateur 3D
Le skill animateur-3d apprend à Claude à faire une vidéo 3D écrite en code, sans logiciel 3D. Il tient en 4 fichiers texte : tu les copies, puis tu les donnes à Claude. Sur ordinateur, le zip en bas de page est plus simple.
Tu es sur ton téléphone ? Le skill s'installe sur un ordinateur, dans Claude Code. Copie le texte et envoie-le-toi (mail, notes), ou rouvre cette page sur ton ordi.
1. Copie les 4 fichiers du skill
---
name: animateur-3d
description: Crée une vidéo ou une animation 3D entièrement écrite en code (Three.js), au niveau d'une pub sur les réseaux sociaux. Scène détaillée et bien éclairée, caméra de cinéma qui alterne plans rapides et plans lents, coupes calées sur la musique, textes animés mot par mot, bruitages qui collent à l'image. À utiliser quand on demande une vidéo 3D, une animation 3D, une pub 3D, un motion design 3D ou une scène 3D animée, sans logiciel 3D.
---
# Animateur 3D : une vidéo 3D écrite en code
Tu joues le rôle d'un animateur 3D. Tu fabriques une scène 3D en code (Three.js), tu la filmes avec une caméra de cinéma, et tu rends une page HTML que l'on peut lire image par image. Avec Claude Code et le moteur libre HyperFrames, cette page devient un fichier MP4.
## 0. Ce que tu livres
- **Toujours** : une page `index.html` autonome (Three.js + GSAP chargés depuis un CDN), construite sur `gabarit/index.html` de ce skill. On peut l'ouvrir dans un navigateur pour voir l'animation.
- **Si tu as un terminal (Claude Code)** : un MP4 rendu avec HyperFrames (`npx hyperframes@0.9.25 render`, version vérifiée ; moteur open source sous licence Apache-2.0). Vérifie que la commande existe avant de la promettre. HyperFrames demande Node.js 22 ou plus (`node -v`).
- **Sans terminal** (claude.ai) : la page HTML ; explique à la personne comment la voir et, si elle veut un MP4, qu'il faudra soit Claude Code, soit un enregistrement de l'écran.
- Par défaut, deux formats : horizontal 1920×1080 et vertical 1080×1920.
## 1. Cadrer avant d'écrire du code
Récupère ces 5 choses (pose au plus une ou deux questions, déduis le reste) :
1. Le sujet et le message unique (une phrase).
2. La durée (souvent 15 à 40 s).
3. Les formats (16:9, 9:16 ou les deux).
4. L'ambiance (couleurs, lumière, références).
5. La musique et la voix (fichiers fournis ou non). Si une musique est fournie, mesure son tempo : tu caleras les coupes dessus.
## 2. Le storyboard
- Écris un tableau : début, fin, caméra, objet héros, texte, son. Fais-le valider avant de coder si la personne est là.
- **8 à 24 plans.** Un plan = une idée, un mouvement de caméra, un détail qui attire l'œil.
- **Alterne le rythme** : un plan rapide (la caméra arrive vite puis se pose), puis un plan lent (travelling doux, comme une caméra sur rail). Jamais deux minutes au même rythme.
- **Coupes sur la musique** : un plan rapide dure 1 à 2 temps ; un plan lent 2 à 4 temps. Le temps fort de la musique tombe sur la révélation.
- Un fil conducteur visuel (une lumière, un objet, une couleur) qui relie les plans.
- Une révélation ou un « avant / après » dans le premier tiers ; le message ou le logo à la fin, sur un fond calme.
## 3. La scène : beaucoup de détails, beaucoup de lumière
Pour chaque objet visible plus d'une seconde :
- **1 objet héros très détaillé + 3 objets secondaires** par plan, une source de lumière qui a une raison d'être (fenêtre, lampe), et **un élément vivant** (poussière dans la lumière, écran qui s'écrit, plante qui bouge, voyant qui respire).
- Formes arrondies (`RoundedBoxGeometry`), matières variées (bois, plastique, métal, tissu), textures dessinées au canvas (×2 pour la netteté).
- **Une scène claire** : éclairage de studio, objets bien lisibles, `ACESFilmicToneMapping`, ombres douces. Une scène sombre fait « amateur ».
- Post-traitement léger : occlusion ambiante (GTAO), un peu de bloom (seuil haut, environ 0,9), flou de profondeur discret, grain et vignette très légers.
- Les écrans et interfaces : dessinés au canvas, texte net, couleurs vives, états qui changent dans le temps (frappe, barre qui se remplit, coches).
## 4. La caméra
- Chaque plan est une entrée `{t0, t1, p0, p1, l0, l1, mvt, f0, f1, r0, r1}` : positions de départ et d'arrivée de la caméra (`p`), du point regardé (`l`), focale (`f`), roulis (`r`, quelques degrés).
- **Plan rapide** : courbe `expoOut` (arrive vite, se pose), léger roulis, focale qui se resserre, petit « coup de fouet » de flou à la coupe.
- **Plan lent** : courbe en cosinus `0,5 − 0,5·cos(πt)`, déplacement court, pas de coup de fouet.
- La caméra ne s'arrête jamais complètement (même 2 % de mouvement). Le flou de profondeur suit la distance caméra → cible.
- **Flou de mouvement** : mesure le déplacement à l'écran du point regardé entre deux images et floute dans ce sens (le gabarit le fait).
- **Vertical** : ne recadre jamais un 16:9. Recompose : recule la caméra plan par plan (de ×1,05 à ×1,75 selon le plan), puis vérifie qu'aucun recul ne fait passer la caméra dans un mur.
## 5. Les textes
- Sous-titres : chaque mot entre en 0,2 à 0,35 s (flou → net, monte de 20 px, échelle 0,9 → 1), un mot après l'autre.
- Gros mots : arrivée en zoom flou (échelle 1,9 → 1). Un mot barré : un trait qui se dessine en 0,3 s.
- Sortie en 0,12 à 0,2 s. Jamais deux textes au même endroit en même temps. Contraste lisible sur le fond.
## 6. Le son
- **Des bruitages qui collent à l'image** : chaque son correspond à ce qu'on voit. Caméra qui file = souffle qui traverse l'image ; bulle de message = petit « pop » ; trait sur un mot = feutre ; touche de clavier = clac ; bouton ou étiquette = clic discret. Le script `scripts/bruitages.py` de ce skill les fabrique (Python, numpy, scipy).
- **À éviter** : cloches, gros « boom », rafales de petits tics, réverbération longue qui fait un bruit de pluie en fond.
- Environ 1,5 bruitage par seconde, seulement sur les gestes.
- Voix (si présente) : 1 à 4 dB au-dessus de la musique quand elle parle. Musique et bruitages : seulement des sons dont tu as le droit de te servir (licence vérifiée).
- Voix de synthèse : le dire. Une mention « Voix générée par IA » et l'étiquette « contenu IA » de la plateforme.
## 7. Contrôler avant de dire « c'est fini »
Sans navigateur ni terminal (claude.ai), demande à la personne d'ouvrir la page et de t'envoyer des captures, puis corrige.
1. Ouvre la page, prends des images au milieu de chaque plan et regarde-les vraiment.
2. Zoome sur les textes, l'écran, les objets héros, les bords du cadre.
3. Cherche les images presque unies et claires : c'est souvent la caméra entrée dans un mur.
4. Vérifie le rythme : les plans rapides doivent avoir un pic de mouvement puis se poser, les plans lents glisser régulièrement.
5. Après le rendu, regarde une planche du MP4 (une image par seconde) et les 3 premières secondes image par image.
Corrige, puis recommence jusqu'à zéro défaut.
## 8. Pièges connus
- Une orbite large ou un départ rapide peuvent démarrer **dans un mur** pendant 2 ou 3 images : invisible sur une planche lente. Contrôle à 10 images par seconde.
- Étiquettes accrochées à un objet 3D : appeler `camera.updateMatrixWorld()` avant `vector.project(camera)`, sinon elles ont une image de retard.
- Sprites transparents (vapeur) + GTAO = carrés noirs : utiliser des points ou couper le GTAO près d'eux.
- Écran trop blanc en gros plan : `MeshBasicMaterial` gris clair avec `toneMapped: false`, bloom au seuil haut.
- Chargements (modèles, textures) : attendre la fin, rendre chaque plan une fois pour préparer les shaders, puis seulement lancer le rendu. Sinon les premières images sortent vides.
- Un élément HTML animé par GSAP : pas de `transform` dans son CSS (conflit).
## 9. Livrer
- Horizontal et vertical, avec et sans musique, plus une planche d'images.
- Dis honnêtement ce qui a été vérifié et ce qui ne l'a pas été.
---
© Will (Will IA, @willll.ia). Skill offert pour ton usage, personnel ou dans ton activité ; tu peux l'adapter pour toi. Pas de revente, de republication ni de diffusion, en tout ou en partie, sans accord écrit. Fourni tel quel, sans garantie de résultat. Indépendant d'Anthropic ; « Claude » est une marque d'Anthropic.
<!doctype html>
<html lang="fr">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=1920, height=1080" />
<title>Gabarit animateur 3D</title>
<!-- © Will (Will IA, @willll.ia) — skill « animateur-3d ». Usage personnel ou pro ; pas de revente, de republication ni de diffusion sans accord écrit. Three.js : licence MIT. GSAP : licence gratuite de Webflow.
Gabarit du skill « animateur-3d ». Une page = une vidéo. Lisible dans un navigateur ; rendue en MP4 par HyperFrames.
Pour la verticale : data-width="1080" data-height="1920" sur #root, LARG/HAUT ci-dessous, et KV (recul) > 1. -->
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
<script type="importmap">
{ "imports": {
"three": "https://cdn.jsdelivr.net/npm/three@0.181.2/build/three.module.js",
"three/addons/": "https://cdn.jsdelivr.net/npm/three@0.181.2/examples/jsm/"
} }
</script>
<style>
html, body { margin: 0; background: #000; }
#root { position: relative; width: 1920px; height: 1080px; overflow: hidden; font-family: system-ui, -apple-system, "Helvetica Neue", sans-serif; }
#scene { position: absolute; inset: 0; width: 100%; height: 100%; display: block; }
.st { position: absolute; left: 0; right: 0; bottom: 80px; margin: 0 auto; width: fit-content; max-width: 1700px; padding: 12px 28px; border-radius: 18px;
background: rgba(28,16,10,.62); text-align: center; font-weight: 800; font-size: 56px; line-height: 1.15; color: #fff; opacity: 0; z-index: 5; }
.st b { color: #ffb15c; }
.st .mot { display: inline-block; opacity: 0; }
.titre { position: absolute; left: 0; right: 0; top: 300px; text-align: center; font-weight: 900; font-size: 170px; color: #7a1f0e; opacity: 0;
text-shadow: 0 6px 30px rgba(255,255,255,.5); z-index: 5; }
</style>
</head>
<body>
<div id="root" data-composition-id="main" data-width="1920" data-height="1080" data-duration="8">
<canvas id="scene"></canvas>
<div id="t1" class="titre">BONJOUR</div>
<div id="s1" class="st">Une scène 3D, écrite en <b>code</b>.</div>
<div id="s2" class="st">Une caméra qui <b>bouge</b> comme au cinéma.</div>
</div>
<script>
// --- Timeline des textes (GSAP, en pause : le moteur la fait avancer image par image) ---
window.__timelines = window.__timelines || {};
const tl = gsap.timeline({ paused: true });
function enMots(el){ const out=[]; [...el.childNodes].forEach(n=>{
if(n.nodeType===3){ n.textContent.split(/(\s+)/).forEach(m=>{ if(!m) return;
if(/^\s+$/.test(m)) out.push(document.createTextNode(m)); else { const s=document.createElement("span"); s.className="mot"; s.textContent=m; out.push(s); } }); }
else { const s=document.createElement("span"); s.className="mot"; s.appendChild(n.cloneNode(true)); out.push(s); } });
el.replaceChildren(...out); return el.querySelectorAll(".mot"); }
// [id, début, fin]
[["s1", 1.2, 4.3], ["s2", 4.6, 7.6]].forEach(([id, a, b]) => {
const el = document.getElementById(id), mots = enMots(el);
tl.fromTo(el, {opacity:0}, {opacity:1, duration:.01}, a);
tl.fromTo(mots, {opacity:0, y:26, scale:.9, filter:"blur(8px)"}, {opacity:1, y:0, scale:1, filter:"blur(0px)", duration:.34, ease:"expo.out", stagger:.08}, a);
tl.to(el, {opacity:0, y:-12, filter:"blur(6px)", duration:.16, ease:"power2.in"}, b - .16);
});
tl.fromTo("#t1", {opacity:0, scale:1.9, filter:"blur(16px)"}, {opacity:1, scale:1, filter:"blur(0px)", duration:.45, ease:"expo.out"}, .1);
tl.to("#t1", {opacity:0, scale:.8, filter:"blur(12px)", duration:.18, ease:"power2.in"}, 1.0);
tl.to({}, {duration: 8}, 0);
window.__timelines["main"] = tl;
</script>
<script type="module">
import * as THREE from "three";
import { RoundedBoxGeometry } from "three/addons/geometries/RoundedBoxGeometry.js";
import { RoomEnvironment } from "three/addons/environments/RoomEnvironment.js";
import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";
import { RenderPass } from "three/addons/postprocessing/RenderPass.js";
import { UnrealBloomPass } from "three/addons/postprocessing/UnrealBloomPass.js";
import { OutputPass } from "three/addons/postprocessing/OutputPass.js";
import { ShaderPass } from "three/addons/postprocessing/ShaderPass.js";
const LARG = 1920, HAUT = 1080, QUAL = 1.5; // QUAL : rendu interne plus grand = plus net
const KV = 1; // recul de la caméra (vertical : 1.3 à 1.7)
const canvas = document.getElementById("scene");
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, preserveDrawingBuffer: true });
renderer.setPixelRatio(1); renderer.setSize(LARG*QUAL, HAUT*QUAL, false);
renderer.toneMapping = THREE.ACESFilmicToneMapping; renderer.toneMappingExposure = 1.15;
renderer.shadowMap.enabled = true; renderer.shadowMap.type = THREE.PCFSoftShadowMap;
const scene = new THREE.Scene();
scene.background = new THREE.Color(0xf1e6d6);
const pmrem = new THREE.PMREMGenerator(renderer);
scene.environment = pmrem.fromScene(new RoomEnvironment(), .04).texture; scene.environmentIntensity = .45;
const camera = new THREE.PerspectiveCamera(32, LARG/HAUT, .03, 60);
// --- Lumières : une clé chaude (fenêtre), un débouchage, un contre-jour ---
const cle = new THREE.DirectionalLight(0xffd9a8, 3.2); cle.position.set(-3, 4, 2); cle.castShadow = true;
cle.shadow.mapSize.set(2048, 2048); cle.shadow.camera.left = cle.shadow.camera.bottom = -4; cle.shadow.camera.right = cle.shadow.camera.top = 4; cle.shadow.radius = 4;
scene.add(cle, new THREE.HemisphereLight(0xfff4e6, 0x8a6a50, .9));
const contre = new THREE.PointLight(0xffb15c, 6, 6); contre.position.set(1.2, 2.2, -2.2); scene.add(contre);
// --- Objets : sol, mur, bureau, écran, plante ---
const boite = (w,h,d,mat,x,y,z,r=.02) => { const m = new THREE.Mesh(new RoundedBoxGeometry(w,h,d,3,r), mat); m.position.set(x,y,z); m.castShadow = m.receiveShadow = true; scene.add(m); return m; };
const bois = new THREE.MeshStandardMaterial({ color: 0x8a5a3a, roughness: .55 });
const beige = new THREE.MeshStandardMaterial({ color: 0xe8dcc6, roughness: .45 });
boite(12, .1, 12, new THREE.MeshStandardMaterial({ color: 0xc9a98a, roughness: .9 }), 0, -.05, 0, .01); // sol
boite(12, 5, .1, new THREE.MeshStandardMaterial({ color: 0xd98f6a, roughness: .95 }), 0, 2.5, -2.6, .01); // mur
boite(2.4, .08, 1.1, bois, 0, 1.1, -1.3); // plateau
[[-1.1,-1.75],[1.1,-1.75],[-1.1,-.85],[1.1,-.85]].forEach(([x,z]) => boite(.07, 1.06, .07, bois, x, .53, z)); // pieds
boite(.62, .5, .45, beige, 0, 1.55, -1.55, .05); // écran (coque)
// l'écran : une texture canvas qui change avec le temps (élément vivant)
const ec = document.createElement("canvas"); ec.width = 1024; ec.height = 768; const g = ec.getContext("2d");
const texEcran = new THREE.CanvasTexture(ec); texEcran.colorSpace = THREE.SRGBColorSpace;
const ecran = new THREE.Mesh(new THREE.PlaneGeometry(.5, .375), new THREE.MeshBasicMaterial({ map: texEcran, color: 0xd0d0d0, toneMapped: false }));
ecran.position.set(0, 1.56, -1.32); scene.add(ecran);
function dessinerEcran(t){
g.fillStyle = "#fbf7ef"; g.fillRect(0, 0, 1024, 768);
g.fillStyle = "#7A1024"; g.fillRect(0, 0, 1024, 70);
g.fillStyle = "#222"; g.font = "600 54px system-ui"; const txt = "Écris-moi une scène en 3D…";
g.fillText(txt.slice(0, Math.max(0, Math.floor((t-.5)*14))), 60, 200);
const p = Math.min(1, Math.max(0, (t-3)/3)); g.fillStyle = "#e8e0d2"; g.fillRect(60, 420, 900, 40); g.fillStyle = "#16a34a"; g.fillRect(60, 420, 900*p, 40);
texEcran.needsUpdate = true;
}
boite(.1, .5, .1, beige, 0, 1.3, -1.6); // pied d'écran
boite(.7, .03, .22, beige, 0, 1.16, -1.05, .01); // clavier
const pot = new THREE.Mesh(new THREE.CylinderGeometry(.09, .07, .18, 24), new THREE.MeshStandardMaterial({ color: 0xf4f0e8, roughness: .4 }));
pot.position.set(.85, 1.23, -1.45); pot.castShadow = true; scene.add(pot);
const feuilles = [];
for (let i = 0; i < 9; i++) { const f = new THREE.Mesh(new THREE.SphereGeometry(.08, 16, 10), new THREE.MeshStandardMaterial({ color: 0x3f8a4a, roughness: .6 }));
const a = i/9*Math.PI*2; f.position.set(.85+Math.cos(a)*.08, 1.4+(i%3)*.06, -1.45+Math.sin(a)*.08); f.scale.set(1, .35, .6); f.rotation.set(.4, a, .3);
f.castShadow = true; scene.add(f); feuilles.push([f, f.rotation.x, i]); }
// --- Post-traitement : bloom léger + flou de mouvement + grain ---
const composer = new EffectComposer(renderer); composer.setPixelRatio(1); composer.setSize(LARG*QUAL, HAUT*QUAL);
composer.addPass(new RenderPass(scene, camera));
composer.addPass(new UnrealBloomPass(new THREE.Vector2(LARG*QUAL, HAUT*QUAL), .3, .5, .9));
composer.addPass(new OutputPass());
const flou = new ShaderPass({ uniforms: { tDiffuse: { value: null }, uDir: { value: new THREE.Vector2() } },
vertexShader: "varying vec2 vUv; void main(){ vUv=uv; gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.); }",
fragmentShader: `uniform sampler2D tDiffuse; uniform vec2 uDir; varying vec2 vUv;
void main(){ if(dot(uDir,uDir)<1e-8){ gl_FragColor=texture2D(tDiffuse,vUv); return; }
vec4 s=vec4(0.); for(int i=0;i<15;i++){ s+=texture2D(tDiffuse, vUv+uDir*(float(i)/14.-.5)); } gl_FragColor=s/15.; }` });
composer.addPass(flou);
// --- Plans de caméra : RAPIDE (expoOut, coup de fouet) puis LENT (cosinus) en alternance ---
const V = (x,y,z) => new THREE.Vector3(x,y,z);
const expoOut = t => t >= 1 ? 1 : 1 - Math.pow(2, -10*t);
const doux = t => .5 - .5*Math.cos(Math.PI*t);
const clamp = (x,a=0,b=1) => Math.min(b, Math.max(a, x));
const plans = [
{ t0:0, t1:2.2, p0:V(2.6,2.4,2.6), p1:V(1.3,1.75,1.0), l0:V(0,1.4,-1.4), l1:V(0,1.5,-1.4), mvt:expoOut, f0:40, f1:32, r0:.05, r1:0, vite:true },
{ t0:2.2, t1:4.5, p0:V(-.9,1.5,.2), p1:V(-.4,1.55,.0), l0:V(.2,1.45,-1.4), l1:V(0,1.52,-1.4), mvt:doux },
{ t0:4.5, t1:6.0, p0:V(.9,1.62,-.4), p1:V(.0,1.58,-.6), l0:V(0,1.56,-1.32), l1:V(0,1.56,-1.32),mvt:expoOut, f0:36, f1:30, vite:true },
{ t0:6.0, t1:8.0, p0:V(.3,1.7,.6), p1:V(1.2,1.9,1.6), l0:V(0,1.5,-1.4), l1:V(0,1.45,-1.4), mvt:doux },
];
const cible = new THREE.Vector3(); let focale = 32;
function cam(t){
const p = plans.find(q => t >= q.t0 && t < q.t1) || plans[plans.length-1];
const u = p.mvt(clamp((t-p.t0)/(p.t1-p.t0)));
camera.position.lerpVectors(p.p0, p.p1, u); cible.lerpVectors(p.l0, p.l1, u);
if (KV !== 1) camera.position.sub(cible).multiplyScalar(p.kv || KV).add(cible);
camera.position.y += Math.sin(t*1.3)*.004; // respiration : la caméra n'est jamais figée
camera.up.set(0,1,0); camera.lookAt(cible); camera.rotateZ((p.r0||0) + ((p.r1||0)-(p.r0||0))*u);
const f = (p.f0||32) + ((p.f1||p.f0||32) - (p.f0||32))*u; if (f !== focale) { focale = f; camera.fov = f; camera.updateProjectionMatrix(); }
}
const X = new THREE.Vector3(), A = new THREE.Vector3();
function reglerFlou(t){
let dx = 0, dy = 0; const dt = 1/30, p = plans.find(q => t >= q.t0 && t < q.t1);
if (p && t-dt >= p.t0) { // déplacement à l'écran du point regardé en une image
cam(t); camera.updateMatrixWorld(); X.copy(cible); A.copy(X).project(camera); const ax = A.x, ay = A.y;
cam(t-dt); camera.updateMatrixWorld(); A.copy(X).project(camera); dx = (ax-A.x)*.25; dy = (ay-A.y)*.25;
}
plans.forEach((q, k) => { if (!k || !q.vite) return; const e = t-q.t0; // coup de fouet en entrant dans un plan rapide
if (e > -.1 && e < .14) { const w = e < 0 ? 1+e/.1 : 1-e/.14; dx += .045*w*w; } });
const L = Math.hypot(dx, dy); if (L > .05) { dx *= .05/L; dy *= .05/L; }
flou.uniforms.uDir.value.set(dx, dy);
}
function renderAt(t){
reglerFlou(t); cam(t); dessinerEcran(t);
feuilles.forEach(([f, rx, i]) => { f.rotation.x = rx + Math.sin(t*1.1 + i)*.03; });
contre.intensity = 6 + Math.sin(t*1.5)*.6;
composer.render();
}
window.addEventListener("hf-seek", e => renderAt(e.detail.time)); // le moteur de rendu envoie l'instant à afficher
renderAt(window.__hfThreeTime || 0);
// Pour regarder l'animation pendant le travail : `npx hyperframes preview` dans ce dossier (lecteur avec barre de temps).
// La 3D suit la timeline GSAP : chaque position de la timeline redessine la scène.
window.__timelines.main.eventCallback("onUpdate", () => renderAt(window.__timelines.main.time()));
// Ouverte seule dans un navigateur : la vidéo joue, recommence, et se réduit pour tenir dans la fenêtre.
// Pilotée par le moteur de rendu (signal hf-seek) : rien ne change, la page garde sa taille d'origine.
let pilote = false;
const racine = document.getElementById("root");
function tenirDansLaFenetre(){
if (pilote) return;
const w = +racine.dataset.width, h = +racine.dataset.height, k = Math.min(innerWidth / w, innerHeight / h);
racine.style.transformOrigin = "0 0";
racine.style.transform = `translate(${(innerWidth - w * k) / 2}px, ${(innerHeight - h * k) / 2}px) scale(${k})`;
document.body.style.overflow = "hidden";
}
window.addEventListener("hf-seek", () => { pilote = true; window.__timelines.main.pause(); racine.style.transform = ""; document.body.style.overflow = ""; });
window.__timelines.main.eventCallback("onComplete", () => { if (!pilote) window.__timelines.main.restart(); });
setTimeout(() => {
if (pilote || window.__hfThreeTime || navigator.webdriver) return;
tenirDansLaFenetre(); window.addEventListener("resize", tenirDansLaFenetre);
window.__timelines.main.play();
}, 400);
</script>
</body>
</html>
"""Bruitages qui collent à l'image, calculés en Python par ce script (aucun fichier son externe).
Chaque son = un geste qu'on voit :
souffle la caméra file (le son traverse l'image si pan et pan_fin sont différents)
souffle_lent travelling lent, air très doux
entree un gros mot arrive en zoom
feutre un trait barre un mot
pop une bulle ou une pastille apparaît ("f" = hauteur en Hz, 700 à 1100)
clic clic d'interface discret (bouton, étiquette, case)
touche touche de clavier
montee montée d'air avant une révélation
ouverture révélation : souffle clair qui s'ouvre
descente tout retombe
remplissage barre qui se remplit
Usage :
python3 bruitages.py sons.json sortie.wav --duree 30
sons.json : [{"t": 1.2, "type": "souffle", "g": -18, "pan": -0.6, "pan_fin": 0.6, "dur": 0.4}, ...]
t = instant en secondes, g = niveau de crête en dB (−30 discret, −15 fort), pan = gauche (−1) à droite (+1).
Besoin de : numpy et scipy (pip install numpy scipy).
© Will (Will IA, @willll.ia) — skill « animateur-3d ». Usage personnel ou pro ; pas de revente, de republication ni de diffusion sans accord écrit.
"""
import argparse, json, wave
import numpy as np
from scipy.signal import butter, sosfilt
SR = 48000
R = np.random.default_rng(11)
def bp(x, lo, hi, o=2): return sosfilt(butter(o, [lo, min(hi, SR / 2 - 200)], btype="band", fs=SR, output="sos"), x)
def lp(x, f, o=2): return sosfilt(butter(o, f, btype="low", fs=SR, output="sos"), x)
def hp(x, f, o=2): return sosfilt(butter(o, f, btype="high", fs=SR, output="sos"), x)
def glisse(n, f0, f1, f2=None, larg=.9):
"""Bruit dont la fréquence centrale glisse de f0 à f1 (puis f2) : c'est ce qui fait un « whoosh »."""
x = R.standard_normal(n + 4096); N, H = 2048, 256; w = np.hanning(N); out = np.zeros(n + 4096)
fr = np.fft.rfftfreq(N, 1 / SR)
for i in range(0, n, H):
u = i / max(n - 1, 1)
if f2 is None: fc = f0 * (f1 / f0) ** u
else: fc = f0 * (f1 / f0) ** (u / .55) if u < .55 else f1 * (f2 / f1) ** ((u - .55) / .45)
g = np.exp(-.5 * (np.log2(np.maximum(fr, 1) / fc) / larg) ** 2)
out[i:i + N] += np.fft.irfft(np.fft.rfft(x[i:i + N] * w) * g) * w
return out[:n]
def enveloppe(n, montee=.5, forme=2.0):
t = np.linspace(0, 1, n); a = np.where(t < montee, t / montee, (1 - t) / (1 - montee))
return np.clip(a, 0, 1) ** forme
def souffle(dur=.38): n = int(SR * dur); return lp(glisse(n, 350, 2600, 700) * enveloppe(n, .58, 1.6), 9000)
def souffle_lent(dur=1.6): n = int(SR * dur); return lp(glisse(n, 250, 900, 400, larg=1.2) * enveloppe(n, .5, 1.2), 4000)
def entree(dur=.32): n = int(SR * dur); return lp(glisse(n, 2200, 500, larg=.8) * enveloppe(n, .75, 1.5), 8000)
def feutre(dur=.26):
n = int(SR * dur); t = np.arange(n) / SR
grain = 1 + .5 * np.sign(np.sin(2 * np.pi * 38 * t + R.random() * 6))
x = bp(R.standard_normal(n), 1800, 6500, 3) * grain * enveloppe(n, .12, .8) + .35 * bp(R.standard_normal(n), 500, 1400) * enveloppe(n, .1, 1.5)
return lp(x, 9000)
def pop(f=850):
n = int(SR * .12); t = np.arange(n) / SR
fi = f * (1 + .55 * np.exp(-t / .012))
x = np.sin(2 * np.pi * np.cumsum(fi) / SR) * np.exp(-t / .028) + .25 * hp(R.standard_normal(n), 3000) * np.exp(-t / .003)
return x * np.clip(t / .0015, 0, 1)
def clic(f=2400):
n = int(SR * .05); t = np.arange(n) / SR
x = bp(R.standard_normal(n), f * .6, f * 1.8, 2) * np.exp(-t / .004) + .3 * np.sin(2 * np.pi * f * .5 * t) * np.exp(-t / .006)
return x * np.clip(t / .0008, 0, 1)
def touche():
n = int(SR * .09); t = np.arange(n) / SR; k = R.uniform(.85, 1.2)
corps = np.sin(2 * np.pi * 180 * k * t) * np.exp(-t / .018)
clac = bp(R.standard_normal(n), 1500 * k, 4500 * k, 2) * np.exp(-t / .006) * .8
retour = np.zeros(n); i = int(R.uniform(.035, .055) * SR)
retour[i:] = bp(R.standard_normal(n - i), 1200, 3500) * np.exp(-np.arange(n - i) / SR / .004) * .35
return (corps * .7 + clac + retour) * np.clip(t / .0006, 0, 1)
def montee(dur=1.4):
n = int(SR * dur); x = glisse(n, 200, 3500, larg=1.0) * np.linspace(0, 1, n) ** 2.2
x[-int(.03 * SR):] *= np.linspace(1, 0, int(.03 * SR)); return lp(x, 9000)
def ouverture(dur=.9):
n = int(SR * dur); return lp(glisse(n, 3200, 900, larg=1.1) * np.exp(-np.linspace(0, 4, n)) * np.clip(np.arange(n) / (.006 * SR), 0, 1), 10000)
def descente(dur=.7): n = int(SR * dur); return lp(glisse(n, 1800, 180, larg=1.0) * enveloppe(n, .15, 1.3), 5000)
def remplissage(dur=1.8): n = int(SR * dur); return lp(glisse(n, 400, 2000, larg=.7) * enveloppe(n, .85, 1.0), 6000)
AVEC_DUREE = dict(souffle=souffle, souffle_lent=souffle_lent, entree=entree, feutre=feutre, montee=montee,
ouverture=ouverture, descente=descente, remplissage=remplissage)
def fabrique(ev):
ty = ev["type"]
if ty == "pop": return pop(ev.get("f", 850))
if ty == "clic": return clic(ev.get("f", 2400))
if ty == "touche": return touche()
if ty in AVEC_DUREE: return AVEC_DUREE[ty](ev["dur"]) if "dur" in ev else AVEC_DUREE[ty]()
raise ValueError("type inconnu : " + ty)
def piece(st, wet=.07):
"""Une pièce très courte (≈ 0,12 s) : un peu d'air, sans traîne."""
n = int(.12 * SR); t = np.arange(n) / SR; out = st.copy()
for c in range(2):
ir = lp(R.standard_normal(n), 5000) * np.exp(-t / .03); ir[:int(.006 * SR)] = 0; ir /= np.sqrt((ir ** 2).sum())
out[:, c] += wet * np.convolve(st[:, c], ir)[:len(st)]
return out
def main():
ap = argparse.ArgumentParser(); ap.add_argument("sons"); ap.add_argument("sortie"); ap.add_argument("--duree", type=float, default=30)
a = ap.parse_args(); evs = json.load(open(a.sons, encoding="utf-8"))
st = np.zeros((int(SR * a.duree) + SR * 2, 2))
for ev in evs:
x = fabrique(ev); x = x / (np.abs(x).max() + 1e-9) * 10 ** (ev.get("g", -18) / 20)
i = int(ev["t"] * SR); m = min(len(x), len(st) - i)
if m <= 0: continue
p0 = ev.get("pan", 0); p1 = ev.get("pan_fin", p0)
p = np.linspace(p0, p1, m); gl, gd = np.cos((p + 1) * np.pi / 4), np.sin((p + 1) * np.pi / 4)
st[i:i + m, 0] += x[:m] * gl * 1.41; st[i:i + m, 1] += x[:m] * gd * 1.41
st = piece(st)[:int(SR * a.duree)]
pk = np.abs(st).max()
if pk > .9: st *= .9 / pk
with wave.open(a.sortie, "wb") as w:
w.setnchannels(2); w.setsampwidth(2); w.setframerate(SR); w.writeframes((st * 32767).astype(np.int16).tobytes())
print(f"{a.sortie} : {len(evs)} bruitages, {len(evs) / a.duree:.2f} par seconde")
if __name__ == "__main__":
main()
[
{"t": 0.0, "type": "souffle", "dur": 0.8, "g": -20, "pan": 0.4, "pan_fin": 0},
{"t": 0.08, "type": "entree", "g": -20},
{"t": 1.2, "type": "pop", "f": 900, "g": -20},
{"t": 2.2, "type": "souffle_lent", "dur": 1.8, "g": -30},
{"t": 0.5, "type": "touche", "g": -28},
{"t": 0.57, "type": "touche", "g": -29},
{"t": 0.64, "type": "touche", "g": -27},
{"t": 3.0, "type": "remplissage", "dur": 2.0, "g": -27},
{"t": 4.3, "type": "souffle", "dur": 0.4, "g": -19, "pan": -0.6, "pan_fin": 0.6},
{"t": 4.6, "type": "pop", "f": 1000, "g": -20},
{"t": 6.0, "type": "clic", "f": 2200, "g": -25}
]
2. Installe-le sur ton ordinateur
- Ouvre Claude Code. Pour chaque fichier, écris : « Crée le fichier
~/.claude/skills/suivi de son chemin, avec ce texte », puis colle le texte copié. - Ouvre une nouvelle session de Claude Code : le skill est chargé.
- Pour obtenir un fichier MP4, il faut aussi HyperFrames, un outil libre qui a besoin de Node.js. Tout est expliqué dans le guide du skill animateur 3D : page 2 pour le MP4, page 4 pour installer le skill.
Avant d'installer un skill, lis-le : c'est la règle avec tous les skills, y compris le mien.
Sur ordinateur, tu préfères le fichier ?
Décompresse-le et place le dossier animateur-3d dans ~/.claude/skills/.
Et maintenant ?
Essaie le skill
Copie-le plus haut, installe-le, puis ouvre une nouvelle session de Claude Code.
Revoir les étapesBloqué ? Écris-moi
Pose ta question en message privé sur Instagram, ou par mail.
Ton heure offerte
Tu veux faire des vidéos comme ça pour ta marque ? Montre-moi ton idée, je te dis par où commencer.
1 h en visio · offerte · sans engagement
Réserver mon heure offerte30 secondes · sans compte · sans carte
Tu peux aussi m'écrire : par mail ou sur Instagram.