Luan-vP/fire-sprites

Vidéo de performance de feu en sprites

Vous guidez un artiste depuis une vidéo brute jusqu'à des feuilles de sprites qu'il pourra utiliser dans un jeu. Il connaît sa performance ; vous exécutez les outils. Impliquez-le aux deux endroits où son jugement compte (quels mouvements, et où chaque mouvement commence et se termine) et faites tout le reste vous-même.

Les outils se trouvent dans le dossier tools/ de ce kit (deux niveaux au-dessus de ce fichier). Appelez-le $KIT. Chaque outil s'exécute dans un répertoire projet que vous créez pour cet artiste ; les vidéos sources sont référencées, jamais copiées.

Lisez references/how-it-works.md une fois avant de commencer. Il explique les trois idées sur lesquelles repose tout le pipeline : couches corps et feu séparées, gestion de l'exposition, et normalisation ancrée sur les pieds.

0. Configuration (une fois par machine)

cd $KIT && python3 -m venv .venv && .venv/bin/pip install -r requirements.txt

Utilisez une compilation Python native pour la machine (sur Apple Silicon, un Python x86 installe silencieusement un PyTorch ancien et uniquement CPU). ffmpeg et ffprobe doivent être dans le PATH. Un GPU (Apple MPS ou CUDA) est fortement recommandé : le rendu coûte environ 3 s par image de sortie sur un M2 Max. Les poids du modèle se téléchargent lors de la première utilisation.

Ci-dessous, py signifie $KIT/.venv/bin/python et les commandes s'exécutent depuis le répertoire projet.

1. Demander les bonnes images

Demandez à l'artiste les fichiers originaux de la caméra, pas un export édité ou pour les réseaux sociaux. Regardez dans le dossier qu'il vous indique : un original 4K, 10 bits, 50 ips se trouve souvent à côté d'un final cut 720p, et tout ce qui suit en est meilleur. Demandez aussi s'il existe des images de lui marchant ou debout avant que le feu ne soit allumé : les routines de feu contiennent rarement un cycle de marche propre, et les jeux en ont besoin.

mkdir -p ~/sprite-projects/NOM && cd ~/sprite-projects/NOM
py $KIT/tools/ingest.py main "/chemin/vers/original.mov"      # répétez avec d'autres noms pour d'autres clips

Lisez ce que ingest imprime. Il mesure le niveau de noir réel (les balises de plage de fichier ne sont pas fiables) et avertit en cas de sources 8 bits, basse résolution et fréquence d'images variable. La fréquence d'images variable doit d'abord être corrigée (ré-encodage en fréquence d'images constante), sinon les numéros d'image dérivent entre la proxy et la source.

2. Trouver les images utilisables

py $KIT/tools/pose_pass.py main                             # lent : environ 15 images proxy par seconde
py $KIT/tools/find_segments.py main --strips                # ajoutez --performer skin si une foule habillée est dans le champ
py $KIT/tools/find_bursts.py main                           # bouffées de feu, détectées par luminosité

• find_segments conserve les séquences où tout le corps est dans le cadre et debout. Attendez-vous à ce qu'une fraction des images soit qualifiée : les caméras portatives coupent constamment les pieds. C'est normal ; dites le nombre à l'artiste.
• Regardez vous-même quelques strips/*.jpg. Si elles suivent la mauvaise personne, passez en mode --performer.
• Regardez bursts/main.jpg. Conservez uniquement les vraies bouffées de feu, puis py $KIT/tools/catalog.py add-bursts main (et supprimez les entrées erronées de catalog/selected.json). Les bouffées de feu sont trouvées de cette manière car la recherche basée sur la pose rejette les images surexposées.

3. Cataloguer les mouvements (utiliser des sous-agents)

py $KIT/tools/catalog.py batches 5

Confiez chaque lot à un sous-agent en utilisant le prompt dans references/catalog-prompt.md (remplissez le numéro de lot et décrivez l'artiste en une ligne pour que les réviseurs puissent rejeter la mauvaise personne). Ils lisent les filmstrips numérotés par image et écrivent catalog/outK.json. C'est l'étape qui bénéficie le plus des agents en parallèle : c'est purement visuel, et chaque lot est indépendant. Ensuite :

py $KIT/tools/catalog.py select            # shortlist : qualité >= 4, plus marches/tours/tours/attaques à 3
py $KIT/tools/catalog.py list

Dites clairement à l'artiste ce qui a été trouvé et ce qui ne l'a pas été (par exemple : "13 idles, 8 tours, mais une seule vraie marche, à partir du clip avant que le feu ne soit allumé").

4. L'artiste rogne et choisit

py $KIT/tools/make_trim.py                 # un clip contextuel par mouvement + trim.html
open trim.html

Les plages des réviseurs sont délibérément serrées ; les vrais mouvements ont besoin de respirer dans ce qui précède et suit. Dans trim.html, l'artiste fait glisser le début et la fin de chaque mouvement sur quelques secondes d'images environnantes, marque Garder ou Supprimer, et copie la liste depuis la boîte en bas. Demandez-lui de vous la coller. La page stocke son état dans son navigateur, vous ne pouvez donc pas la lire vous-même. Sauvegardez le texte collé dans un fichier et :

py $KIT/tools/catalog.py apply-trim gardes.txt

5. Rendu, packaging, révision

py $KIT/tools/render_move.py --gardes        # longue durée : exécutez-la en arrière-plan
py $KIT/tools/pack.py --gardes
open review.html

Avant de faire votre rapport, regardez vous-même plusieurs fichiers moves/NOM/preview.jpg. Choses à vérifier et à dire à voix haute :

• une autre personne fusionnée dans le découpage (mettez "gate": true sur ce mouvement dans catalog/selected.json si le mouvement n'a pas d'accessoire, puis re-rendu avec --force);
• mur éclairé par le feu apparaissant dans la couche feu ;
• pieds ou tête coupés : render_move imprime la proportion de chaque plage avec tout le corps dans le champ. Les rognages étendus tombent souvent sur des images où l'artiste quitte le cadre.

review.html joue chaque mouvement avec des commutateurs d'arrière-plan et de couche, y compris "corps + lueur de feu additive", ce qui est la façon dont un jeu devrait le dessiner. atlas.json contient la grille d'images, les ips, l'ancrage des pieds et la plage source par mouvement.

6. Optionnel : rendu 8 bits

S'il souhaite une version rétro, utilisez le skill fire-sprites-retro.

Règles d'honnêteté pour ce travail

• Signalez les comptes et les limites, pas seulement les succès : combien de secondes étaient utilisables, quels mouvements ont des membres coupés, quelles couches de feu incluent le mur.
• Les images imposent des limites strictes. Un nuage de feu qui sort du cadre de la caméra a un bord droit ; une flamme surexposée n'a pas de texture interne à récupérer. Dites-le au lieu de promettre une correction.
• Ne mettez jamais les images, le nom ou les sprites rendus de l'artiste dans un espace public. Les sorties restent dans le répertoire projet sauf s'il demande autrement.

Voir references/troubleshooting.md pour les problèmes rencontrés en pratique et ce qui les a résolus.