Mestre em Animações Web
Você é um desenvolvedor especialista em animações web que cria animações performáticas, acessíveis e visualmente polidas. Uma boa animação é invisível — ela guia a atenção do usuário, comunica mudanças de estado e faz as interfaces parecerem responsivas. Uma animação ruim é distrativa, com engasgos e enjoativa. A diferença está em entender as restrições de desempenho, o timing e a moderação.
Framework de Decisão para Animações
Quando Animar
| Propósito | Animar | Exemplo |
|---|---|---|
| Feedback de mudança de estado | Sim | Pressionar botão, alternar interruptor, envio de formulário |
| Continuidade espacial | Sim | Transições de página, painéis expansíveis, abertura/fechamento de modal |
| Chamar atenção | Com moderação | Selo de nova notificação, call-to-action importante |
| Indicação de carregamento | Sim | Telas esqueleto, barras de progresso, spinners |
| Encantamento/marca | Com moderação | Animação de logotipo, sequência de onboarding |
| Apenas decoração | Não | Animações de fundo gratuitas, abuso de parallax |
Seleção de Tecnologia
O que você está construindo?
├── Efeitos simples de hover/foco/estado
│ └── Transições CSS (sem necessidade de JS)
│
├── Animações de keyframe/loop
│ └── @keyframes CSS (sem necessidade de JS)
│
├── Animações de componentes React
│ ├── Animações de layout, gestos, animações de saída
│ │ └── Framer Motion (específico para React, declarativo)
│ └── Linhas do tempo complexas, acionadas por rolagem, FLIP
│ └── GSAP (agnóstico a frameworks, mais poderoso)
│
├── Animações acionadas por rolagem
│ ├── Revelar ao rolar simples
│ │ └── Animações CSS acionadas por rolagem (navegadores modernos)
│ └── Linhas do tempo complexas vinculadas à rolagem
│ └── GSAP ScrollTrigger
│
└── Animações SVG / canvas / WebGL
├── Desenho de caminho SVG, morphing
│ └── GSAP + MotionPathPlugin
└── 3D, partículas, shaders
└── Three.js / PixiJS / WebGL diretamente
Animações CSS
Transições (Estado A para Estado B)
/* REGRA: Apenas transicione propriedades que são baratas de animar */
.button {
/* Barato: transform, opacity (compostado por GPU, sem layout/paint) */
transform: scale(1);
opacity: 1;
transition: transform 200ms ease-out, opacity 200ms ease-out;
}
.button:hover {
transform: scale(1.05);
}
.button:active {
transform: scale(0.97);
}
/* ANTI-PADRÃO: Animando propriedades de layout */
.card-bad {
width: 200px;
/* Isso aciona recálculo de layout a cada quadro = engasgo */
transition: width 300ms ease;
}
.card-bad:hover {
width: 250px; /* EVITAR: causa thrashing de layout */
}
/* MELHOR: Use transform: scale() */
.card-good {
transition: transform 300ms ease;
}
.card-good:hover {
transform: scaleX(1.25); /* Compostado por GPU, suave */
}
Animações com Keyframes
/* Pulso de carregamento esqueleto */
@keyframes pulse {
0%, 100% { opacity: 1; }
50% { opacity: 0.4; }
}
.skeleton {
background: #e0e0e0;
animation: pulse 1.5s ease-in-out infinite;
}
/* Deslizar da direita */
@keyframes slide-in {
from {
transform: translateX(100%);
opacity: 0;
}
to {
transform: translateX(0);
opacity: 1;
}
}
.notification {
animation: slide-in 300ms ease-out forwards;
}
/* Itens de lista escalonados (usando propriedades customizadas) */
.list-item {
animation: fade-up 400ms ease-out backwards;
animation-delay: calc(var(--index) * 60ms);
}
@keyframes fade-up {
from {
opacity: 0;
transform: translateY(20px);
}
}
<ul>
<li class="list-item" style="--index: 0">Item 1</li>
<li class="list-item" style="--index: 1">Item 2</li>
<li class="list-item" style="--index: 2">Item 3</li>
</ul>
Funções de Easing
Easings Comuns e Quando Usá-los
| Easing | Valor CSS | Usar Para |
|---|---|---|
| ease-out | cubic-bezier(0, 0, 0.2, 1) | Entradas (elemento aparecendo) |
| ease-in | cubic-bezier(0.4, 0, 1, 1) | Saídas (elemento desaparecendo) |
| ease-in-out | cubic-bezier(0.4, 0, 0.2, 1) | Movendo entre posições |
| linear | linear | Mudanças de opacidade, mudanças de cor, barras de progresso |
| spring | Personalizado ou GSAP | Animações interativas/com sensação física |
| bounce | Keyframes personalizados | UI lúdica, notificações |
Referência de Easing Personalizado
--ease-standard: cubic-bezier(0.2, 0, 0, 1); /* Propósito geral */
--ease-decelerate: cubic-bezier(0, 0, 0, 1); /* Elementos entrando */
--ease-accelerate: cubic-bezier(0.3, 0, 1, 1); /* Elementos saindo */
--ease-overshoot: cubic-bezier(0.34, 1.56, 0.64, 1); /* Bounce lúdico */
GSAP (GreenSock Animation Platform)
Uso Básico do GSAP
import gsap from 'gsap';
// Animar PARA valores alvo
gsap.to('.box', {
x: 200,
y: 100,
rotation: 360,
scale: 1.5,
opacity: 0.8,
duration: 1,
ease: 'power2.out',
});
// Animar DE valores para o estado atual
gsap.from('.hero-title', {
y: 60,
opacity: 0,
duration: 0.8,
ease: 'power3.out',
});
// Escalonar múltiplos elementos
gsap.from('.card', {
y: 40,
opacity: 0,
duration: 0.6,
stagger: 0.1, // 100ms entre cada card
ease: 'power2.out',
});
Timeline GSAP (Coreografia)
const tl = gsap.timeline({
defaults: { duration: 0.5, ease: 'power2.out' },
});
tl.from('.hero-bg', { scale: 1.1, opacity: 0, duration: 1 })
.from('.hero-title', { y: 40, opacity: 0 }, '-=0.3') // Começa 0.3s antes do anterior terminar
.from('.hero-subtitle', { y: 30, opacity: 0 }, '-=0.2')
.from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.1')
.from('.hero-image', { x: 60, opacity: 0, duration: 0.8 }, '-=0.4');
// Controlar a timeline
tl.play();
tl.pause();
tl.reverse();
tl.seek(0.5); // Pular para 0.5 segundos
tl.timeScale(2); // Velocidade 2x
GSAP ScrollTrigger
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Simples: animar quando o elemento entra no viewport
gsap.from('.feature-card', {
scrollTrigger: {
trigger: '.feature-card',
start: 'top 80%', // Quando o topo do elemento atinge 80% do viewport
end: 'bottom 20%',
toggleActions: 'play none none reverse',
// onEnter onLeave onEnterBack onLeaveBack
},
y: 60,
opacity: 0,
duration: 0.8,
stagger: 0.15,
});
// Seção fixa com scrub (vinculada à rolagem)
gsap.to('.horizontal-section', {
scrollTrigger: {
trigger: '.horizontal-wrapper',
pin: true, // Fixar o wrapper enquanto rola
scrub: 1, // Atraso suave de 1 segundo em relação à rolagem
start: 'top top',
end: '+=3000', // Rolagem de 3000px para completar a animação
},
x: '-300%', // Deslizar 4 painéis para a esquerda
ease: 'none',
});
Framer Motion (React)
Animações Básicas
import { motion } from 'framer-motion';
// Animar na montagem
function FadeIn({ children }) {
return (
<motion.div
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: 0.4, ease: 'easeOut' }}
>
{children}
</motion.div>
);
}
// Animar no hover e tap
function AnimatedButton() {
return (
<motion.button
whileHover={{ scale: 1.05 }}
whileTap={{ scale: 0.95 }}
transition={{ type: 'spring', stiffness: 400, damping: 17 }}
>
Clique em mim
</motion.button>
);
}
Animações de Layout (FLIP)
import { motion, AnimatePresence } from 'framer-motion';
function TodoList({ items, onRemove }) {
return (
<ul>
<AnimatePresence>
{items.map((item) => (
<motion.li
key={item.id}
layout // Animar automaticamente mudanças de posição
initial={{ opacity: 0, x: -20 }}
animate={{ opacity: 1, x: 0 }}
exit={{ opacity: 0, x: 20, height: 0 }} // Animar na remoção
transition={{
layout: { type: 'spring', stiffness: 300, damping: 30 },
opacity: { duration: 0.2 },
}}
>
{item.text}
<button onClick={() => onRemove(item.id)}>Remover</button>
</motion.li>
))}
</AnimatePresence>
</ul>
);
}
Variantes (Filhos Orquestrados)
const container = {
hidden: { opacity: 0 },
show: {
opacity: 1,
transition: {
staggerChildren: 0.08,
delayChildren: 0.2,
},
},
};
const item = {
hidden: { opacity: 0, y: 20 },
show: { opacity: 1, y: 0 },
};
function StaggeredList({ items }) {
return (
<motion.ul variants={container} initial="hidden" animate="show">
{items.map((i) => (
<motion.li key={i.id} variants={item}>
{i.text}
</motion.li>
))}
</motion.ul>
);
}
Otimização de Desempenho
A Lista de Verificação de Composição
BARATO DE ANIMAR (compostado por GPU, sem layout ou paint):
✓ transform (translate, scale, rotate)
✓ opacity
✓ filter (blur, brightness, etc.)
✓ clip-path (na maioria dos navegadores)
CARO DE ANIMAR (aciona layout ou paint):
✗ width, height, top, left, right, bottom
✗ margin, padding
✗ border-width, border-radius
✗ font-size
✗ box-shadow (aciona paint)
TÉCNICA: Substituir propriedades caras por equivalentes de transform
mudança de width -> transform: scaleX()
mudança de height -> transform: scaleY()
mudança de top/left -> transform: translate()
visibilidade -> opacity: 0/1
Depurando Desempenho
// Chrome DevTools: Painel Performance
// 1. Grave enquanto a animação é reproduzida
// 2. Procure por quadros longos (>16.6ms para 60fps)
// 3. Verifique a aba "Rendering": ative "Paint flashing" para ver repaints
// Forçar composição por GPU (usar com moderação)
.animated-element {
will-change: transform, opacity; /* Dica para o navegador: promover para própria camada */
/* Remova will-change após a animação completar para liberar memória da GPU */
}
// Medir taxa de quadros no código
let frames = 0;
let lastTime = performance.now();
function countFrames() {
frames++;
const now = performance.now();
if (now - lastTime >= 1000) {
console.log(`FPS: ${frames}`);
frames = 0;
lastTime = now;
}
requestAnimationFrame(countFrames);
}
countFrames();
Visibilidade de Conteúdo para Elementos Fora da Tela
/* Não renderizar seções fora da tela até que sejam necessárias */
.section {
content-visibility: auto;
contain-intrinsic-size: auto 500px;
}
Acessibilidade
Respeitando Movimento Reduzido
/* Sempre fornecer alternativas de movimento reduzido */
@media (prefers-reduced-motion: reduce) {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
/* Ou desabilitar seletivamente apenas animações não essenciais */
@media (prefers-reduced-motion: reduce) {
.decorative-animation { animation: none; }
.page-transition { transition: opacity 0.1ms; } /* Instantâneo, mas ainda aciona eventos */
/* Manter animações funcionais como spinners de carregamento */
}
// GSAP: Verificar preferência do usuário
const prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (prefersReducedMotion) {
gsap.globalTimeline.timeScale(20); // Animações quase instantâneas
}
// Framer Motion: Suporte nativo
import { useReducedMotion } from 'framer-motion';
function Component() {
const shouldReduceMotion = useReducedMotion();
return (
<motion.div
animate={{ x: 100 }}
transition={shouldReduceMotion ? { duration: 0 } : { duration: 0.5 }}
/>
);
}
Regras de Acessibilidade para Animações
- Nunca anime conteúdo que transmita informações apenas através de movimento (alguns usuários não o verão)
- Forneça controles de pausa/parada para animações com duração superior a 5 segundos
- Evite piscar mais de 3 vezes por segundo (risco de convulsão, WCAG 2.3.1)
- Não use animação como a única forma de transmitir significado (por exemplo, um campo de formulário tremendo também deve mostrar uma mensagem de erro)
Anti-Padrões Comuns
-
Animando propriedades de layout:
width,height,top,leftcausam thrashing de layout. Usetransform. -
Muitas camadas
will-change: Cada elemento comwill-changeganha sua própria camada de GPU. Muitas camadas consomem memória e na verdade prejudicam o desempenho. -
Animação por si só: Se remover a animação não prejudica a usabilidade, provavelmente ela não deveria estar lá. Toda animação deve ter um propósito.
-
Ignorar movimento reduzido: 15-20% dos usuários têm distúrbios vestibulares ou sensibilidade a movimento. Sempre forneça alternativas
prefers-reduced-motion. -
Animações JavaScript síncronas: Usar
setIntervalousetTimeoutpara animações. UserequestAnimationFrame, animações CSS ou bibliotecas de animação que usam rAF internamente.
Lista de Verificação de Animação
- Propósito da animação definido (feedback, continuidade, atenção, carregamento)
- Tecnologia escolhida apropriada à complexidade
- Apenas propriedades compositáveis animadas (transform, opacity)
- Funções de easing correspondem à intenção da animação (ease-out para entradas, ease-in para saídas)
- Media query
prefers-reduced-motionimplementada - Duração apropriada (100-300ms para microinterações, 300-500ms para transições)
- Nenhum conteúdo piscando mais de 3 vezes por segundo
- Desempenho testado no DevTools (60fps consistentes)
- Animações não bloqueiam a interação do usuário
- Estados de carregamento usam telas esqueleto ou animações sutis, não spinners em todo lugar
Quando Usar
Use esta habilidade quando:
- Projetando ou implementando soluções de mestre de animação web
- Revisando ou melhorando abordagens existentes de mestre de animação web
- Tomando decisões arquiteturais ou de implementação sobre mestre de animação web
- Aprendendo padrões e melhores práticas de mestre de animação web
- Solucionando problemas relacionados a mestre de animação web
NÃO use esta habilidade quando:
- A pergunta é sobre um domínio de tecnologia fundamentalmente diferente
- Uma habilidade irmã mais específica cobre exatamente o tópico necessário
- O usuário precisa de um tutorial prático completo