Pingwink/skill

Automação do Blender 5.2, Otimização Cycles e Fluxo de Trabalho de Vídeo

Este guia (skill) contém procedimentos comprovados, configurações de otimização e padrões de código desenvolvidos durante modelagem, animação e renderização de cenas no Blender 5.2.

---

1. Arquitetura de comunicação e renderização

A. Controle de sessão interativa (Socket IPC)

Para modelagem interativa, modificação de materiais e frames de teste, use um cliente socket:

• Porta: 127.0.0.1:9876 (plugin Blender MCP / socket bridge)
• Protocolo: JSON terminado com byte nulo \0 ({"type": "execute", "code": "...", "strict_json": true})

B. Renderização de animações em segundo plano (CLI headless)

Regra: Não renderize animações longas via socket (risco de congelamento da GUI ou timeout). Salve a cena em um arquivo .blend e execute um processo CLI dedicado em segundo plano:

& "C:\Program Files\Blender Foundation\Blender 5.2\blender.exe" -b "caminho\para\projeto.blend" -s 1 -e 108 -a

• Vantagens: 15–20% mais rápido (sem overhead OpenGL/viewport), streaming do progresso frame a frame no stdout, sem bloquear a interface.

---

2. Principais mudanças na API no Blender 5.2+

A. Exportação de vídeo para FFMPEG / MP4

No Blender 5.2, atribuir file_format = 'FFMPEG' diretamente às configurações padrão gera um erro TypeError. É necessário primeiro definir media_type:

import bpy

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

# 1. Obrigatório no Blender 5.2 antes de selecionar o formato de vídeo:
ims.media_type = 'VIDEO'
ims.file_format = 'FFMPEG'

# 2. Configuração do contêiner e codec:
scene.render.ffmpeg.format = 'MPEG4'
scene.render.ffmpeg.codec = 'H264'
scene.render.ffmpeg.constant_rate_factor = 'HIGH'
scene.render.ffmpeg.ffmpeg_preset = 'REALTIME' # Opções: 'BEST', 'GOOD', 'REALTIME'

B. Compositor (Grupo de Nós de Composição)

O Blender 5.2 introduz compositing_node_group em vez do antigo scene.node_tree e NodeGroupOutput em vez 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

# Criar entradas/saídas
rl = ng.nodes.new('CompositorNodeRLayers')
glare = ng.nodes.new('CompositorNodeGlare')
out = ng.nodes.new('NodeGroupOutput')

# No Blender 5.2, os parâmetros do Glare são sockets, não propriedades do objeto:
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. Otimização extrema do Cycles (Render GPU 16× mais rápido)

Configuração que reduz o tempo de renderização de ~56 s para ~3 s por frame mantendo a qualidade de estúdio:

import bpy

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

# 1. OptiX Ray Tracing & Configuração GPU
cpref = bpy.context.preferences.addons['cycles'].preferences
cpref.compute_device_type = 'OPTIX'
cpref.get_devices()

# Ativar apenas a placa de vídeo NVIDIA (desativar CPU lento)
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. Amostragem inteligente com denoising AI
cycles.samples = 10                  # 10-12 amostras são suficientes com OptiX Denoiser!
cycles.use_denoising = True
cycles.denoiser = 'OPTIX'

# 3. Fast GI & Limite de reflexos de luz (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. Reutilização de dados de geometria entre frames
scene.render.use_persistent_data = True

---

4. Padrões de modelagem e animação

A. Pálpebras orgânicas (Shape Keys + perfil quadrático)

• Deformar a borda superior da pálpebra em direção à inferior, mantendo a elipse do olho: closed_z = -h_bot * math.sqrt(max(0.0, 1.0 - (x / w_eye)**2))
• Simultaneamente, animar a dobra da pele (crease) e um sutil movimento de rotação do globo ocular para baixo ao fechar as pálpebras, para obter uma expressão cansada e natural.
• Usar interpolação BEZIER com EASE_IN_OUT para aceleração e desaceleração suave do movimento da pálpebra.

B. Partículas procedurais de fumaça e vórtices

• Criar faixas espirais usando bmesh: radius = r_base + delta * t, spiral_angle = base_angle + t * turns * pi.
• Usar material Principled BSDF com transparência baseada em ShaderNodeTexNoise mixado em um ColorRamp.
• Loop de rotação com interpolation = 'LINEAR' (de ângulo 0 a múltiplos de 360°), para que o movimento das partículas seja uniforme e repetível.

---

5. Fluxo de verificação antes da renderização final

1. Sempre renderize 1 frame de teste com o objeto aberto e 1 com o objeto fechado/transformado ao máximo.
2. Meça o tempo de execução de um único frame: tempo_animacao = numero_de_frames * tempo_de_um_frame
3. Teste uma renderização CLI curta de 2 frames (-s 1 -e 2 -a) para verificar a gravação correta do arquivo de vídeo.