Design de Animação
Propósito
Projetar e implementar animações web performáticas e intencionais que melhorem a experiência do usuário sem sacrificar desempenho ou acessibilidade. Este skill cobre ferramentas de animação, padrões e a estrutura de decisão para escolher a abordagem certa.
Seleção de Ferramentas de Animação
Matriz de Decisão
NECESSIDADE DE ANIMAÇÃO FERRAMENTA RECOMENDADA
--------------------------------------------------------------
Efeitos simples de hover/foco Transições CSS
Sequências de keyframes (loading, etc.) CSS @keyframes
Animações de entrada/saída de componentes Framer Motion (React)
Vue <Transition> (Vue)
Revelações acionadas por rolagem Animações CSS orientadas por rolagem
(ou Intersection Observer)
Sequências temporais complexas GSAP
Animações de caminho SVG GSAP ou CSS
Movimento baseado em física/mola Framer Motion (spring)
Animações de layout (posição/tamanho) Framer Motion (layoutId)
Movimento baseado em gestos (arrastar, pinça) Framer Motion (drag)
Transições de elemento compartilhado View Transitions API
Animações de visualização de dados Transições D3 ou GSAP
Microinterações (ícones, alternadores) CSS ou Lottie
Transições CSS
Fundamentos
/* Atalho de transição: propriedade duração função-temporização atraso */
.botao {
background: var(--cor-marca);
transition: background 200ms ease-out, transform 150ms ease-out;
}
.botao:hover {
background: var(--cor-marca-hover);
transform: scale(1.02);
}
/* Propriedades individuais */
.card {
transition-property: transform, box-shadow, opacity;
transition-duration: 200ms, 300ms, 200ms;
transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
}
/* Funções de temporização nomeadas */
--ease-in: cubic-bezier(0.4, 0, 1, 1); /* Acelerando */
--ease-out: cubic-bezier(0, 0, 0.2, 1); /* Desacelerando */
--ease-in-out: cubic-bezier(0.4, 0, 0.2, 1); /* Padrão */
--ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Ultrapassagem */
Padrões de Transição Comuns
/* Aparecer/Desaparecer */
.fade-enter { opacity: 0; }
.fade-enter-active { opacity: 1; transition: opacity 300ms ease-out; }
.fade-exit { opacity: 1; }
.fade-exit-active { opacity: 0; transition: opacity 200ms ease-in; }
/* Deslizar para cima a partir de baixo */
.slide-up {
transform: translateY(20px);
opacity: 0;
transition: transform 300ms ease-out, opacity 200ms ease-out;
}
.slide-up.active {
transform: translateY(0);
opacity: 1;
}
/* Brilho de carregamento (skeleton) */
@keyframes brilho {
0% { background-position: -200% 0; }
100% { background-position: 200% 0; }
}
.skeleton {
background: linear-gradient(90deg, #e0e0e0 25%, #f0f0f0 50%, #e0e0e0 75%);
background-size: 200% 100%;
animation: brilho 1.5s ease-in-out infinite;
}
CSS @keyframes
/* Giratório */
@keyframes girar {
to { transform: rotate(360deg); }
}
.giratorio {
animation: girar 1s linear infinite;
border: 3px solid var(--cor-borda);
border-top-color: var(--cor-marca);
border-radius: 50%;
width: 24px; height: 24px;
}
/* Pulsar (indicador de atenção) */
@keyframes pulsar {
0%, 100% { opacity: 1; }
50% { opacity: 0.5; }
}
.ponto-notificacao {
# ... (condensado) ...
.item-lista:nth-child(2) { animation-delay: calc(1 * 50ms); }
.item-lista:nth-child(3) { animation-delay: calc(2 * 50ms); }
/* Ou com atributo style: style="--i: 3" */
.item-lista {
animation-delay: calc(var(--i) * 50ms);
}
Animações CSS Orientadas por Rolagem
/* Animar com base na posição de rolagem */
@keyframes revelar {
from {
opacity: 0;
transform: translateY(40px) scale(0.95);
}
to {
opacity: 1;
transform: translateY(0) scale(1);
}
}
/* Acionar quando o elemento entra na viewport */
.revelar-na-rolagem {
animation: revelar linear both;
animation-timeline: view();
animation-range: entry 0% entry 50%;
}
# ... (condensado) ...
to { transform: translateY(-50px); }
}
.elemento-parallax {
animation: parallax linear;
animation-timeline: scroll();
}
Framer Motion (React)
Padrões Básicos
import { motion, AnimatePresence } from 'framer-motion';
// Animação de entrada
function Card() {
return (
<motion.div
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: 0.3, ease: 'easeOut' }}
>
<h2>Conteúdo do Card</h2>
</motion.div>
);
}
// Animação de saída (requer AnimatePresence)
function Modal({ isOpen, onClose }: ModalProps) {
return (
# ... (condensado) ...
<motion.li key={item.id} variants={itemVariants}>
{item.nome}
</motion.li>
))}
</motion.ul>
);
}
Física de Mola
// Animação com mola (movimento natural baseado em física)
<motion.div
animate={{ x: 100 }}
transition={{
type: 'spring',
stiffness: 300, // Maior = mais rápido
damping: 20, // Maior = menos oscilação
mass: 1, // Maior = mais inércia
}}
/> .// Predefinições
const predefinicoesMola = {
rapida: { type: 'spring', stiffness: 400, damping: 25 },
elastica: { type: 'spring', stiffness: 300, damping: 10 },
suave: { type: 'spring', stiffness: 120, damping: 14 },
melado: { type: 'spring', stiffness: 60, damping: 20 },
};
// Quando usar mola vs. easing:
// Mola: elementos interativos, arrastar, mudanças de layout (parece natural)
// Easing: transições simples, entrada/saída (parece previsível)
Animações de Layout
// Animação automática de layout
function CardExpansivel({ expandido }: { expandido: boolean }) {
return (
<motion.div layout className={expandido ? 'card-expandido' : 'card-recolhido'}>
<motion.h2 layout="position">Título</motion.h2>
{expandido && (
<motion.p
initial={{ opacity: 0 }}
animate={{ opacity: 1 }}
exit={{ opacity: 0 }}
>
Conteúdo expandido aqui.
</motion.p>
)}
</motion.div>
);
}
# ... (condensado) ...
{item.titulo}
</motion.div>
))}
</div>
</LayoutGroup>
);
}
Animações de Gesto
// Arrastar
<motion.div
drag
dragConstraints={{ top: -100, bottom: 100, left: -100, right: 100 }}
dragElastic={0.2}
whileDrag={{ scale: 1.1, cursor: 'grabbing' }}
/> .// Hover e toque
<motion.button
whileHover={{ scale: 1.05 }}
whileTap={{ scale: 0.95 }}
transition={predefinicoesMola.rapida}
>
Clique em Mim
</motion.button> .// Acionado por rolagem (com useInView)
# ... (condensado) ...
animate={estaVisivel ? { opacity: 1, y: 0 } : {}}
transition={{ duration: 0.6, ease: 'easeOut' }}
>
{children}
</motion.div>
);
}
GSAP (Linhas do Tempo Complexas)
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Sequência de linha do tempo
const tl = gsap.timeline({ defaults: { ease: 'power2.out', duration: 0.5 } });
tl.from('.hero-titulo', { y: 60, opacity: 0 })
.from('.hero-subtitulo', { y: 40, opacity: 0 }, '-=0.3') // Sobreposição de 0.3s
.from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.2')
.from('.hero-imagem', { x: 100, opacity: 0 }, '-=0.4');
// Animação acionada por rolagem
gsap.from('.card-funcionalidade', {
scrollTrigger: {
trigger: '.secao-funcionalidades',
start: 'top 80%',
# ... (condensado) ...
const ctx = gsap.context(() => {
// Todas as animações GSAP aqui
gsap.from('.item', { opacity: 0, y: 20, stagger: 0.1 });
}, containerRef);
return () => ctx.revert(); // Limpar todas as animações
}, []);
Preferências de Movimento Reduzido
Implementação
/* CSS: Respeitar globalmente a preferência do usuário */
@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;
}
}
// React: Hook useReducedMotion
function useReducedMotion(): boolean {
const [reduzido, setReduzido] = useState(false);
useEffect(() => {
const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
setReduzido(mq.matches);
const handler = (e: MediaQueryListEvent) => setReduzido(e.matches);
mq.addEventListener('change', handler);
return () => mq.removeEventListener('change', handler);
}, []);
return reduzido;
}
// Uso
function CardAnimado() {
const reduzido = useReducedMotion();
# ... (condensado) ...
Conteúdo
</motion.div>
);
}
// Framer Motion integrado (v6+)
import { useReducedMotion } from 'framer-motion';
Orçamento de Desempenho para Animação
ALVO: As animações devem manter 60fps (16,67ms por quadro)
REGRAS:
1. Animar apenas transform e opacity (propriedades apenas do compositor)
2. Evitar animar width, height, top, left, margin, padding
3. Usar will-change com moderação (adiciona sobrecarga de memória)
4. Limitar animações simultâneas a ~10-15 elementos
5. Usar requestAnimationFrame para animações orientadas por JS
6. Debounce manipuladores de rolagem (ou usar animações CSS orientadas por rolagem)
7. Evitar animar elementos que acionam layout em outros elementos
MEDIÇÃO:
- Chrome DevTools > Performance > Gráfico de quadros
- Alvo: Nenhum quadro excedendo 16ms
- Verificar thrashing de layout (indicadores de refluxo forçado)
TÉCNICAS DE OTIMIZAÇÃO:
- Usar transform: translateZ(0) ou will-change para promover camadas
- Usar contain: layout paint para contêineres animados
- Usar content-visibility: auto para conteúdo animado fora da tela
- Pausar animações quando não visíveis (Intersection Observer)
Princípios de Design de Animação
1. PROPÓSITO: Cada animação deve servir a uma função
- Guiar a atenção
- Mostrar relações (pai-filho, antes-depois)
- Fornecer feedback (clique, hover, sucesso, erro)
- Manter orientação espacial (de onde o conteúdo veio)
- Reduzir o tempo de espera percebido
2. DIRETRIZES DE DURAÇÃO:
Microinterações (hover, alternar): 100-200ms
Animações de entrada: 200-400ms
Animações de saída: 150-300ms (mais rápida que a entrada)
Transições de página: 300-500ms
Sequências complexas: 500-1000ms total
3. EASING:
Entrando: ease-out (desacelerando -- aparece rapidamente, se estabelece)
Saindo: ease-in (acelerando -- começa devagar, sai rapidamente)
Movendo: ease-in-out (movimento natural)
Contínuo: linear (giratórios, progresso)
4. ESCALONAMENTO:
30-80ms entre itens da lista (mais rápido para mais itens)
Duração total máxima de escalonamento: ~500ms (mesmo para 20+ itens)
Lista de Verificação da Arquitetura de Animação
- Ferramenta de animação selecionada com base nas necessidades de complexidade
- Transições CSS usadas para efeitos simples de hover/foco
- CSS @keyframes usados para animações de loop e carregamento
- Framer Motion ou equivalente usado para animações de entrada/saída/layout
- GSAP reservado para sequências complexas de linha do tempo
- Todas as animações mantêm 60fps (verificado no DevTools)
- Apenas transform e opacity são animados (sem propriedades de layout)
- prefers-reduced-motion respeitado globalmente
- Durações de animação seguem diretrizes de UX (100-500ms)
- Tempo de escalonamento limitado a uma duração total razoável
- Cada animação tem um propósito claro (não decorativa)
- Física de mola usada para animações interativas/de gestos
- Animações orientadas por rolagem usam API CSS onde suportado
- Animações GSAP são limpas na desmontagem do componente
- will-change usado apenas durante animação ativa
Quando Usar
Use este skill quando:
- Projetando ou implementando soluções de design de animação
- Revisando ou melhorando abordagens existentes de design de animação
- Tomando decisões arquiteturais ou de implementação sobre design de animação
- Aprendendo padrões e melhores práticas de design de animação
- Solucionando problemas relacionados a design de animação
NÃO use este skill quando:
- A pergunta é sobre um domínio de tecnologia fundamentalmente diferente
- Um skill irmão mais específico cobre exatamente o tópico necessário
- O usuário precisa de um tutorial prático completo em vez de orientação especializada
Formato de Saída
# Análise de Design de Animação
## Avaliação de Contexto
[Resumo da situação e restrições]
## Abordagem Recomendada
[Recomendação principal com justificativa]
## Etapas de Implementação
1. [Etapa com detalhes específicos]
2. [Etapa com detalhes específicos]
3. [Etapa com detalhes específicos]
## Compensações e Considerações
- [Compensação principal 1]
- [Compensação principal 2]
## Próximos Passos
- [Item de ação imediata]
- [Item de ação de acompanhamento]
Exemplo
Entrada: "Ajude-me a implementar design de animação para uma aplicação de produção de médio porte"
Saída: Uma análise estruturada cobrindo avaliação do estado atual, abordagem de design de animação recomendada com padrões específicos, roteiro de implementação com marcos e estratégias de mitigação de riscos adaptadas à escala e restrições da aplicação.
Casos de Borda
- Integração com sistema legado: Quando o design de animação deve coexistir com abordagens legadas, forneça um caminho de migração gradual em vez de uma reescrita completa
- Incompatibilidade de escala: Quando a complexidade da solução excede a escala do projeto, recomende uma abordagem mais simples e observe quando revisitar
- Lacunas de habilidade da equipe: Quando a equipe não tem experiência com a abordagem recomendada, inclua recursos de aprendizado e alternativas mais simples
- Requisitos conflitantes: Quando as restrições entram em conflito (por exemplo, desempenho vs. manutenibilidade), declare explicitamente a compensação e recomende com base nas prioridades declaradas