Pingwink/skill

Automatisation Blender 5.2, Optimisation Cycles et Flux Vidéo

Ce guide (skill) contient des procédures éprouvées, des configurations d'optimisation et des modèles de code développés lors de la modélisation, de l'animation et du rendu de scènes dans Blender 5.2.

---

1. Architecture de communication et de rendu

A. Contrôle de session interactive (Socket IPC)

Pour la modélisation interactive, la modification des matériaux et les images de test, utilisez un client socket :

• Port : 127.0.0.1:9876 (plugin Blender MCP / socket bridge)
• Protocole : JSON terminé par un octet null \0 ({"type": "execute", "code": "...", "strict_json": true})

B. Rendu d'animations en arrière-plan (CLI headless)

Règle : Ne rendez pas les longues animations via le socket (risque de blocage de l'interface ou de timeout). Enregistrez la scène dans un fichier .blend et lancez un processus CLI dédié en arrière-plan :

& "C:\Program Files\Blender Foundation\Blender 5.2\blender.exe" -b "chemin\vers\projet.blend" -s 1 -e 108 -a

• Avantages : Rendu 15 à 20 % plus rapide (pas de surcharge OpenGL/viewport), streaming de la progression image par image dans stdout, pas de blocage de l'interface.

---

2. Changements clés de l'API dans Blender 5.2+

A. Export vidéo vers FFMPEG / MP4

Dans Blender 5.2, l'affectation de file_format = 'FFMPEG' directement aux paramètres par défaut génère une erreur TypeError. Il faut d'abord définir media_type :

import bpy

scene = bpy.context.scene
ims = scene.render.image_settings

# 1. Requis dans Blender 5.2 avant le choix du format vidéo :
ims.media_type = 'VIDEO'
ims.file_format = 'FFMPEG'

# 2. Configuration du conteneur et du codec :
scene.render.ffmpeg.format = 'MPEG4'
scene.render.ffmpeg.codec = 'H264'
scene.render.ffmpeg.constant_rate_factor = 'HIGH'
scene.render.ffmpeg.ffmpeg_preset = 'REALTIME' # Options : 'BEST', 'GOOD', 'REALTIME'

B. Compositeur (Compositing Node Group)

Blender 5.2 introduit compositing_node_group à la place de l'ancien scene.node_tree et NodeGroupOutput à la place de CompositorNodeComposite :

scene = bpy.context.scene
scene.use_nodes = True

ng = scene.compositing_node_group
if not ng:
    ng = bpy.data.node_groups.new(name="Compositing", type='CompositorNodeTree')
    scene.compositing_node_group = ng

# Création des entrées/sorties
rl = ng.nodes.new('CompositorNodeRLayers')
glare = ng.nodes.new('CompositorNodeGlare')
out = ng.nodes.new('NodeGroupOutput')

# Dans Blender 5.2, les paramètres Glare sont des sockets, pas des propriétés d'objet :
glare.inputs['Type'].default_value = 'Fog Glow'
glare.inputs['Threshold'].default_value = 0.55
glare.inputs['Size'].default_value = 7.0
glare.inputs['Strength'].default_value = 0.8

---

3. Optimisation extrême de Cycles (Rendu GPU 16× plus rapide)

Configuration réduisant le temps de rendu d'environ 56 s à environ 3 s par image tout en conservant une qualité professionnelle :

import bpy

scene = bpy.context.scene
scene.render.engine = 'CYCLES'

# 1. OptiX Ray Tracing et configuration GPU
cpref = bpy.context.preferences.addons['cycles'].preferences
cpref.compute_device_type = 'OPTIX'
cpref.get_devices()

# Activez uniquement la carte graphique NVIDIA (désactivez le CPU lent)
for device in cpref.devices:
    if device.type == 'OPTIX' and 'GeForce' in device.name:
        device.use = True
    else:
        device.use = False

cycles = scene.cycles
cycles.device = 'GPU'

# 2. Échantillonnage intelligent avec débruitage IA
cycles.samples = 10                  # 10-12 échantillons suffisent avec OptiX Denoiser !
cycles.use_denoising = True
cycles.denoiser = 'OPTIX'

# 3. Fast GI et limite des rebonds lumineux (Light Bounces)
cycles.use_fast_gi = True
cycles.max_bounces = 4
cycles.diffuse_bounces = 2
cycles.glossy_bounces = 2
cycles.transmission_bounces = 2
cycles.volume_bounces = 1
cycles.transparent_max_bounces = 4
cycles.caustics_reflective = False
cycles.caustics_refractive = False

# 4. Réutilisation des données de géométrie entre les images
scene.render.use_persistent_data = True

---

4. Modèles de modélisation et d'animation

A. Paupières organiques (Shape Keys + profil carré)

• Déformez le bord supérieur de la paupière vers le bord inférieur en conservant l'ellipse de l'œil : closed_z = -h_bot * math.sqrt(max(0.0, 1.0 - (x / w_eye)**2))
• Animez simultanément le pli cutané (crease) ainsi qu'un mouvement de rotation subtil du globe oculaire vers le bas lors de la fermeture des paupières pour obtenir une expression fatiguée et naturelle.
• Utilisez l'interpolation BEZIER avec EASE_IN_OUT pour une accélération et un ralentissement fluides du mouvement des paupières.

B. Particules de fumée et tourbillons procéduraux

• Créez des spirales à l'aide de bmesh : radius = r_base + delta * t, spiral_angle = base_angle + t * turns * pi.
• Utilisez un matériau Principled BSDF avec une transparence basée sur ShaderNodeTexNoise mixé dans un ColorRamp.
• Bouclez la rotation avec interpolation = 'LINEAR' (d'un angle 0 à un multiple de 360°) pour que le mouvement des particules soit uniforme et répétable.

---

5. Processus de vérification avant le rendu complet

1. Effectuez toujours le rendu d'1 image de test avec l'objet ouvert et 1 avec l'objet fermé/transformé au maximum.
2. Mesurez le temps d'exécution d'une seule image : temps_animation = nombre_d_images * temps_d_une_seule_image
3. Testez un court rendu CLI de 2 images (-s 1 -e 2 -a) pour vérifier le bon enregistrement du fichier vidéo.