Biznomad – Sites Web com Animação de Vídeo ao Rolar (Scrollytelling de Nível Apple)
Esta skill fornece padrões arquitetônicos completos, pipelines de compressão FFmpeg e código JS/CSS de produção para construir sites de alto desempenho com animação de vídeo ao rolar, no padrão dos sites da Apple, Stripe, Lusion e Awwwards Site-of-the-Day.
Pesquisa do Setor e Análise Arquitetônica
Ao construir experiências de vídeo acionadas por rolagem, as principais agências de tecnologia e design selecionam entre três estratégias primárias de renderização:
| Estratégia | Referência do Setor | Melhor para | Prós | Contras |
|---|---|---|---|---|
| Canvas Image Sequence | Apple (MacBook, AirPods, iPhone) | Precisão ao arrastar, lag zero, quadro perfeito | Extremamente suave a 60–120fps, funciona em GPUs móveis | Requer pré-carregamento de quadros (array de 20–60MB) |
| Vídeo HTML5 Codificado com ALL-I | Stripe, Nike, Tesla | Configuração rápida, largura de banda baixa (arquivo único) | Único download MP4, inicialização rápida | Requer distância curta entre keyframes (-g 1) |
| Shader WebGL | Lusion, Active Theory, Cuberto | Distorção 3D, efeitos de vidro líquido | Altamente criativo, controle de iluminação e refração | Maior carga na GPU, complexidade do shader |
1. Preparação de Vídeo e Pipeline de Codificação FFmpeg
Para obter avanço de quadro instantâneo e suave, o vídeo DEVE ser codificado com distância de keyframe igual a 1 (cada quadro é um Intra-frame / Keyframe).
Opção A: Preparar Vídeo para Avanço em Vídeo HTML5 (Codificação ALL-I)
Execute este comando FFmpeg para gerar um MP4 de avanço ultrarrápido:
ffmpeg -i input.mp4 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" -c:v libx264 -preset slow -crf 18 -g 1 -keyint_min 1 -an -movflags +faststart output_scrub.mp4
Opção B: Preparar Sequência de Quadros para Avanço em Canvas (Estilo Apple)
Extraia quadros comprimidos em WebP ou JPEG 1080p:
mkdir -p frames
ffmpeg -i input.mp4 -vf "scale=1920:1080" -q:v 85 frames/frame_%04d.jpg
# Ou para WebP (tamanho de arquivo menor):
ffmpeg -i input.mp4 -vf "scale=1920:1080" -c:v libwebp -quality 85 frames/frame_%04d.webp
2. Configuração da Stack Técnica
- Mecanismo de Rolagem Suave:
@studio-freight/lenisouLenis(elimina tremores e fornece rolagem com momentum) - Driver de Animação:
GSAP 3.12+comScrollTrigger - Camada de Renderização:
<canvas>com Contexto 2D ou<video>com sincronizaçãocurrentTime - Tipografia e HUD: Cartões sobrepostos fixos com efeito glassmorphism sincronizados com os gatilhos da linha do tempo
3. Arquitetura de Produção: Sequência Canvas Estilo Apple (Recomendado)
Abaixo está a implementação pronta para produção de uma sequência de frames em canvas estilo Apple, com pré-carregador, rolagem suave Lenis e camadas de texto scrollytelling flutuantes.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
<title>Apple-Style Video Scroll Showcase</title>
<!-- Fontes & CDNs GSAP + Lenis -->
<link rel="preconnect" href="https://fonts.googleapis.com"/>
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;800;900&family=JetBrains+Mono:wght@500;700&display=swap" rel="stylesheet"/>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/lenis.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.12.5/gsap.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.12.5/ScrollTrigger.min.js"></script>
<style>
:root {
--bg: #000000;
--paper: #f5f5f7;
--dim: #86868b;
--accent: #2997ff;
--accent-glow: rgba(41, 151, 255, 0.35);
--panel: rgba(22, 22, 23, 0.75);
--line: rgba(255, 255, 255, 0.12);
}
* { box-sizing: border-box; margin: 0; padding: 0; }
body {
background: var(--bg);
color: var(--paper);
font-family: "Inter", system-ui, -apple-system, sans-serif;
overflow-x: hidden;
-webkit-font-smoothing: antialiased;
}
/* Pré-carregador */
#preloader {
position: fixed;
inset: 0;
z-index: 999;
background: #000;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 16px;
transition: opacity 0.6s ease, visibility 0.6s ease;
}
#preloader.done { opacity: 0; visibility: hidden; }
.loader-bar {
width: 200px;
height: 3px;
background: rgba(255, 255, 255, 0.15);
border-radius: 999px;
overflow: hidden;
}
.loader-fill {
height: 100%;
width: 0%;
background: var(--accent);
transition: width 0.1s linear;
}
/* Estágio de Rolagem com Canvas Fixo */
.scroll-stage {
position: relative;
height: 400vh; /* Determina a duração da interação de rolagem */
}
.sticky-viewport {
position: sticky;
top: 0;
width: 100vw;
height: 100vh;
overflow: hidden;
display: flex;
align-items: center;
justify-content: center;
}
canvas#scrollCanvas {
width: 100%;
height: 100%;
object-fit: cover;
display: block;
}
/* Painéis Flutuantes de Scrollytelling */
.hud-overlay {
position: absolute;
inset: 0;
pointer-events: none;
z-index: 10;
}
.hud-card {
position: absolute;
max-width: 460px;
background: var(--panel);
backdrop-filter: blur(20px);
-webkit-backdrop-filter: blur(20px);
border: 1px solid var(--line);
border-radius: 20px;
padding: 32px;
opacity: 0;
transform: translateY(30px);
transition: opacity 0.5s ease, transform 0.5s ease;
}
.hud-card.active {
opacity: 1;
transform: translateY(0);
}
.hud-eyebrow {
font-family: "JetBrains Mono", monospace;
color: var(--accent);
font-size: 12px;
letter-spacing: 0.15em;
text-transform: uppercase;
font-weight: 700;
margin-bottom: 8px;
}
.hud-title {
font-size: 32px;
font-weight: 800;
letter-spacing: -0.03em;
line-height: 1.1;
margin-bottom: 12px;
}
.hud-desc {
color: var(--dim);
font-size: 15px;
line-height: 1.6;
}
/* Posições Individuais do HUD */
.hud-1 { top: 15%; left: 8%; }
.hud-2 { top: 35%; right: 8%; }
.hud-3 { bottom: 15%; left: 8%; }
/* Seção Final */
.outro-sec {
min-height: 100vh;
display: flex;
align-items: center;
justify-content: center;
text-align: center;
background: #08080a;
border-top: 1px solid var(--line);
padding: 80px 24px;
}
.outro-title {
font-size: clamp(40px, 6vw, 84px);
font-weight: 900;
letter-spacing: -0.04em;
margin-bottom: 24px;
}
.btn-cta {
display: inline-block;
background: var(--accent);
color: #fff;
font-weight: 700;
padding: 16px 36px;
border-radius: 999px;
text-decoration: none;
box-shadow: 0 10px 30px var(--accent-glow);
transition: transform 0.2s;
}
.btn-cta:hover { transform: scale(1.05); }
</style>
</head>
<body>
<!-- Pré-carregador -->
<div id="preloader">
<div style="font-weight:700;font-size:14px;letter-spacing:0.1em">CARREGANDO EXPERIÊNCIA</div>
<div class="loader-bar"><div class="loader-fill" id="loaderFill"></div></div>
</div>
<!-- Contêiner de Rolagem com Vídeo -->
<div class="scroll-stage" id="scrollStage">
<div class="sticky-viewport">
<canvas id="scrollCanvas"></canvas>
<!-- Overlays de Scrollytelling HUD -->
<div class="hud-overlay">
<div class="hud-card hud-1" id="hud1">
<div class="hud-eyebrow">01 / ARQUITETURA</div>
<h2 class="hud-title">Precisão Projetada.</h2>
<p class="hud-desc">Cada quadro calculado em tempo real. Velocidade visual e capacidade de resposta incomparáveis.</p>
</div>
<div class="hud-card hud-2" id="hud2">
<div class="hud-eyebrow">02 / TELEMETRIA</div>
<h2 class="hud-title">Fluxo de Dados em Tempo Real.</h2>
<p class="hud-desc">Sincronização de submilissegundos entre a entrada de rolagem do usuário e a apresentação no canvas.</p>
</div>
<div class="hud-card hud-3" id="hud3">
<div class="hud-eyebrow">03 / DESEMPENHO</div>
<h2 class="hud-title">Domínio de 120 FPS.</h2>
<p class="hud-desc">Renderização de canvas acelerada por GPU sem queda de quadros ou gaguejos na rolagem.</p>
</div>
</div>
</div>
</div>
<section class="outro-sec">
<div>
<h1 class="outro-title">Pronto para Lançar.</h1>
<a href="#" class="btn-cta">EXPERIMENTE O FUTURO →</a>
</div>
</section>
<script>
document.addEventListener('DOMContentLoaded', () => {
// 1. Inicializar Rolagem Suave Lenis
const lenis = new Lenis({
duration: 1.2,
easing: (t) => Math.min(1, 1.001 - Math.pow(2, -10 * t)),
smoothWheel: true
});
function raf(time) {
lenis.raf(time);
requestAnimationFrame(raf);
}
requestAnimationFrame(raf);
// Sincronizar Lenis com GSAP ScrollTrigger
lenis.on('scroll', ScrollTrigger.update);
gsap.ticker.add((time) => lenis.raf(time * 1000));
gsap.ticker.lagSmoothing(0);
// 2. Configurar Canvas e Pré-carregador de Imagens
const canvas = document.getElementById('scrollCanvas');
const ctx = canvas.getContext('2d');
const loaderFill = document.getElementById('loaderFill');
const preloader = document.getElementById('preloader');
const totalFrames = 120; // Número de quadros extraídos
const images = [];
const airbnb = { frame: 0 };
// Gerador de URL de quadro (Substitua pelo seu caminho relativo)
const currentFrame = (index) => `./frames/frame_${(index + 1).toString().padStart(4, '0')}.jpg`;
let loadedCount = 0;
for (let i = 0; i < totalFrames; i++) {
const img = new Image();
img.src = currentFrame(i);
img.onload = () => {
loadedCount++;
loaderFill.style.width = `${(loadedCount / totalFrames) * 100}%`;
if (loadedCount === totalFrames) {
preloader.classList.add('done');
renderCanvas();
}
};
images.push(img);
}
// Lidar com Telas Retina de Alta Resolução (DPR)
function resizeCanvas() {
const dpr = window.devicePixelRatio || 1;
canvas.width = window.innerWidth * dpr;
canvas.height = window.innerHeight * dpr;
ctx.scale(dpr, dpr);
renderCanvas();
}
window.addEventListener('resize', resizeCanvas);
function renderCanvas() {
if (!images[airbnb.frame]) return;
const img = images[airbnb.frame];
const w = window.innerWidth;
const h = window.innerHeight;
// Matemática para Ajuste de Cobertura (Cover Fit)
const imgRatio = img.width / img.height;
const canvasRatio = w / h;
let drawW, drawH, offsetX, offsetY;
if (canvasRatio > imgRatio) {
drawW = w;
drawH = w / imgRatio;
offsetX = 0;
offsetY = (h - drawH) / 2;
} else {
drawW = h * imgRatio;
drawH = h;
offsetX = (w - drawW) / 2;
offsetY = 0;
}
ctx.clearRect(0, 0, w, h);
ctx.drawImage(img, offsetX, offsetY, drawW, drawH);
}
// Redimensionamento Inicial do Canvas
resizeCanvas();
// 3. Sequência GSAP ScrollTrigger
gsap.to(airbnb, {
frame: totalFrames - 1,
snap: "frame",
ease: "none",
scrollTrigger: {
trigger: "#scrollStage",
start: "top top",
end: "bottom bottom",
scrub: 0.5,
onUpdate: () => renderCanvas()
}
});
// 4. Gatilhos para Overlays de Scrollytelling HUD
function setupHudTrigger(id, startPct, endPct) {
ScrollTrigger.create({
trigger: "#scrollStage",
start: `${startPct}% top`,
end: `${endPct}% top`,
onEnter: () => document.getElementById(id).classList.add('active'),
onLeave: () => document.getElementById(id).classList.remove('active'),
onEnterBack: () => document.getElementById(id).classList.add('active'),
onLeaveBack: () => document.getElementById(id).classList.remove('active')
});
}
setupHudTrigger('hud1', 10, 30);
setupHudTrigger('hud2', 35, 60);
setupHudTrigger('hud3', 65, 90);
});
</script>
</body>
</html>
4. Arquitetura Alternativa: Avanço Direto em Vídeo HTML5
Para projetos usando um único arquivo .mp4 comprimido com codificação Intra-frame (-g 1):
const video = document.getElementById('scrubVideo');
video.pause();
// Garantir que os metadados sejam carregados para a duração
video.onloadedmetadata = function() {
gsap.to(video, {
currentTime: video.duration,
ease: "none",
scrollTrigger: {
trigger: "#videoStage",
start: "top top",
end: "bottom bottom",
scrub: 0.3
}
});
};
5. Regras de Ouro para Qualidade Apple
- Keyframes Intra-frame (
-g 1): Obrigatório para avanço em vídeo HTML5, caso contrário o avanço fica instável nos intervalos de busca de keyframes. - Proporção de Pixels do Dispositivo (DPR): Sempre dimensione a resolução do canvas por
window.devicePixelRatiopara uma saída Retina nítida. - Matemática de Cobertura de Proporção: Calcule
offsetXeoffsetYao redimensionar o canvas para que os quadros mantenham a cobertura object-fit completa. - Interpolação de Rolagem Lenis: Nunca omita a inércia de rolagem suave (
Lenis). Eventos de roda nativos criam etapas discretas que degradam o avanço do vídeo. - Fallback de Performance Móvel: Em dispositivos móveis de baixa potência (
matchMedia('(prefers-reduced-motion: reduce)')ou baixa largura de banda), ofereça reprodução automática de vídeo ou frames estáticos em vez de cálculos pesados de avanço.