O que MSP — Manim Style & Protocol faz?
Uma Especificação de Habilidade de Nível de Produção para Animações Manim Geradas por IA
Versão: 1.0
Alvo: Manim Community Edition (ManimCE) ≥ v0.18
Propósito: Permitir que qualquer sistema de IA gere animações Manim limpas, organizadas, com morfismo suave e qualidade de estúdio/produção por padrão — não como exceção.
0. DIRETIVA PRINCIPAL
Cada cena que você escrever deve parecer que veio de um estúdio de animação profissional, não de um script de estudante. Se uma escolha for ambígua, escolha a opção que é mais suave, mais limpa e mais intencional — nunca a opção padrão mais preguiçosa.
Antes de escrever qualquer código, percorra silenciosamente esta lista de verificação:
- Qual é a única ideia que esta cena comunica?
- Qual é a hierarquia visual (o que o olho deve ver primeiro, segundo, terceiro)?
- Qual paleta de cores e fonte estou usando, e ela é consistente em todo o projeto?
- Como cada objeto vai entrar, se transformar e sair — nada deve simplesmente "aparecer" ou "desaparecer" sem um verbo de animação.
- Qual é o ritmo (orçamento total de
run_time) para a cena?
1. AMBIENTE & VERSÃO
Sempre use como padrão a Manim Community Edition, não a ManimGL, a menos que o usuário solicite explicitamente a ManimGL estilo 3b1b.
from manim import *
- Binário CLI:
manim(nãomanimgl) - Verbo de criação:
Create()(nãoShowCreation()) - Renderização matemática:
MathTex(r"...")(nãoTex(R"..."))
Nunca misture APIs. Se um trecho usar self.camera.frame sem MovingCameraScene/ThreeDScene, sinalize-o — isso é sintaxe ManimGL vazando.
2. ESTRUTURA DE ARQUIVOS DO PROJETO
Para qualquer coisa além de uma única cena trivial, imponha esta estrutura — nunca despeje tudo em um único arquivo monolítico:
projeto/
├── manim.cfg # configuração de renderização fixa (veja §9)
├── tema.py # cores, fontes, constantes (fonte única da verdade)
├── helpers.py # construtores de mobjects reutilizáveis / funções de layout
├── cenas/
│ ├── 01_intro.py
│ ├── 02_derivacao.py
│ └── 03_outro.py
└── assets/ # svgs, imagens, áudio
Exemplo de tema.py (SEMPRE crie um para projetos com várias cenas):
from manim import *
# ---- PALETA ----
COR_FUNDO = "#0E0E12"
PRIMARIA = "#58C4DD" # azul padrão do manim, ou cor da marca
SECUNDARIA = "#FFD166"
DESTAQUE = "#EF476F"
TEXTO_PRINCIPAL = "#F5F5F5"
TEXTO_SUAVE = "#8A8A8F"
SUCESSO = "#06D6A0"
# ---- TIPOGRAFIA ----
FONTE_PRINCIPAL = "Helvetica" # ou específica do projeto
FONTE_MONO = "JetBrains Mono"
# ---- CONSTANTES DE TEMPO ----
T_RAPIDO = 0.5
T_NORMAL = 1.0
T_LENTO = 1.8
LAG = 0.08 # lag_ratio padrão para revelações em grupo
config.background_color = COR_FUNDO
Cada arquivo de cena importa de tema.py. Nunca codifique cores hexadecimais ou números mágicos de run_time diretamente depois que um arquivo de tema existir — esta é a marca nº 1 de saída não profissional e inconsistente.
3. PADRÕES DE DESIGN VISUAL
3.1 Regras de Cor
- Máximo de 4-5 cores por projeto (1 fundo, 1-2 primárias, 1-2 de destaque). Mais parece ruidoso/amador.
- Use a cor semanticamente: mesma cor = mesmo significado em todo o vídeo (ex., sempre azul para "dado", sempre vermelho para "desconhecido").
- O fundo quase nunca deve ser preto puro (
#000000) ou branco puro — use um preto suave próximo (#0E0E12) ou um branco suave para reduzir o cansaço visual e dar uma sensação de "estúdio".
3.2 Regras de Tipografia
- Use
Text()para rótulos de UI, títulos, legendas — rápido, sem dependência de LaTeX. - Use
MathTex()para toda notação matemática — nunca finja matemática comText(). - Use
Tex()apenas para blocos LaTeX de prosa+matemática misturados. - Defina uma
font=globalmente através das constantes do tema; nunca deixe a escolha da fonte variar de cena para cena. - Convenção de título:
.to_edge(UP), peso negrito, tamanho de fonte consistente (ex., 40pt) em todas as cenas.
3.3 Regras de Layout
- Respeite a regra dos terços — evite centralizar tudo por padrão; use
.to_edge(),.shift(),.next_to()deliberadamente. - Mantenha margens consistentes (valores de
buff) — defina uma constanteMARGEM = 0.75e reutilize-a em cada chamada.to_edge(..., buff=MARGEM). - Agrupe objetos relacionados em um único
VGroupe posicione/anime o grupo, não mobjects individuais soltos — isso garante que o alinhamento permaneça correto através de qualquer transformação posterior. - Sempre chame
.arrange()ou.arrange_in_grid()em grupos em vez de calcular coordenadas manualmente — coordenadas manuais são frágeis e a fonte nº 1 de layouts quebrados sob edições posteriores.
4. O PROTOCOLO DE MORFISMO & TRANSFORMAÇÃO
Este é o coração da animação "suave e com morfismo" — a aparência característica de vídeos explicativos de alta qualidade.
4.1 Regra: Nunca Corte, Sempre Transforme
Se um objeto conceitualmente se torna outro objeto (equação se reorganiza, forma se transforma em outra forma, rótulo é atualizado), nunca use FadeOut + FadeIn como mobjects separados e não relacionados — isso parece um corte brusco. Sempre use uma família de transformação:
| Situação | Ferramenta correta |
|---|---|
| Equação se reorganiza, termos persistem | TransformMatchingTex(antigo, novo) |
| Forma se transforma em forma diferente | Transform(antigo, novo) ou ReplacementTransform(antigo, novo) |
| Grupo de mobjects se reestrutura (ex., lista de tópicos → diagrama) | TransformMatchingShapes(grupo_antigo, grupo_novo) |
| Um objeto substitui explicitamente outro no grafo da cena | ReplacementTransform (troca antigo por novo em self.mobjects) |
| Desvanecimento implicando continuidade (ex., fantasma/sobreposição) | FadeTransform(antigo, novo) |
Detalhe do protocolo para TransformMatchingTex: sempre construa ambos os mobjects MathTex com agrupamento de substrings consistente (os mesmos fragmentos LaTeX como grupos {} separados) para que o Manim possa combinar símbolos idênticos — isso é o que faz os termos "deslizarem" visualmente para sua nova posição em vez de fazer uma transição cruzada.
eq1 = MathTex("a", "+", "b", "=", "c")
eq2 = MathTex("c", "=", "a", "+", "b")
self.play(TransformMatchingTex(eq1, eq2), run_time=1.2)
4.2 Regra: Use .animate para Morfismos de Propriedade Simples
Para mudanças contínuas de propriedade única (posição, escala, cor, rotação) em um mobject, prefira a sintaxe .animate — é mais limpa e o Manim interpola a transformação líquida automaticamente:
self.play(quadrado.animate.shift(RIGHT * 2).scale(1.5).set_color(DESTAQUE), run_time=1.0)
Ressalva (crítica, evite bugs de alucinação de IA): chamadas .animate encadeadas interpolam o estado líquido final, não cada etapa intermediária sequencialmente. Nunca encadeie chamadas .animate que dependem de um resultado intermediário (ex., .animate.move_to(X).rotate(angulo_dependendo_da_posição)) — divida em chamadas self.play() separadas.
4.3 Regra: Use Updaters para Movimento Contínuo/Dependente
Sempre que o estado de um objeto deve rastrear continuamente outro objeto (um rótulo seguindo um ponto, uma exibição de valor rastreando um ValueTracker), use add_updater, nunca reproduza manualmente cada quadro:
rastreador = ValueTracker(0)
rotulo = DecimalNumber(0).add_updater(lambda d: d.set_value(rastreador.get_value()))
ponto = Dot().add_updater(lambda m: m.move_to(eixos.c2p(rastreador.get_value(), f(rastreador.get_value()))))
self.add(rotulo, ponto)
self.play(rastreador.animate.set_value(5), run_time=3, rate_func=linear)
Sempre remove_updater (ou use always_redraw para lógica de recalcular do zero mais limpa) assim que a fase de dependência de um objeto terminar, para evitar bugs de updater obsoletos posteriores em cenas longas.
5. PROTOCOLO DE TEMPO, RITMO & EASING
5.1 Política de Função de Taxa Padrão
- Padrão (não substitua):
smooth— ease-in/ease-out em curva S. Use para 90% das animações — revelações de equações, criação de formas, movimentos padrão. linear: obrigatório para qualquer coisa que descreva movimento físico literal de taxa constante — pontos orbitando, vetores de velocidade uniforme, ponteiros de relógio girando, barras de progresso vinculadas ao tempo real decorrido.rush_into/rush_from: use para entradas/saídas de ênfase onde algo deve parecer que está se encaixando no lugar ou sendo lançado para longe.there_and_back/there_and_back_with_pause: use para pulsos de atenção estiloIndicate, nunca para mudanças de estado permanentes.ease_out_bounce/ease_out_elastic: reserve para conteúdo lúdico e informal apenas — nunca em uma derivação formal de matemática/ciência, onde parece pouco profissional.
5.2 Regras de Orçamento de Tempo
- Mantenha
run_timeindividual entre 0,4s e 3s. Abaixo de 0,4s parece chocante; acima de 3s (sem motivo narrativo) arrasta. - Entradas de títulos/cabeçalhos de seção:
0,8–1,2s. - Transformações de equações/diagramas:
1,0–1,5s. - Pulsos de ênfase (
Indicate,Flash,Circumscribe):0,5–0,8s. - Movimentos de câmera (
move_camera,self.camera.frame.animate):1,5–3s— movimentos de câmera mais rápidos que isso causam náuseas. - Insira pausas deliberadas
self.wait(0,3–1,0)após cada grande revelação — nunca encadeie chamadasself.play()consecutivas sem pausa; isso sobrecarrega o espectador.
5.3 Protocolo de Composição
- Eventos simultâneos mas independentes → chamada única
self.play(AnimA, AnimB, ...). - Simultâneos com início escalonado (ex., 6 tópicos aparecendo em sequência mas se sobrepondo) →
LaggedStart(*anims, lag_ratio=0.15). - Eventos estritamente sequenciais e dependentes →
Succession(*anims)ou chamadasself.play()separadas. - Revelações de listas/grades (marcadores, grades de formas) → sempre
LaggedStartMap(FadeIn, grupo, lag_ratio=0.08, shift=UP*0.3)em vez de um únicoFadeIn(grupo)simultâneo — o escalonamento é o que faz as entradas de grupo parecerem orgânicas em vez de robóticas.
6. PROTOCOLO DE ORGANIZAÇÃO DE CENA & CÓDIGO
6.1 Forma do Método construct
Sempre decomponha construct() em fases claramente delimitadas e nomeadas por meio de comentários ou métodos auxiliares — nunca um bloco ininterrupto de 100 linhas:
class CenaDerivacao(Cena):
def construct(self):
self.configurar_titulo()
self.mostrar_equacao_inicial()
self.derivar_passos()
self.destacar_resultado()
self.limpar()
def configurar_titulo(self):
self.titulo = Text("Derivando a Fórmula Quadrática", font=FONTE_PRINCIPAL).to_edge(UP)
self.play(Write(self.titulo), run_time=T_NORMAL)
self.wait(T_RAPIDO)
def mostrar_equacao_inicial(self):
...
Para vídeos longos, divida em várias classes de cena (uma por seção lógica) em vez de um único construct() gigante — permite renderização direcionada via -n e iteração paralela.
6.2 Protocolo de Construção de Mobjects
- Construa visuais personalizados complexos (diagramas, gráficos, ícones) como funções independentes em
helpers.pyretornando umVGroup, não inline emconstruct():
# helpers.py
def criar_neuronio(raio=0.3, cor=PRIMARIA) -> VGroup:
circulo = Circle(radius=raio, color=cor, fill_opacity=0.8)
rotulo = Text("n", font_size=20).move_to(circulo)
return VGroup(circulo, rotulo)
- Sempre nomeie mobjects de forma significativa (
titulo,eq_inicial,grupo_grafico) — nunca deixe literais anônimos não referenciados que você precisará mutar ou transformar depois. - Use
z_indexexplicitamente para qualquer cena com camadas sobrepostas (não confie apenas na ordem de adição assim que houver mais de 2 camadas).
6.3 Regras de Estilo / Linting
- snake_case para variáveis/métodos, PascalCase para subclasses de Cena.
- Uma linha em branco entre "batidas" de animação no código para legibilidade — a estrutura do código deve espelhar visualmente o ritmo do vídeo.
- Sem números mágicos para cor/posição/tempo — sempre referencie as constantes de
tema.py. - Dicas de tipo para funções auxiliares (
def criar_eixos() -> Axes:) para capacidade de manutenção em projetos maiores.
7. PROTOCOLO DE COMPOSIÇÃO & CÂMERA (2D & 3D)
2D
- Use
MovingCameraScenesempre que o vídeo precisar panorâmica/zoom em 2D (ex., focando em uma sub-região de um diagrama) — anime viaself.camera.frame.animate.move_to(...).set(width=...), sempre com umrun_timeexplícito.
3D
- Subclasse
ThreeDScene. - Defina a orientação inicial com
self.set_camera_orientation(phi=70*GRAUS, theta=-45*GRAUS, zoom=1)em uma etapa de configuração dedicada — nunca deixe a orientação padrão a menos que seja intencional. - Para qualquer reposicionamento de câmera que o espectador deve perceber como movimento, use
self.move_camera(phi=..., theta=..., run_time=2.5)— nunca corte bruscamente viaset_camera_orientationno meio da cena. - Use
self.begin_ambient_camera_rotation(taxa=0.15)para rotação lenta e ambiente sob narração; sempre emparelhe comself.stop_ambient_camera_rotation()antes de qualquermove_cameradeliberado subsequente. - HUD/rótulos/títulos que devem permanecer legíveis independentemente do ângulo da câmera →
self.add_fixed_in_frame_mobjects(rotulo). - Rótulos que devem rastrear objetos 3D mas permanecer legíveis →
self.add_fixed_orientation_mobjects(rotulo). - Mantenha as tuplas de
resoluçãode superfície 3D baixas (ex.,(24,24)) durante a iteração; aumente apenas para a renderização final de produção — esta é puramente uma regra de desempenho/fluxo de trabalho, não visual.
8. PROTOCOLO DE ÊNFASE & ATENÇÃO
Nunca deixe um resultado chave visualmente idêntico ao conteúdo de suporte. Depois de revelar a "recompensa" de uma cena (equação final, insight chave, resultado), aplique exatamente uma técnica de ênfase — não empilhe mais de uma ou parecerá frenético:
Circumscribe(mobjeto, cor=DESTAQUE, run_time=1.2)— desenha uma forma ao redor dele.Indicate(mobjeto, fator_escala=1.15)— breve pulso de escala + flash de cor.Flash(ponto, cor=DESTAQUE)— explosão radial, bom para um ponto/coordenada de interseção específica.mobjeto.animate.set_color(DESTAQUE)combinado com uma ligeira escala — para recolorir permanentemente sinalizando "esta é a resposta."
9. PROTOCOLO DE RENDERIZAÇÃO & EXPORTAÇÃO
9.1 Arquivo de Configuração Fixo (confirme este — nunca confie em flags ad hoc para entrega final)
manim.cfg:
[CLI]
quality = production_quality
preview = False
background_color = "#0E0E12"
output_file = {scene_name}
frame_rate = 60
pixel_height = 1080
pixel_width = 1920
9.2 Estágios do Fluxo de Trabalho (sempre siga esta ordem, nunca renderize a qualidade final primeiro)
- Passe de rascunho:
manim -pql cenas/02_derivacao.py CenaDerivacao— iteração rápida, verifique lógica/tempo. - Passe de verificação:
manim -pqh -s cenas/02_derivacao.py CenaDerivacao— verificação de alta qualidade de quadro único da composição/cor.