Automatiser les aperçus d’animation basse résolution dans Blender avec Kitsu (2026)

Attendre des rendus pleine résolution juste pour évaluer un plan ralentit toute la production. Les artistes passent du temps à attendre et les superviseurs voient leurs retours différés. La boucle d’itération est inefficace.

Pour y remédier, nous pouvons créer des aperçus d’animation basse résolution directement dans Blender et les téléverser automatiquement sur Kitsu via Python dans le cadre de notre pipeline d’animation. Ces aperçus se rendent rapidement, sont faciles à examiner et peuvent être utilisés sans délai dans Kitsu pour validation.

C’est un gros avantage, car les rendus pleine résolution peuvent prendre des heures, et les coûts de stockage cloud et de bande passante réseau ne sont pas anodins quand vous gérez des milliers de plans. Passer de 1080p à 480p peut diviser la taille jusqu’à 5× !

Dans ce tutoriel, nous allons voir comment :

• Configurer les réglages de rendu Blender pour des aperçus basse résolution
• Automatiser le processus de rendu avec Python
• Utiliser ffmpeg pour ajouter un filigrane et un horodatage à la vidéo afin de la contextualiser rapidement
• Exporter les vidéos et les téléverser sur Kitsu

À la fin, vous disposerez d’un script qui fait gagner du temps sur les revues de plans sans sacrifier la qualité des retours.

1. Configuration simple de la scène Blender

Avant de pouvoir créer un aperçu animé, nous avons besoin d’un objet de départ dans la scène. Pour ce tutoriel, nous utiliserons le cube par défaut de Blender.

D’abord, nous créons une référence de la scène et du cube :

import bpy
cube = bpy.data.objects"Cube"
scene = bpy.context.scene

2. Ajouter des keyframes pour l’animation

La prochaine étape consiste à animer notre cube. Pour des aperçus rapides de modélisation, des séquences courtes sont idéales. Ici, nous allons créer une rotation de 360° sur 48 frames (2 secondes à 24 FPS) :

for frame, angle in (1, 0), (12, 1.57), (24, 3.14), (36, 4.71), (48, 6.28):
    scene.frame_set(frame)
    cube.rotation_euler2 = angle
    cube.keyframe_insert(data_path="rotation_euler", index=2)

Cette boucle place des keyframes à intervalles réguliers, en faisant tourner le cube en douceur autour de son axe Z par incréments de pi/2. Utiliser un nombre limité de frames permet de garder le rendu rapide et rend le résultat parfait pour un usage d’aperçu.

À ce stade, vous pouvez parcourir la timeline dans Blender pour vérifier que le cube tourne comme prévu.

3. Rendu basse résolution

Une fois l’animation en place, nous pouvons configurer Blender pour rendre un aperçu rapide en basse résolution. L’objectif est la vitesse plutôt que la qualité : nous voulons quelque chose d’assez clair pour être évalué, mais rapide à produire.

Ici, nous utilisons le moteur de rendu Eevee pour gagner en vitesse et réduire la surcharge de rendu inutile. Il est beaucoup plus rapide que Cycles, car c’est un moteur de rasterisation simple, et dans 90 % des cas, nous n’avons pas besoin d’un rendu hyper réaliste.

scene.render.engine = "BLENDER_EEVEE"
scene.render.resolution_x = 1920
scene.render.resolution_y = 1080
scene.render.resolution_percentage = 50
scene.render.fps = 24
scene.frame_start = 1
scene.frame_end = 48  # match your animation length
scene.render.image_settings.file_format = "FFMPEG"
scene.render.ffmpeg.format = "MPEG4"
scene.render.ffmpeg.codec = "H264"
scene.render.filepath = "//preview.mp4"

Bien que nous partions d’une résolution classique en paysage, réduire resolution_percentage ou désactiver l’échantillonnage de haute qualité dans Eevee peut diminuer drastiquement les temps de rendu pour les aperçus.

Le reste des réglages est assez standard : 24 images par seconde, 48 frames au total, et une vidéo de sortie en mp4 avec encodage H264 (pour une compression plus rapide) écrite dans le dossier courant du script.

Selon votre cas d’usage, vous pouvez réduire la résolution, diminuer le taux de rafraîchissement et abaisser le débit (bitrate) pour réduire la taille de vos aperçus. Il faut toutefois garder une qualité suffisante pour le processus de revue, donc ajustez les réglages pour obtenir un équilibre optimal avec les performances.

Enfin, nous pouvons lancer le rendu en une seule ligne :

bpy.ops.render.render(animation=True)

La vidéo d’aperçu peut être utilisée immédiatement pour la revue, ou traitée davantage avec des outils comme FFmpeg pour les horodatages, les filigranes ou des conventions de nommage personnalisées avant téléversement sur Kitsu.

4. Traitement avec FFmpeg : horodatage, nommage, filigrane

Une fois que Blender a rendu votre animation dans un fichier vidéo, vous pouvez la traiter davantage avec FFmpeg. C’est une étape courante dans les pipelines de production pour ajouter des horodatages, des filigranes ou un nommage personnalisé, afin de préparer les aperçus pour la revue.

Lancez la commande suivante dans un terminal après avoir rendu votre aperçu :

ffmpeg -framerate 24 \\
  -i preview.mp4 \\
  -i watermark.png \\
  -filter_complex "\\
    0:vdrawtext=text='%{pts\\:hms}':x=10:y=10:fontsize=24:fontcolor=white:bordercolor=black:borderw=2v1; \\
    [v1]1:voverlay=W-w-20:H-h-20" \\
  -c:v libx264 -crf 22 -pix_fmt yuv420p \\
  preview_with_stamp.mp4

• drawtext superpose un horodatage en cours dans le coin supérieur gauche.
• overlay place une image de filigrane (watermark.png) dans le coin inférieur droit.
• c:v libx264 -crf 22 -pix_fmt yuv420p garantit une bonne qualité et une compatibilité étendue pour la lecture vidéo.
• Le fichier de sortie, preview_with_stamp.mp4, est votre aperçu finalisé prêt pour la revue.

Bien sûr, vous pouvez ajuster la taille de la police, la position ou le placement du filigrane selon vos besoins pour standardiser les aperçus pour vos revues d’équipe ou clients.

Cette étape termine la préparation d’un aperçu d’animation basse résolution prêt pour la production. Le fichier est maintenant prêt à être téléversé sur Kitsu pour un retour rapide.

5. Téléverser sur Kitsu via Gazu

Une fois votre aperçu basse résolution prêt, vous pouvez le téléverser directement sur Kitsu via le tableau de bord ou utiliser le SDK Python gazu. Kitsu est un outil collaboratif de suivi de pipeline qui permet aux artistes et aux superviseurs d’accéder à l’aperçu immédiatement pour la revue.

Le script Python suivant fournit une CLI interactive simple qui vous permet de choisir le projet et la tâche vers lesquels téléverser votre aperçu :

import gazu
def pickProject(label, list_of_items):
    """Helper UI to pick one item from a list."""
    for i, item in enumerate(list_of_items):
        print(f"{i + 1}. {item'name'}")
    idx = int(input(f"Choose {label} number: ")) - 1
    return list_of_itemsidx
def pickTask(label, list_of_items):
    """Helper UI to pick one item from a list."""
    for i, item in enumerate(list_of_items):
        asset = gazu.entity.get_entity(item"entity_id")
        status = gazu.task.get_task_status(item"task_status_id")
        type = gazu.task.get_task_type(item"task_type_id")
        print(f"{i + 1}. {asset'name'} {type'name'} {status'name'}")
    idx = int(input(f"Choose {label} number: ")) - 1
    return list_of_itemsidx
gazu.set_host("<http://localhost/api>")
user = gazu.log_in("admin@example.com", "mysecretpassword")
projects = gazu.project.all_projects()
project = pickProject("project", projects)
tasks = gazu.task.all_tasks_for_project(project)
task = pickTask("task", tasks)
print("Uploading preview...")
task_status = gazu.task.get_task_status_by_name("todo")
result = gazu.task.publish_preview(
    task,
    task_status,
    comment="Auto-generated preview",
    preview_file_path="./preview.mp4",
)
print("Done:", result)

D’abord, nous nous connectons à Kitsu via gazu avec vos identifiants. Nous utilisons le mode d’installation pour le développement local via Kitsu Docker. Le programme vous permet de sélectionner le projet et la tâche parmi les options disponibles à l’aide de différents endpoints de l’API Kitsu afin d’obtenir toutes vos données de production :

Ensuite, nous téléversons la vidéo d’aperçu générée des étapes précédentes vers la tâche sélectionnée.

Une fois terminé, l’aperçu est disponible dans l’interface de revue de Kitsu, ce qui permet aux membres de l’équipe et aux superviseurs de donner leur avis sans attendre des rendus pleine résolution.

Moteur de revue parfait pour annoter rapidement les images et ajouter des commentaires sur des plans précis :

6. Tout assembler

Pour automatiser la tâche de bout en bout, écrivons une commande bash rapide :

preview.sh

python3 render.py && ./watermark.sh && python3 upload.py

Ensuite, nous pouvons exécuter le script chaque fois que nous devons partager un aperçu :

./preview.sh

Jetez un œil à notre dépôt Github blender-kitsu-low-res-preview pour tester le résultat final par vous-même.

7. Aperçu de l’addon pensé pour les artistes

Bien que cela sorte du cadre de cet article, il pourrait être simple d’envelopper notre code dans un addon Blender afin que les artistes puissent l’utiliser facilement.

Vous auriez besoin d’un panneau principal pour contenir des menus déroulants afin de choisir une production, un asset et une tâche à téléverser. Et d’un bouton à cliquer pour téléverser. La logique de téléversement prendrait en charge le rendu, l’appel à ffmpeg en tant que sous-processus pour le filigrane, et l’envoi des fichiers temporaires vers Kitsu.

Consultez notre article sur le développement d’interface pour un add-on Blender pour plus d’informations.

Conclusion

D’ici là, vous aurez mis en place un pipeline complet : créer un objet 3D simple dans Blender, l’animer, générer un aperçu basse résolution, ajouter des horodatages et des filigranes, puis le téléverser sur Kitsu. Les bénéfices sont immédiats :

• Des revues plus rapides - Les superviseurs et les membres de l’équipe peuvent regarder les aperçus immédiatement sans attendre des rendus pleine résolution.
• Des itérations plus rapides - Les artistes reçoivent des retours plus tôt, ce qui raccourcit la boucle d’itération et réduit les goulots d’étranglement.
• Moins de blocages - Les aperçus et téléversements automatisés éliminent les étapes manuelles répétitives du pipeline pour garantir des livrables cohérents.

Ce qui prenait autrefois une heure de travail manuel peut désormais être géré avec quelques scripts, offrant à l’équipe plus de temps pour se concentrer sur le côté créatif de la production plutôt que sur des tâches répétitives.

Vous pouvez aller encore plus loin avec ce workflow selon les besoins de votre studio d’animation : ajouter des boutons ou des panneaux dans Blender pour exécuter l’intégralité du pipeline en un clic, générer automatiquement des aperçus par lot pour plusieurs plans ou scènes dans un seul script, etc.