Comment rendre plusieurs caméras dans Blender 4.x

Pourquoi rendre plusieurs caméras à la fois ?

Dans les flux de travail professionnels, vous avez souvent besoin de rendus depuis plusieurs angles de caméra — des parcours architecturaux avec 5+ points de vue, des visualisations de produits avec vues de face/côté/dessus, ou des plans VFX avec caméras verrouillées et angles alternatifs. Le rendu de chaque caméra individuellement est fastidieux et chronophage. Blender 4.x offre plusieurs méthodes pour rendre plusieurs caméras en un seul batch, économisant du temps et permettant des soumissions efficaces aux fermes.

Nous gérons des fermes de rendu avec des centaines de travaux multi-caméra quotidiens. Les techniques dans ce guide sont optimisées pour la vitesse et sont nativement supportées par les fermes de rendu cloud comme Super Renders Farm. Que vous travailliez localement ou que vous soumettiez à la ferme, ces approches rationaliseront votre flux de travail multi-caméra.

Méthode 1 : Rendu Multi-Caméra Basé sur les Scènes

La méthode la plus simple et la plus conviviale pour la ferme est de créer des scènes séparées pour chaque caméra. Chaque scène partage la même géométrie et les mêmes matériaux mais a une caméra active différente. Vous rendez alors toutes les scènes en séquence à l'aide d'un script Python.

Configuration :

1. Dans votre scène principale (par exemple, Scene), configurez toutes vos caméras. Positionnez-les où vous avez besoin d'angles.
2. Dans le coin supérieur droit de la fenêtre, trouvez le sélecteur Scene (liste déroulante affichant « Scene »).
3. Cliquez sur le + à côté pour créer une nouvelle scène.
4. Sélectionnez Link Objects quand vous y êtes invité (ceci copie les références d'objets, pas les objets eux-mêmes — les modifications s'appliquent à toutes les scènes).
5. Répétez pour chaque caméra (si vous avez 5 caméras, créez 5 scènes : Scene, Scene.001, Scene.002, etc.).
6. Dans chaque nouvelle scène, allez à Scene Properties > Camera et réglez-la sur la caméra correspondante de votre scène principale.

Exemple :

• Scene : Caméra active = Camera_Front
• Scene.001 : Caméra active = Camera_Side
• Scene.002 : Caméra active = Camera_Top
• Scene.003 : Caméra active = Camera_Iso

Puisque toutes les scènes partagent les mêmes objets, les modifications apportées aux matériaux ou à la géométrie s'appliquent partout. Seule la caméra active diffère.

Rendu de Toutes les Scènes :

Vous pouvez rendre toutes les scènes séquentiellement via la console Python :

import bpy

scenes = bpy.data.scenes
output_folder = "/path/to/output/"

for scene in scenes:
    bpy.context.window.scene = scene
    bpy.context.scene.render.filepath = f"{output_folder}{scene.name}_render.png"
    bpy.ops.render.render(write_still=True)
    print(f"Rendered {scene.name}")

Remplacez /path/to/output/ par votre répertoire de sortie réel. Ce script itère à travers toutes les scènes, définit chacune comme active et la rend dans un fichier nommé de manière unique.

Pour la Ferme :

Lors de la soumission à Super Renders Farm, incluez ce script Python et spécifiez-le comme script de pré-rendu. La ferme l'exécutera automatiquement, rendant toutes les scènes sans intervention manuelle.

Méthode 2 : Liaison de Caméra Basée sur les Marqueurs

Pour les flux de travail plus complexes, utilisez les marqueurs de caméra pour lier des caméras spécifiques aux images ou aux passes de rendu. Cette méthode est utile si vous souhaitez des caméras différentes pour des plages d'images différentes.

Configuration :

1. Dans l'éditeur Timeline, clic droit sur une image et sélectionnez Add Marker.
2. Nommez le marqueur de manière descriptive (par exemple, Camera_Wide_Start).
3. Créez des marqueurs supplémentaires aux numéros d'image clés (par exemple, Camera_Close_Start à l'image 100).
4. Pour chaque marqueur, ouvrez les Marker Properties et associez-y une caméra.

La liaison basée sur les marqueurs est plus complexe que la méthode basée sur les scènes et est généralement utilisée pour les graphiques animés ou les séquences animées où les changements de caméra se produisent à des images spécifiques.

Script Python pour la Liaison de Marqueur :

import bpy

def render_with_markers():
    scene = bpy.context.scene
    markers = scene.timeline_markers
    output_folder = "/path/to/output/"
    
    for i, marker in enumerate(markers):
        if hasattr(marker, 'camera'):
            scene.camera = marker.camera
            frame_start = marker.frame
            frame_end = markers[i + 1].frame if i + 1 < len(markers) else scene.frame_end
            
            for frame in range(frame_start, frame_end):
                scene.frame_set(frame)
                scene.render.filepath = f"{output_folder}frame_{frame:04d}.png"
                bpy.ops.render.render(write_still=True)
                print(f"Rendered frame {frame} with {scene.camera.name}")

render_with_markers()

Cette approche est moins commune pour les rendus d'image unique et plus utile pour les séquences animées. Pour la plupart des travaux multi-caméra, la Méthode 1 (scènes) est plus simple.

Méthode 3 : Rendu par Batch avec Script Python

Pour un contrôle maximal, écrivez un script Python qui définit explicitement les caméras, les chemins de sortie et les paramètres de rendu pour chaque caméra.

Script d'Exemple :

import bpy
import os

output_base = "/path/to/output"
cameras_config = [
    {"name": "Camera_Front", "file": "front_view.png"},
    {"name": "Camera_Side", "file": "side_view.png"},
    {"name": "Camera_Top", "file": "top_view.png"},
    {"name": "Camera_Iso", "file": "isometric_view.png"},
]

scene = bpy.context.scene

for cam_config in cameras_config:
    camera_name = cam_config["name"]
    output_file = os.path.join(output_base, cam_config["file"])
    
    scene.camera = bpy.data.objects[camera_name]
    scene.render.filepath = output_file
    scene.render.image_settings.file_format = 'PNG'
    scene.render.image_settings.compression = 90
    
    bpy.ops.render.render(write_still=True)
    print(f"Rendered {camera_name} -> {output_file}")

print("All cameras rendered successfully!")

Ce script est explicite et facile à modifier. Vous pouvez ajuster les paramètres de rendu par caméra (résolution, échantillons, paramètres de débruiteur) en ajoutant la configuration à chaque entrée de caméra.

Avancé : Paramètres Par-Caméra :

cameras_config = [
    {
        "name": "Camera_Front",
        "file": "front_view.png",
        "samples": 256,
        "denoiser": True,
        "resolution": (1920, 1080)
    },
    {
        "name": "Camera_Close",
        "file": "close_view.png",
        "samples": 512,
        "denoiser": True,
        "resolution": (4096, 2304)
    },
]

for cam_config in cameras_config:
    scene.camera = bpy.data.objects[cam_config["name"]]
    scene.render.filepath = os.path.join(output_base, cam_config["file"])
    scene.render.resolution_x = cam_config["resolution"][0]
    scene.render.resolution_y = cam_config["resolution"][1]
    scene.cycles.samples = cam_config["samples"]
    scene.cycles.use_denoising = cam_config["denoiser"]
    
    bpy.ops.render.render(write_still=True)

Cela permet à chaque caméra de rendre à des résolutions ou des nombres d'échantillons différents, utile pour optimiser les temps de rendu sur plusieurs angles.

Méthode 4 : Configuration des Nœuds du Compositeur pour Sortie Multi-Caméra

Pour des pipelines plus sophistiqués, utilisez le Compositeur pour combiner ou basculer entre les caméras dans une seule passe de rendu.

Configuration :

1. Ouvrez l'éditeur Compositor (Shift+F11 ou Window > Toggle Compositor).
2. Activez Use Nodes (case à cocher en haut à droite).
3. Dans le compositeur, ajoutez un nœud Cryptomatte ou ID Mask pour isoler les rendus par caméra.
4. Alternativement, utilisez les Switch Nodes avec des pilotes de numéro d'image pour basculer automatiquement entre les sorties de caméra pré-rendues.

Exemple : Compositeur Switch pour Séquence Multi-Caméra :

1. Rendez chaque caméra individuellement dans une séquence d'images.
2. Importez chaque séquence dans le compositeur en tant que nœuds Image Sequence.
3. Utilisez un nœud Switch ou Mix avec un pilote numéro d'image pour sélectionner les images de caméra à produire en fonction de l'image actuelle.
4. Cela permet à une tâche de composition unique de produire différentes caméras à différentes plages d'images sans re-rendu.

La méthode du compositeur est avancée et généralement utilisée pour le travail d'effets ou lors de la combinaison de plusieurs rendus dans une seule sortie. Pour les stills ou séquences multi-caméra simples, les Méthodes 1–3 sont plus pratiques.

Méthode 5 : Soumission en Batch de Ferme avec Plusieurs Caméras

Lors de la soumission à Super Renders Farm, tirez parti des capacités multi-rendu de la ferme pour rendre toutes les caméras en parallèle.

Préparation :

1. Assurez-vous que chaque scène a un nom unique et descriptif (par exemple, Front_View, Side_View).
2. Vérifiez que chaque scène a la bonne caméra active définie.
3. Exportez votre fichier Blender.

Soumission :

1. Téléchargez votre fichier .blend vers le portail de soumission de la ferme.
2. Dans les Render Settings, sélectionnez Render All Scenes (ou option équivalente).
3. Spécifiez le format de sortie et le répertoire.
4. Définissez le nombre de nœuds de rendu. La ferme distribue les scènes sur les nœuds disponibles, rendant plusieurs caméras en parallèle.

Exemple de Soumission de Ferme :

• Scene 1 → Node 1 (Camera Front) → Output : front_view_001.png
• Scene 2 → Node 2 (Camera Side) → Output : side_view_001.png
• Scene 3 → Node 3 (Camera Top) → Output : top_view_001.png

Si vous avez 10 scènes et que la ferme dispose de 10+ nœuds disponibles, toutes les caméras se rendent simultanément. C'est beaucoup plus rapide que le rendu local séquentiel.

Flux de Travail Recommandés pour Rendu Multi-Caméra

Utilisez un Nommage de Fichier Cohérent :

Les sorties de rendu doivent être clairement étiquetées :

project_name_camera_front_001.exr
project_name_camera_side_001.exr
project_name_camera_top_001.exr

Organisez les Scènes Logiquement :

Nommez les scènes après les angles de caméra : Front_View, Side_View, Top_View, Isometric, Detail_Close. Évitez les noms génériques comme Scene.001 ou RenderScene_v2.

Optimisez la Résolution par Caméra :

Lors du rendu à une ferme, vous pouvez rendre chaque caméra à des résolutions différentes. Les plans larges pourraient être 1920×1080, tandis que les plans de détail sont 4096×2304.

Utilisez Cryptomatte ou AOVs pour Compositing Flexible :

Rendez les passes Cryptomatte aux côtés de votre rendu de beauté. Cela vous permet d'isoler les objets par ID en post-production sans re-rendu.

FAQ

Le rendu de plusieurs caméras augmentera-t-il considérablement mon temps de rendu ?

Non, si vous soumettez à une ferme avec des nœuds parallèles. Si vous rendez localement séquentiellement, oui — cela prend à peu près N fois plus longtemps pour N caméras. La ferme atténue cela en distribuant les scènes sur les nœuds.

Puis-je rendre plusieurs caméras à différentes plages d'images ?

Oui, en utilisant la liaison basée sur les marqueurs (Méthode 2) ou le compositeur. Par exemple, les images 1–50 se rendent à partir de Caméra A, les images 51–100 à partir de Caméra B.

Toutes les scènes doivent-elles partager les mêmes matériaux et objets ?

Pour la méthode basée sur les scènes, oui. Utilisez « Link Objects » lors de la création de scènes pour partager la géométrie et les matériaux.

Quel format de sortie dois-je utiliser pour les rendus multi-caméra ?

Utilisez EXR pour le travail professionnel (préserve la profondeur de couleur et les AOVs) ou PNG pour le web/aperçu.

Puis-je rendre plusieurs caméras avec flou de mouvement ou profondeur de champ ?

Oui. Le flou de mouvement s'applique par rendu, donc chaque rendu de caméra inclut son propre flou de mouvement s'il est activé. La profondeur de champ est spécifique à la caméra.

Comment gérer les animations de caméra (caméra mobile) sur plusieurs caméras ?

Si les caméras sont animées, chaque scène rendra son animation de caméra respective. Les autres scènes rendent leurs propres animations de caméra indépendamment.

Articles Connexes

Pour plus d'informations sur l'optimisation du rendu Blender, consultez notre guide complet sur la configuration de la ferme de rendu cloud. Nous traitons également des solutions de rendu dans notre guide des problèmes de rendu courants.

Pour la soumission cloud, explorez notre guide de la ferme de rendu cloud Blender pour en savoir plus sur les fonctionnalités supportées, le rendu par batch sur Super Renders Farm et les conseils d'optimisation.

Ressources Supplémentaires

• Documentation de l'API Python Blender 4.x
• Documentation du Rendu Blender
• Manuel des Nœuds du Compositeur Blender