MoGraph do Cinema 4D — equivalentes no Houdini

MoGraph é o motivo pelo qual metade dos motion designers usa C4D. É uma das ferramentas mais elegantes que já foram feitas pra motion — Cloner, Effectors, Fields, tudo funcionando junto de forma intuitiva e visual. Quando você chega no Houdini vindo do MoGraph, a primeira sensação é que o Houdini não tem isso. Na verdade tem — só que distribuído por vários sistemas que, juntos, fazem tudo que o MoGraph faz e muito mais. A diferença é que no C4D você clica num menu, e no Houdini você constrói.

A filosofia do MoGraph vs Houdini

O MoGraph trabalha com objetos — clones são objetos, effectors afetam objetos na hierarquia. O Houdini trabalha com pontos e atributos. Cada clone vira um ponto. Cada parâmetro de transformação vira um atributo nesse ponto. Quando você entende isso, tudo começa a fazer sentido.

Cloner

C4D: O coração do MoGraph. Distribui cópias de um objeto em grade, radial, linear, ou sobre superfície/spline. Animável, instanciado, recebe effectors.

Houdini: Copy to Points (SOP) — é o Cloner do Houdini.

Geometry (o que copiar) → Input 0 do Copy to Points
Points (onde copiar) → Input 1 do Copy to Points

Para criar os pontos de distribuição equivalentes aos modos do Cloner:

Modo Grid (grade):

Grid SOP → modo "Points" → Copy to Points

Modo Radial:

Circle SOP → dividido em N pontos → Copy to Points

Modo Linear:

Line SOP → Resample SOP → Copy to Points

Modo Object (sobre superfície):

Geometry → Scatter SOP → Copy to Points

Modo Spline:

Curve SOP → Resample SOP → Copy to Points

Para que os clones respeitem rotação e escala por ponto, o Copy to Points usa os atributos:

• @orient (quaternion) — rotação
• @pscale — escala uniforme
• @scale (vetor) — escala não-uniforme
• @N + @up — alternativa pra orientação

// No Attribute Wrangle ANTES do Copy to Points:
// Rotação aleatória por instância
@orient = quaternion(radians(rand(@ptnum * 3.7) * 360), {0,1,0});
@pscale = fit01(rand(@ptnum), 0.5, 1.5);

Effectors

Effectors são o que dá vida ao MoGraph. No Houdini, cada effector é equivalente a um Attribute Wrangle — ou uma combinação de nós — que modifica atributos dos pontos antes do Copy to Points.

Random Effector

C4D: Adiciona variação aleatória de posição, rotação, escala e outros parâmetros por clone.

Houdini: Attribute Randomize SOP ou Point Wrangle:

// Randomizar posição
@P += set(rand(@ptnum) - 0.5, rand(@ptnum + 1) - 0.5, rand(@ptnum + 2) - 0.5) * chf("amount");

// Randomizar escala
@pscale = fit01(rand(@ptnum * 13.7), chf("min_scale"), chf("max_scale"));

// Randomizar rotação
float angle = rand(@ptnum * 7.3) * 360;
@orient = quaternion(radians(angle), {0,1,0});

Step Effector

C4D: Aplica uma rampa progressiva ao longo dos clones — do primeiro ao último.

Houdini: Attribute Wrangle com ramp por índice normalizado:

// Step effector: ramp de escala do primeiro ao último clone
float t = float(@ptnum) / float(@numpt - 1);
@pscale = chramp("scale_ramp", t);

O chramp cria uma ramp editável direto nos parâmetros do nó — equivalente visual às curvas do Step Effector.

Plain Effector

C4D: O mais genérico — transforma posição, rotação, escala com falloff. É o que você mais usa junto com Fields.

Houdini: Point Wrangle direto. A combinação de campos de influência (Fields) é feita com atributos de máscara:

// Plain effector com máscara por atributo "mask" (0 a 1)
float mask = @mask; // calculado antes por um SDF ou função
@P.y += mask * chf("offset_y");
@pscale = lerp(1.0, chf("target_scale"), mask);

Effector de Spline (Spline Effector)

C4D: Alinha ou movimenta clones ao longo de uma spline.

Houdini: Path Deform SOP, ou calcular posição na curva via Point Wrangle + xyzdist():

// Puxar cada ponto em direção à curva mais próxima
// (curva no segundo input)
float dist;
vector uv_pos;
int prim = xyzdist(1, @P, uv_pos, dist);
vector closest = primuv(1, "P", prim, uv_pos);
@P = lerp(@P, closest, chf("blend"));

Sound Effector

C4D: Deforma clones baseado em amplitude de áudio.

Houdini: Via CHOP network — você usa um Audio CHOP que lê arquivo de áudio e exporta os dados como atributos via CHOP to Attribute. É mais setup, mas muito mais controle (por banda de frequência, por beat, etc).

Shader Effector

C4D: Usa uma textura/shader como mapa de influência nos clones.

Houdini: Você bake a textura como atributo nos pontos via Attribute from Map SOP:

Scatter SOP (pontos sobre UV) → Attribute from Map SOP
Parâmetro: texture path, atributo de saída (ex: "influence")

Depois usa esse atributo no Wrangle pra modular qualquer coisa.

Fields

C4D (R20+): Fields definem áreas de influência pro MoGraph — esferas, boxes, splines, noise, etc. São composáveis e têm blending entre si.

Houdini: Fields no Houdini são literalmente volumes VDB ou funções matemáticas nos Wrangles. A flexibilidade é maior, mas é mais explícito.

Field esférico:

// Influência esférica a partir de um centro
float dist = distance(@P, {0,0,0});
float falloff = 1.0 - fit(dist, 0, chf("radius"), 0, 1);
falloff = clamp(falloff, 0, 1);
@mask = falloff;

Field de noise (como o Random Field do C4D):

@mask = fit01(noise(@P * chf("freq") + @Time * chf("speed")), 0, 1);

Field de volume (VDB):

VDB SOP → Volume Sample → atributo de máscara

Para composição de fields (como o Field Layer do C4D), você simplesmente multiplica ou adiciona atributos em Wrangles sequenciais.

MoSpline

C4D: Anima splines proceduralmente — crescimento, ondulação, trails.

Houdini: Combinação de Resample + Carve SOP pra crescimento de spline:

Curve SOP → Carve SOP
Parâmetro "First U" keyframed de 0 a 1 = crescimento da spline

Para MoSpline com turbulência e ondas:

Curve SOP → Resample SOP → Mountain SOP (ou Point Wrangle com noise)

Tracer / Trail

C4D: Gera splines seguindo o rastro de objetos ao longo do tempo.

Houdini: Trail SOP — equivalente direto.

Animated Points → Trail SOP
Mode: "Trails" ou "Previous Frame"

Para trails com comprimento controlado e fade de atributos ao longo do trail, Trail + Attribute Blur ou Wrangle por índice de ponto.

PolyFX

C4D: Fragmenta geometria em polígonos individuais pra animar separadamente com effectors.

Houdini: Nó Explode Pieces (SOP) ou separar por primitiva com Connectivity + Split:

Geometry → Connectivity SOP (Class: Primitive) → Split por @class
→ cada peça vira um "clone" → Copy to Points style transform

Para o fluxo mais direto (animar cada polígono):

Geometry → Facet SOP (Unique Points) → Point Wrangle (transforma por @primnum)

Voronoi Fracture (equivalente ao MoGraph Fracture)

C4D: MoGraph Fracture + Cloner com Voronoi fragment.

Houdini: Voronoi Fracture (SOP) — mais poderoso e controlável.

Geometry → Voronoi Fracture SOP
Points de fratura: Scatter SOP sobre a geometria

Para animação das peças fraturadas com effector-style:

Voronoi Fracture → Pack SOP → Copy to Points (ou Attribute Wrangle por @piece)

Effector de Matrix (instâncias sem geometria)

C4D: Matrix Object — distribui “pontos virtuais” sem render, só pra receber effectors e depois alimentar um Cloner.

Houdini: É exatamente como o Houdini pensa por padrão — você trabalha com pontos que carregam atributos, sem precisar de geometria visível até o Copy to Points final. Essa é a abordagem nativa.

Um exemplo completo: logo reveal com MoGraph thinking

Em C4D: Cloner em grade → Random Effector → Step Effector com ramp → animar o Step

Em Houdini:

Grid SOP (pontos)
  → Attribute Wrangle (random scale, rotation por @ptnum)
  → Attribute Wrangle (ramp por índice + @Time pra animar o step)
  → Copy to Points (geometria do logo fragmentado)

// No segundo Wrangle: step animado
float step_pos = fit(@Time, 0, 5, -0.2, 1.2); // anima de 0 a 5 segundos
float t = float(@ptnum) / float(@numpt - 1);
float dist_from_step = abs(t - step_pos);
float influence = 1.0 - fit(dist_from_step, 0, chf("softness"), 0, 1);
influence = clamp(influence, 0, 1);

@P.y += influence * 2.0;
@pscale = lerp(@pscale, 1.0, influence);

Com essa lógica você tem o equivalente exato de um Step Effector animado — e pode adicionar qualquer campo de influência adicional sem depender de menus.

Resumo: MoGraph no Houdini em uma frase

MoGraph = Copy to Points + Attribute Wrangles + Ramps + VEX

Não existe botão “adicionar effector”. Você constrói o effector. Isso assusta no começo, mas depois de entender que todo effector é só matemática em pontos, você percebe que tem poder ilimitado — e qualquer coisa que você viu num reel e pensou “como fizeram isso?”, provavelmente é um Wrangle com 10 linhas de VEX.

Recursos

• Houdini Docs — Copy to Points
• Houdini Docs — Attribute Wrangle
• Houdini Docs — Trail SOP
• Houdini Docs — Voronoi Fracture
• Houdini Docs — Carve SOP
• SideFX — Motion Graphics in Houdini
• Entagma — Procedural Motion Graphics

Última atualização: 2026 | Parte do wiki Zé do Motion