Blender Scripting pour des pipelines d’animation : introduction 2026

L’interface utilisateur graphique de Blender est sans aucun doute impressionnante, mais il y a toujours certaines tâches qui donnent l’impression d’être une corvée : partager des aperçus avec l’équipe, ajuster d’innombrables paramètres dans un nouveau projet, ou refaire les mêmes étapes encore et encore. Parfois, on aimerait juste avoir un bouton qui fait le travail, et le scripting permet justement de l’obtenir !

Dans cet article, nous allons ouvrir les possibilités de la fonctionnalité de scripting de Blender grâce au langage de programmation Python. Vous apprendrez à écrire votre premier script, à l’exécuter, et à comprendre comment les modules de scripting de Blender sont organisés. À la fin, vous aurez une bonne compréhension de la façon de commencer à optimiser votre pipeline de production.

Que puis-je faire avec le scripting ?

Le scripting dans Blender n’est pas seulement une astuce sympa pour les passionnés : c’est une nécessité pour des studios de toutes tailles.

En production, la vitesse et la cohérence sont tout. Les studios font constamment face à des délais serrés, à de grandes bibliothèques d’actifs, et au besoin de garder des dizaines de plans et de scènes parfaitement synchronisés sur plusieurs postes de travail. Le faire manuellement est lent, source d’erreurs et coûteux : c’est pourquoi l’automatisation est si importante !

Le scripting ne consiste pas à écrire du code, mais à vous donner des raccourcis créatifs et des superpouvoirs. Avec Python, vous pouvez automatiser les tâches ennuyeuses et répétitives qui grignotent votre temps, ou générer de la géométrie procédurale, des matériaux, et même des environnements entiers en quelques lignes. Vous pouvez concevoir vos propres outils et menus adaptés à votre workflow, et prendre un contrôle total sur les scènes, les paramètres de rendu, les caméras et les lumières. Le scripting vous permet même de connecter Blender à des outils externes ou à des APIs, faisant de cette approche une partie puissante de pipelines plus larges.

Prérequis

Avant de vous lancer, assurez-vous d’avoir :

• Blender - Téléchargez et installez la dernière version depuis blender.org.
• Python - Vous aurez besoin du langage de programmation Python pour utiliser les modules de scripting natifs de Blender et exécuter des programmes depuis le terminal de votre système d’exploitation.

1. Créer un nouveau script

Dans Blender, ouvrez l’espace de travail Scripting. Vous verrez un panneau d’éditeur de texte où vous pouvez créer un nouveau script en cliquant sur New. C’est ici que vous pouvez écrire votre code Python, et c’est particulièrement utile pour voir les résultats en temps réel :

Pour un pipeline de production, il est généralement plus utile d’exécuter un script depuis l’interface en ligne de commande. Heureusement, Python est désormais livré avec des modules Blender. Dans ce tutoriel, nous allons exécuter un programme Python directement depuis le terminal de l’OS pour éviter les étapes supplémentaires liées à la navigation dans l’interface graphique, donc la première étape consiste à installer le module Blender requis :

pip install bpy==3.6.0 --extra-index-url <https://download.blender.org/pypi/>

Pour tester, créons un nouveau fichier Blender vide en utilisant Python :

import bpy
bpy.ops.wm.save_as_mainfile(filepath="./new_empty_file.blend")

Tout d’abord, nous importons le module d’API Python de Blender bpy, qui nous permet de contrôler presque tout dans Blender (objets, matériaux, rendu, etc.). Ensuite, nous sauvegardons l’espace de travail actuel dans un nouveau fichier.

Nous pouvons exécuter le programme dans le terminal comme ceci :

python3 script.py

Nous pouvons aussi ouvrir le fichier nouvellement créé avec la CLI de Blender :

blender new_empty_file.blend

Félicitations ! Vous avez terminé votre premier script. Passons maintenant à un exemple plus utile : générer du texte 3D.

2. Exemple de texte « Hello World »

Imaginez que vous vouliez créer une animation d’introduction inspirée de Star Wars. Celle, justement, avec un texte qui défile lentement vers le haut en angle :

Comment feriez-vous cela de manière efficace pour que ce soit facile à modifier ? En utilisant un script, bien sûr ! Alors essayons un exemple simple et générons du texte 3D.

Nous créons un nouveau fichier et supprimons tous les objets de la scène pour partir sur une base propre :

import bpy
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete(use_global=False)

• bpy.ops.object.select_all(action='SELECT') : Sélectionne tous les objets présents actuellement dans la scène.
• bpy.ops.object.delete(use_global=False) : Supprime tous les objets sélectionnés.

Deux instructions suffisent pour ajouter un nouvel objet texte à la scène :

bpy.ops.object.text_add(enter_editmode=False, location=(0, 0, 0))
text_obj = bpy.context.object

• bpy.ops.object.text_add(...) : Ajoute un objet Texte à l’emplacement (0, 0, 0) dans le monde 3D (coordonnées XYZ).
• text_obj = bpy.context.object : Stocke une référence vers le nouvel objet texte créé dans la variable text_obj. Chaque fois que vous ajoutez quelque chose de nouveau, Blender en fait l’objet actif, que vous pouvez récupérer via bpy.context.object.

Changeons la chaîne de texte en « Hello World » :

text_obj.data.body = "Hello World"

• text_obj.data fait référence au Text DataBlock, c’est-à-dire le contenu réel ou les paramètres de l’objet texte.
• .body = "Hello World" définit la chaîne affichée sur « Hello World ».

Ensuite, nous pouvons ajuster quelques paramètres de texte pour lui donner un peu d’épaisseur et le centrer sur les axes x et y :

text_obj.data.extrude = 0.05
text_obj.data.align_x = 'CENTER'
text_obj.data.align_y = 'CENTER'

• extrude = 0.05 : Donne de la profondeur au texte, en le faisant passer d’un texte 2D plat à un texte 3D légèrement extrudé.
• align_x = 'CENTER' : Centre horizontalement le texte.
• align_y = 'CENTER' : Centre verticalement le texte.

Vous pouvez trouver davantage d’options en lisant la documentation sur les propriétés de l’objet texte de Blender.

Enfin, nous pouvons faire pivoter le texte pour qu’il soit orienté vers la caméra plutôt que posé à plat au sol, puisque par défaut le texte de Blender est posé à plat sur le plan XY :

text_obj.rotation_euler0 = 1.5708   # 90 degrés en radians

• rotation_euler0 : Fait référence à la rotation autour de l’axe X.
• 1.5708 radians ≈ 90 degrés.

Nous pouvons sauvegarder le résultat en utilisant l’instruction mentionnée précédemment :

bpy.ops.wm.save_as_mainfile(filepath="./text.blend")

Pour résumer, voici à quoi ressemble notre code final :

import bpy
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete(use_global=False)
bpy.ops.object.text_add(enter_editmode=False, location=(0, 0, 0))
text_obj = bpy.context.object
text_obj.data.body = "Hello World"
text_obj.data.extrude = 0.05
text_obj.data.align_x = 'CENTER'
text_obj.data.align_y = 'CENTER'
text_obj.rotation_euler0 = 1.5708
bpy.ops.wm.save_as_mainfile(filepath="./text.blend")

3. Comment exécuter un script (chargement du script)

Comme mentionné précédemment, la syntaxe pour exécuter un script en mode headless est simplement la même que pour n’importe quel programme Python :

python3 text.py

Et c’est tout ! Vous venez d’exécuter votre premier script utile de Blender. Il est super pratique pour l’automatisation, les pipelines ou le traitement par lots.

Ouvrez simplement le fichier text.blend et regardez le résultat :

Vous pouvez aussi ouvrir un fichier .blend spécifique et exécuter le script dans ce contexte :

bpy.ops.wm.open_mainfile(filepath='my_scene.blend')

Celui-ci charge d’abord my_scene.blend, puis exécute le reste du script dessus.

Parfois, vous voulez envoyer des arguments personnalisés :

python3 args.py – --text "CLI Hello"

Dans args.py, vous pouvez accéder à ces arguments comme ceci :

import sys
argv = sys.argv
argv = argvargv.index("--") + 1:  # récupérer les arguments après --
print("Custom args:", argv)

C’est tout pour les bases, mais il vous reste encore beaucoup à découvrir.

4. Modules de scripting expliqués

Blender expose ses fonctionnalités de scripting via différents modules. Comprendre ce que fait chaque module vous aide à définir ce que vous pouvez écrire en script, et comment rechercher la documentation pour le coder.

Tout d’abord, les modules bpy de base :

• bpy.context (Accès au contexte) - Fournit des informations sur l’état actuel de Blender (objet actif, scène, mode, objets sélectionnés, etc.), par exemple bpy.context.object obtient l’objet actif.
• bpy.data (Accès aux données) - Donne un accès direct aux datablocks de Blender tels que les maillages, objets, matériaux et caméras. Exemple : bpy.data.objects"Cube" récupère l’objet Cube.
• bpy.msgbus (Message Bus) - Un système pub/sub pour écouter les changements dans les données de Blender et déclencher des rappels comme l’abonnement à des événements de changement de frame.
• bpy.ops (Opérateurs) - Expose des fonctions qui imitent des actions de l’interface utilisateur comme l’ajout d’objets, la suppression ou le rendu. Exemple : bpy.ops.mesh.primitive_cube_add() ajoute un cube.
• bpy.types (Types) - Définit les classes de base des données de Blender (par ex. Object, Mesh, Material) pour l’extension et la personnalisation, afin de créer des panneaux ou des opérateurs personnalisés.
• bpy.utils (Utilitaires) - Fournit des fonctions d’aide pour l’enregistrement des classes, la gestion des add-ons et l’accès aux chemins système, par exemple bpy.utils.register_class(MyOperator).
• bpy.path (Utilitaires de chemin) - Outils pour gérer les chemins de fichiers, y compris la résolution des chemins relatifs et la création des chemins absolus, par exemple bpy.path.abspath("//textures/wood.png").
• bpy.app (Données d’application) - Fournit des informations sur Blender lui-même comme la version, les détails de build et le mode d’exécution. Exemple : bpy.app.version renvoie (3, 6, 2).
• bpy.props (Définitions de propriétés) - Utilisé pour définir des propriétés personnalisées comme des nombres, des chaînes et des énumérations pour les opérateurs, panneaux ou add-ons, par exemple my_prop: bpy.props.IntProperty(name="My Number").

Ensuite, vous pouvez trouver d’autres bibliothèques plus spécialisées :

• aud (Système audio) - La bibliothèque audio de Blender pour jouer des sons, charger des fichiers et mixer l’audio. Exemple : jouer un fichier .wav directement dans Blender avec Python.
• bgl (Wrapper OpenGL) - Un wrapper OpenGL de bas niveau pour le dessin de viewport 3D personnalisé (remplacé par gpu). Pour dessiner par exemple des surcouches personnalisées.
• bl_math (Fonctions mathématiques supplémentaires) - Des aides mathématiques supplémentaires pour l’interpolation, le calcul de distances et les opérations de géométrie, par exemple pour calculer des distances entre des points.
• blf (Dessin de polices) - Le module de dessin de polices de Blender pour rendre du texte dans les surcouches du viewport ou dans des panneaux, par exemple blf.draw(font_id, "Hello World").
• bmesh (Module BMesh) - Fournit un accès direct de bas niveau au système d’édition de maillage de Blender pour la modélisation procédurale et les opérations de topologie. Exemple : créer ou modifier des sommets et des faces en mode édition.
• bpy_extras (Utilitaires supplémentaires) - Contient des fonctions d’aide comme le support d’import/export, des conversions mathématiques et des utilitaires view3d, par exemple simplifier des conversions de coordonnées.
• freestyle (Module Freestyle) - Contrôle le rendu de lignes Freestyle de Blender pour le rendu d’arêtes non photoréaliste. Exemple : ajuster des styles de ligne ou des règles de visibilité.
• gpu (Module GPU) - Une API moderne de rendu GPU qui permet des shaders personnalisés et des surcouches du viewport (successeur à bgl). Exemple : rendu avec des shaders GLSL personnalisés.
• gpu_extras (Utilitaires GPU) - Fonctions d’aide pour le dessin GPU, simplifiant le rendu de formes sans code GLSL complet, par exemple dessiner un rectangle simple.
• idprop.types (Accès aux propriétés ID) - Fournit un accès structuré aux propriétés d’ID personnalisées de Blender sous forme de dictionnaire/tableau. Par exemple, pour manipuler des métadonnées personnalisées sur les objets.
• imbuf (Tampon d’image) - Gère les tampons d’image, permettant le chargement, la sauvegarde et la manipulation au niveau des pixels, par exemple la génération d’images procédurales.
• mathutils (Types & utilitaires mathématiques) - La bibliothèque de mathématiques de Blender proposant Vector, Matrix, Quaternion et des utilitaires géométriques, par exemple Vector((1,0,0)).cross(Vector((0,1,0))) → (0,0,1).

Conclusion

Le scripting de Blender avec Python est l’une des façons les plus puissantes d’étendre et de personnaliser votre workflow.

Dans cet article, nous avons exploré comment créer et exécuter des scripts, afficher votre tout premier « Hello World » dans le monde 3D, et utiliser le module bpy pour faire faire à Blender exactement ce que vous voulez.

Au premier abord, le scripting peut sembler intimidant, mais comme vous l’avez vu, même quelques lignes peuvent ouvrir la porte à des possibilités totalement nouvelles !

À présent, c’est à vous. Automatisez les tâches ennuyeuses ou créez des outils depuis zéro pour votre pipeline en studio. Vous pouvez le faire !