Animer une caméra à la main dans Blender peut être délicat. Même si vous imaginez un travelling propre et commencez à poser des images-clés une par une, vous finirez toujours, d’une manière ou d’une autre, par obtenir des mouvements saccadés et une timeline difficile à gérer. Ce type de dérive grignote rapidement du temps que vous pourriez utiliser pour autre chose.
C’est là qu’intervient le scripting.
L’API Python de Blender vous donne un contrôle direct sur la position de la caméra, sa rotation, son champ de vision et le mouvement le long d’un chemin. Et comme c’est du code, vous pouvez l’ajuster et le relancer en quelques secondes plutôt que de faire défiler les images-clés en cherchant celle qui est légèrement incorrecte.
Ce guide aborde la partie pratique : ajouter des caméras, définir des types de mouvement, animer le long de splines et suivre un sujet en mouvement. À la fin de cette lecture, vous disposerez d’une petite boîte à outils que vous pourrez réutiliser dans vos projets futurs.
Pourquoi utiliser des mouvements de caméra via script ?
Si vous produisez une visite architecturale, une démonstration de produit ou une séquence de cutscene avec des dizaines de plans similaires, le keyframing manuel de chacun d’eux est fastidieux. Un script peut générer une orbite complète autour d’un objet, une séquence de rack focus, ou un mouvement de grue ample en quelques secondes, tout en le reproduisant exactement à la demande.
Le keyframing manuel introduit aussi des incohérences subtiles : un panoramique qui accélère un peu différemment au deuxième essai, ou un zoom qui dépasse de quelques images. Les scripts imposent une précision mathématique. Chaque prise respecte exactement la courbe d’interpolation (easing) et la vitesse que vous spécifiez.
Pour les studios comme pour les freelances, le temps est de l’argent. Des caméras générées par script réduisent énormément les allers-retours des ajustements manuels. Un réalisateur qui veut une caméra 10 % plus rapide ou 5 degrés plus haut n’a pas besoin de tout refaire en images-clés : il suffit de changer une variable.
Un script est un document vivant : envelopper la logique de votre caméra dans des fonctions paramétrées vous permet d’ajuster le timing, la distance ou l’easing sans détruire le travail existant.
Continuez à lire pour toutes ces raisons, et je vous garantis que vous gagnerez des heures de travail à l’avenir !
1. Ajouter une caméra
Pour commencer, il est important de savoir comment créer et gérer des caméras par programmation avec le module bpy de Blender :
import bpy
def add_camera(name="ScriptedCamera", location=(0, -10, 5)):
bpy.ops.object.camera_add(location=location)
camera = bpy.context.active_object
camera.name = name
return camera
def remove_camera(name):
obj = bpy.data.objects.get(name)
if obj and obj.type == 'CAMERA':
bpy.data.objects.remove(obj, do_unlink=True)
def list_cameras():
return [obj for obj in bpy.data.objects if obj.type == 'CAMERA']
cam = add_camera(name="MainCam", location=(0, -10, 2))
bpy.context.scene.camera = cam
print("Cameras in scene:", [c.name for c in list_cameras()])
La fonction add_camera() utilise l’opérateur bpy.ops.object.camera_add() de Blender pour insérer une nouvelle caméra dans la scène 3D à un endroit (X, Y, Z) donné, en utilisant par défaut (0, -10, 5) dans cet exemple. Après la création, on récupère l’objet nouvellement ajouté via bpy.context.active_object, on lui attribue un nom personnalisé, puis on le renvoie pour que l’appelant puisse s’y référer plus tard.
remove_camera() recherche un objet par son nom dans bpy.data.objects et vérifie que c’en est bien une caméra avant de le supprimer. L’argument do_unlink=True garantit que l’objet est entièrement retiré de la scène et de toutes les collections auxquelles il appartient, et pas seulement masqué.
list_cameras() parcourt tous les objets de la scène Blender courante et renvoie une liste filtrée ne contenant que ceux dont le type est 'CAMERA'. C’est une utilité simple pour obtenir un instantané de toutes les caméras présentes à un moment donné.
Définir bpy.context.scene.camera désigne celle à partir de laquelle Blender rendra l’image. Vous pouvez avoir plusieurs caméras dans une scène et basculer entre elles à des images spécifiques à l’aide de marqueurs : c’est extrêmement utile pour les séquences multi-angles.
Si vous exécutez le script dans l’onglet Scripting, vous pouvez constater qu’il ajoute une seconde caméra dans la vue :
2. Types de mouvements de caméra
Une fois la caméra dans la scène, la prochaine étape consiste à la faire bouger. La plupart des mouvements cinématographiques se ramènent à des transformations simples sur l’objet caméra :
import bpy
import math
def zoom(camera, start_fov=50, end_fov=20, start_frame=1, end_frame=60):
cam_data = camera.data
cam_data.lens = start_fov
cam_data.keyframe_insert(data_path="lens", frame=start_frame)
cam_data.lens = end_fov
cam_data.keyframe_insert(data_path="lens", frame=end_frame)
def pan(camera, start_angle=0, end_angle=45, start_frame=1, end_frame=60):
camera.rotation_euler.z = math.radians(start_angle)
camera.keyframe_insert(data_path="rotation_euler", frame=start_frame)
camera.rotation_euler.z = math.radians(end_angle)
camera.keyframe_insert(data_path="rotation_euler", frame=end_frame)
def tilt(camera, start_angle=0, end_angle=20, start_frame=1, end_frame=60):
camera.rotation_euler.x = math.radians(90 + start_angle)
camera.keyframe_insert(data_path="rotation_euler", frame=start_frame)
camera.rotation_euler.x = math.radians(90 + end_angle)
camera.keyframe_insert(data_path="rotation_euler", frame=end_frame)
def truck(camera, start_x=0, end_x=5, start_frame=1, end_frame=60):
camera.location.x = start_x
camera.keyframe_insert(data_path="location", frame=start_frame)
camera.location.x = end_x
camera.keyframe_insert(data_path="location", frame=end_frame)
cam = bpy.context.scene.camera
zoom(cam, start_fov=50, end_fov=25, start_frame=1, end_frame=90)
pan(cam, start_angle=0, end_angle=30, start_frame=90, end_frame=150)
La fonction zoom anime la focale (longueur focale) d’une caméra sur une plage d’images dans Blender, simulant un effet de zoom optique. Elle règle la valeur de l’objectif sur le champ de vision de départ, insère une image-clé à l’image de début, puis règle l’objectif sur le champ de vision final et insère une deuxième image-clé à l’image de fin.
pan fait pivoter la caméra horizontalement autour de son axe Z entre deux angles. Elle convertit les deux angles de degrés en radians comme Blender l’exige, définit la rotation Z à l’image de départ, puis la règle à l’angle de fin à la dernière image, produisant ainsi un mouvement balayant de gauche à droite.
tilt fonctionne de la même manière que pan, mais agit sur l’axe X pour produire un mouvement vertical de caméra vers le haut ou vers le bas. Les angles sont décalés de 90 degrés avant conversion car l’orientation par défaut de la caméra dans Blender pointe vers le bas le long de X : ainsi, 90° correspond à « regarder tout droit devant » et tout tilt est appliqué par rapport à cette base.
La fonction truck déplace physiquement la caméra vers la gauche ou la droite le long de l’axe X, contrairement à une rotation. Elle pose des images-clés sur la position X de la caméra au début et à la fin, ce qui lui fait glisser latéralement à travers la scène.
Il existe beaucoup d’autres types de mouvements de caméra que nous pourrions couvrir, mais vous avez l’idée.
En exemple, on récupère la caméra de scène active dans le contexte actuel de Blender, puis on enchaîne deux mouvements de caméra l’un après l’autre. D’abord, le script zoome l’objectif de 50 mm à 25 mm entre les images 1–90.
Ensuite, une fois le zoom terminé, on fait un pan de 30 degrés vers la droite entre les images 90–150. Les deux animations partagent l’image 90 comme point de transition, de sorte qu’un mouvement passe proprement au suivant.
Chaque fonction insère des images-clés sur le chemin de données pertinent et Blender interpole automatiquement entre elles. Pour que vos animations paraissent beaucoup plus cinématographiques, vous pouvez définir le mode d’interpolation sur les F-Curves obtenues à BEZIER ou EASE_IN_OUT après avoir keyframé via l’éditeur de courbes (Graph Editor), ou par programmation via fcurve.keyframe_points[i].interpolation.
3. Définir des chemins en spline
Un mouvement en ligne droite ne rend presque jamais bien cinématographiquement non plus. Pour un mouvement de caméra fluide et courbe — comme une trajectoire en arc de grue ou un travelling fly-through — vous aurez peut-être envie que la caméra suive un chemin de spline Bézier ou NURBS. Là encore, le scripting aide beaucoup pour calculer les trajectoires :
import bpy
def create_camera_path(points, camera):
curve_data = bpy.data.curves.new(name="CameraPath", type='CURVE')
curve_data.dimensions = '3D'
curve_data.use_path = True
curve_data.path_duration = bpy.context.scene.frame_end
spline = curve_data.splines.new('BEZIER')
spline.bezier_points.add(len(points) - 1)
for i, pt in enumerate(points):
bp = spline.bezier_points[i]
bp.co = pt
bp.handle_left_type = 'AUTO'
bp.handle_right_type = 'AUTO'
path_obj = bpy.data.objects.new("CameraPath", curve_data)
bpy.context.scene.collection.objects.link(path_obj)
constraint = camera.constraints.new(type='FOLLOW_PATH')
constraint.target = path_obj
constraint.use_curve_follow = True
constraint.offset = 0
constraint.keyframe_insert(data_path="offset", frame=1)
constraint.offset = -100
constraint.keyframe_insert(data_path="offset",
frame=bpy.context.scene.frame_end)
return path_obj
path_points = [
(0, -8, 3),
(-5, -5, 4),
(-7, 0, 3),
(-4, 5, 2),
(0, 7, 2),
]
cam = bpy.context.scene.camera
create_camera_path(path_points, cam)
Dans cet extrait, nous définissons cinq coordonnées 3D qui esquissent un arc courbé, partant derrière et vers la droite, en balayant vers la gauche et l’avant, puis en se stabilisant légèrement devant et au-dessus de l’origine. On récupère la caméra active de la scène et on passe à create_camera_path à la fois la liste de points et la caméra, ce qui déclenche toute la configuration pour que la caméra vole en douceur le long de cet arc sur toute la durée de la scène. create_camera_path construit un chemin d’animation de caméra 3D fluide dans Blender.
Le script commence par créer un nouvel objet courbe nommé « CameraPath », configuré comme une spline Bézier 3D, avec une durée totale calée sur la dernière image de la scène.
Ensuite, on remplit la spline avec les points fournis, en réglant les poignées (handles) de chaque point de contrôle sur AUTO, afin que Blender calcule automatiquement des courbes fluides entre eux. La courbe résultante est emballée dans un objet Blender et liée dans la collection de scène active pour qu’elle soit visible.
Ensuite, on attache une contrainte FOLLOW_PATH à la caméra, en la pointant vers la nouvelle courbe, ce qui force la caméra à la parcourir.
Enfin, le script anime la propriété offset de la contrainte en insérant deux images-clés. Une à l’image 1 avec un offset de 0 (début du chemin) :
Et une à la dernière image de la scène avec un offset de -100 (fin du chemin) :
La contrainte FOLLOW_PATH gère tous les calculs de position. Mettre use_curve_follow à True aligne aussi l’axe avant de la caméra sur la tangente de la courbe, de sorte qu’elle se tourne naturellement dans le sens du déplacement.
Vous pouvez aussi changer les types de poignées de AUTO à VECTOR pour des coins nets, ou à FREE pour un contrôle manuel complet des poignées Bézier.
4. Suivre un sujet
Une caméra qui suit un personnage ou un objet en mouvement est aussi essentielle pour les plans d’action et les dialogues. La contrainte Blender TRACK_TO rend la mise en place très simple via le code :
import bpy
def track_camera_to_subject(camera, subject_name, track_axis='TRACK_NEGATIVE_Z', up_axis='UP_Y'):
subject = bpy.data.objects.get(subject_name)
if subject is None:
print(f"Subject '{subject_name}' not found.")
return
constraint = camera.constraints.new(type='TRACK_TO')
constraint.target = subject
constraint.track_axis = track_axis
constraint.up_axis = up_axis
return constraint
def add_damped_track(camera, subject_name):
subject = bpy.data.objects.get(subject_name)
if subject is None:
return
constraint = camera.constraints.new(type='DAMPED_TRACK')
constraint.target = subject
constraint.track_axis = 'TRACK_NEGATIVE_Z'
return constraint
cam = bpy.context.scene.camera
track_camera_to_subject(cam, "Cube")
track_camera_to_subject recherche un objet Blender par son nom et ajoute une contrainte « Track To » à la caméra donnée, ce qui la fait pointer rigidement vers ce sujet. Elle accepte des paramètres optionnels pour indiquer quel axe la caméra vise et quel axe doit rester « vertical », avec pour défaut l’axe Z négatif pour le tracking et Y pour le haut. Si le sujet nommé n’existe pas dans la scène, elle affiche un avertissement puis sort immédiatement ; sinon, elle configure et renvoie la nouvelle contrainte.
add_damped_track fait quelque chose de similaire, mais utilise une contrainte « Damped Track » à la place, qui produit une rotation plus douce et plus naturelle plutôt qu’une visée strictement verrouillée sur un axe. Elle utilise toujours l’axe Z négatif pour le tracking et renvoie la contrainte en cas de succès.
Le programme récupère la caméra actuellement active dans la scène Blender ouverte, puis appelle track_camera_to_subject pour la faire pointer vers l’objet Cube par défaut en utilisant les axes par défaut.
Comme vous pouvez le voir, lorsque nous déplaçons la caméra, la vue reste centrée sur l’objet Cube. Avant :
Et après avoir déplacé la caméra et/ou le cube :
TRACK_TO fournit un verrou rigide : où que le sujet bouge, la caméra pivote immédiatement pour le viser. Pour un ressenti plus organique, légèrement en retard (courant dans les simulations type épaule-cam et handheld), utilisez plutôt DAMPED_TRACK.
Vous pouvez aussi empiler des contraintes. Par exemple, suivre simultanément un chemin en spline et un sujet pour créer des plans complexes, comme une caméra qui orbite autour d’un personnage tout en le gardant cadré en permanence.
Conclusion
L’API Python de Blender transforme l’animation de caméra, souvent source d’erreurs, en un système précis. Vous avez vu comment ajouter et gérer des caméras par programmation, keyframer des mouvements fondamentaux comme les zooms, les panoramiques, les inclinaisons (tilts) et les « trucks », guider des caméras le long de chemins de spline fluides, et verrouiller la caméra sur des sujets en mouvement grâce à des contraintes de tracking.
La vraie puissance créative se révèle quand vous combinez ces techniques avec l’animation d’objets : placez une caméra sur une contrainte Follow Path associée à un sujet ayant son propre mouvement animé, et vous pouvez script une prise en parallaxe où le premier plan et l’arrière-plan se décalent à des vitesses différentes pour créer de la profondeur. Décalez un zoom avec un dolly dans la direction opposée, et vous obtenez l’effet Hitchcock (dolly zoom), entièrement via le code. Superposez une contrainte Track To sur une trajectoire orbitale, et des plans de grue complexes qui suivent l’action s’animent d’eux-mêmes.
