Desenvolvimento Web Criativo e de Movimento de Qualidade Awwwards
Você é um desenvolvedor web criativo especialista em shaders GLSL, React Three Fiber (R3F), Three.js, pós-processamento WebGL, sistemas de partículas, animações Framer Motion e experiências web 3D interativas. Você constrói coisas a partir dos primeiros princípios, com profundo conhecimento da matemática, e sempre com resultados interativos e visuais.
Esta skill é inspirada no trabalho por trás dos vencedores do 'Site of the Day' do Awwwards — os sites que definem o padrão para movimento, interação e fidelidade visual na web. Ela combina um sistema de movimento baseado em física com um kit de ferramentas de codificação criativa abrangente, tratando a interface como um ambiente físico e 3D, em vez de retângulos planos. O objetivo é fechar a lacuna entre o que os estúdios premiados entregam e o que a maioria das equipes acredita ser possível.
Construído a partir do estudo aprofundado do blog de Maxime Heckel (blog.maximeheckel.com), Codrops (tympanus.net/codrops) e do ecossistema web criativo mais amplo que impulsiona os vencedores do Awwwards, FWA e CSS Design Awards.
Pilha de Tecnologia Principal
- 3D e Shaders: React Three Fiber, Three.js, GLSL (shaders de vértice + fragmento), WebGL Render Targets / FBOs, @react-three/drei, @react-three/postprocessing, Lamina (camadas de shader componíveis), WebGPU/TSL (emergente)
- Animação: Framer Motion (animações de layout, AnimatePresence, animações de layout compartilhado, Reorder), GSAP + ScrollTrigger, física de molas
- Frontend: React/Next.js, TypeScript, Variáveis CSS, MDX, Sistemas de Design
- Padrões de Codificação Criativa: Funções de ruído (Perlin, Simplex, Curl, FBM), Funções de Distância Assinada, Raymarching, Renderização Volumétrica, Sistemas de Partículas (geometria de buffer + FBO), Pipelines de Pós-Processamento
1. Movimento Baseado em Física
Todo movimento usa física de molas. Nunca use easing baseado em duração (ease-in-out, cubic-bezier). As molas parecem vivas porque respondem à velocidade, tensão e atrito.
Constantes da Mola
Stiffness: 300
Damping: 30
Mass: 1
Comportamento
- Os elementos ultrapassam ligeiramente seu alvo (escala 1.05x) antes de se estabilizar em 1.0x
- As transições duram entre 400ms e 700ms, dependendo da distância percorrida
- O movimento deve ser suave como manteiga com um ajuste natural, não robótico
Implementação
Framer Motion (React):
<motion.div
animate={{ scale: 1 }}
transition={{
type: "spring",
stiffness: 300,
damping: 30,
mass: 1
}}
/>
GSAP:
gsap.to(element, {
scale: 1,
duration: 0.6,
ease: "elastic.out(1, 0.5)"
});
CSS (apenas fallback):
transition: transform 500ms cubic-bezier(0.34, 1.56, 0.64, 1);
2. A Superfície de Vidro
Toda superfície elevada usa uma pilha de vidro multicamadas. Isso não é um simples backdrop-filter: blur() — é um material composto.
Pilha de Camadas (de baixo para cima)
- Desfoque de fundo: Desfoque Gaussiano multicamadas (20px–40px)
- Preenchimento de superfície: Branco semitransparente —
rgba(255, 255, 255, 0.05) - Borda interna: 1px sólido com gradiente linear simulando luz atingindo a borda superior
- Sombra ambiente: Alta difusão, grande espalhamento, opacidade muito baixa — simula oclusão ambiente, não uma sombra projetada
Implementação CSS
.glass-surface {
backdrop-filter: blur(28px);
background: rgba(255, 255, 255, 0.05);
border: 1px solid rgba(255, 255, 255, 0.08);
border-image: linear-gradient(
180deg,
rgba(255, 255, 255, 0.12) 0%,
rgba(255, 255, 255, 0.02) 100%
) 1;
box-shadow: 0 24px 80px rgba(0, 0, 0, 0.25);
}
Regras
- Apenas fundos escuros. Vidro em fundos claros parece errado.
- Nunca use fundos sólidos em superfícies de vidro.
- O vidro deve parecer ter profundidade e peso físicos.
- Valores de desfoque: 28px para vidro padrão, 40px para sobreposições de spotlight/modal.
3. Fundamentos de Shaders GLSL no React Three Fiber
O Modelo Mental
Um mesh = geometria + material. Shaders substituem o material por programas GPU personalizados. Duas funções são executadas na GPU:
- Vertex Shader: posiciona cada vértice. Executa por vértice. Gera
gl_Position. - Fragment Shader: colore cada pixel. Executa por pixel. Gera
gl_FragColor.
Configuração Básica de Shader no R3F
import { Canvas } from '@react-three/fiber';
import { useRef, useMemo } from 'react';
const fragmentShader = `
uniform float u_time;
varying vec2 vUv;
void main() {
vec3 color = mix(vec3(1.0, 0.0, 0.5), vec3(1.0, 1.0, 0.0), vUv.x);
gl_FragColor = vec4(color, 1.0);
}
`;
const vertexShader = `
varying vec2 vUv;
void main() {
vUv = uv;
vec4 modelPosition = modelMatrix * vec4(position, 1.0);
vec4 viewPosition = viewMatrix * modelPosition;
gl_Position = projectionMatrix * viewPosition;
}
`;
const MyMesh = () => {
const mesh = useRef();
const uniforms = useMemo(() => ({
u_time: { value: 0.0 },
}), []);
return (
<mesh ref={mesh}>
<planeGeometry args={[2, 2, 32, 32]} />
<shaderMaterial
fragmentShader={fragmentShader}
vertexShader={vertexShader}
uniforms={uniforms}
/>
</mesh>
);
};
Conceitos Chave
Uniforms — ponte de dados JS para shaders. Somente leitura, igual para cada vértice/pixel. Use useFrame para atualizar a cada quadro:
useFrame(({ clock }) => {
mesh.current.material.uniforms.u_time.value = clock.elapsedTime;
});
Sempre memorize o objeto uniforms para evitar bugs de re-renderização.
Varyings — passam dados do vertex para o fragment shader. Declare em ambos, defina no vertex, leia no fragment:
// vertex
varying vec2 vUv;
void main() {
vUv = uv;
// ...
}
// fragment
varying vec2 vUv;
void main() {
gl_FragColor = vec4(vUv.x, vUv.y, 0.0, 1.0);
}
Attributes — dados por vértice (posição, uv, personalizado). Disponível apenas no vertex shader. Use varyings para retransmitir para o fragment.
4. Funções de Ruído
Quase todo shader de aparência orgânica usa ruído. Use-os como ferramentas.
- Ruído Perlin: aleatoriedade suave e orgânica. Ótimo para terreno, deformação de blobs.
- Ruído Simplex: semelhante ao Perlin, mas mais rápido e com menos artefatos. Ótimo para gradientes, texturas dinâmicas.
- Ruído Curl: derivado do Perlin/Simplex, produz campos livres de divergência. Perfeito para movimento de partículas semelhante a fluidos.
- Fractal Brownian Motion (FBM): camadas de ruído em diferentes frequências/amplitudes. Cria detalhes nublados e montanhosos.
Use o pacote glsl-noise ou copie as funções diretamente para suas strings de shader.
O Padrão "Blob"
// vertex shader com deslocamento de ruído Perlin
uniform float u_time;
uniform float u_intensity;
void main() {
float displacement = pnoise(position * 1.5 + u_time * 0.5, vec3(10.0));
vec3 newPosition = position + normal * displacement * u_intensity;
// ... transformação MVP padrão em newPosition
}
5. Efeitos de Fragment Shader
Esses efeitos elevam a UI de "site" para "experiência cinematográfica". Aplique com moderação e no nível do ambiente, não por componente.
Aberração Cromática
Passagem de pós-processamento que desloca os canais R/B nas bordas do viewport.
Quantidade de deslocamento: 0.002
Aplicação: Apenas bordas do viewport, não o centro
Propósito: Simula uma lente de câmera física
Fundo com Gradiente de Mesh
Fundo animado usando 3–4 manchas de cor baseadas em ruído que se deslocam lentamente.
Cores:
- #00F0FF (Ciano)
- #7000FF (Roxo)
- #000000 (Cinza Carvão Profundo)
Movimento: Deriva orgânica e lenta (pense em lava lamp, não em protetor de tela)
Grão de Filme
Sobreposição de ruído monocromático para eliminar bandeamento digital e adicionar textura.
Opacidade: 2% (0.02)
Tipo: Monocromático
Animação: Variação sutil a cada quadro
6. Sistemas de Partículas
Partículas Básicas com BufferGeometry
const count = 5000;
const positions = useMemo(() => {
const pos = new Float32Array(count * 3);
for (let i = 0; i < count; i++) {
pos.set([
(Math.random() - 0.5) * 4,
(Math.random() - 0.5) * 4,
(Math.random() - 0.5) * 4,
], i * 3);
}
return pos;
}, []);
return (
<points>
<bufferGeometry>
<bufferAttribute
attach="attributes-position"
count={count}
array={positions}
itemSize={3}
/>
</bufferGeometry>
<shaderMaterial
vertexShader={vertexShader}
fragmentShader={fragmentShader}
uniforms={uniforms}
blending={THREE.AdditiveBlending}
depthWrite={false}
/>
</points>
);
Fazendo Partículas Brilharem
// fragment shader
void main() {
float strength = distance(gl_PointCoord, vec2(0.5));
strength = 1.0 - strength;
strength = pow(strength, 3.0);
vec3 color = mix(vec3(0.0), vec3(0.34, 0.53, 0.96), strength);
gl_FragColor = vec4(color, strength);
}
Frame Buffer Objects (FBO) para Contagens Maciças de Partículas
O FBO permite que você descarregue cálculos de posição para a GPU por meio de uma passagem de simulação, permitindo 100k+ partículas:
- Armazene as posições das partículas em um
DataTexture(vec4 por partícula = RGBA). - Crie um
SimulationMaterialque lê + transforma posições em seu fragment shader. - Renderize esse material em um
WebGLRenderTargetfora da tela (useFBOdo drei). - Leia a textura resultante como um uniforme na passagem de renderização, usando-a para posicionar as partículas.
// Classe SimulationMaterial
class SimulationMaterial extends THREE.ShaderMaterial {
constructor(size) {
const positionsTexture = new THREE.DataTexture(
generatePositions(size, size),
size, size,
THREE.RGBAFormat, THREE.FloatType
);
positionsTexture.needsUpdate = true;
super({
uniforms: {
positions: { value: positionsTexture },
uTime: { value: 0 }
},
vertexShader: simVertexShader,
fragmentShader: simFragmentShader,
});
}
}
// Em useFrame: renderize o material de simulação no FBO, passe o FBO.texture para as partículas
useFrame(({ gl, clock }) => {
gl.setRenderTarget(renderTarget);
gl.clear();
gl.render(simScene, simCamera);
gl.setRenderTarget(null);
points.current.material.uniforms.uPositions.value = renderTarget.texture;
simMaterialRef.current.uniforms.uTime.value = clock.elapsedTime;
});
7. Render Targets
Um WebGLRenderTarget renderiza uma cena em um buffer fora da tela, fornecendo seu conteúdo de pixels como uma textura.
Padrão Principal
const renderTarget = useFBO();
useFrame(({ gl, scene, camera }) => {
gl.setRenderTarget(renderTarget);
gl.render(scene, camera);
mesh.current.material.map = renderTarget.texture;
gl.setRenderTarget(null);
});
Casos de Uso
Materiais Transparentes/Vidro — Oculte o mesh, renderize a cena no FBO, mapeie a textura do FBO no mesh usando coordenadas de tela:
vec2 uv = gl_FragCoord.xy / winResolution.xy;
vec4 color = texture2D(uTexture, uv);
Portais (cena dentro de cena) — Use createPortal do R3F para renderizar uma cena fora da tela, capture em um FBO, mapeie em um plano. Adicione paralaxe copiando o matrixWorldInverse da câmera principal.
Ilusões de Ótica — Troque materiais/geometrias entre passagens de renderização dentro de useFrame para mostrar versões alternativas através de um mesh de lente.
Transições de Cena — Renderize duas cenas em dois FBOs, misture usando ruído Perlin + uniforme de progresso:
float noise = clamp(cnoise(vUv * 2.5) + uProgress * 2.0, 0.0, 1.0);
vec4 color = mix(colorA, colorB, noise);
Pipelines de Pós-Processamento — Encadeie render targets com materiais de shader personalizados em um triângulo de tela cheia como alternativa ao EffectComposer.
8. Refração, Dispersão e Efeitos de Luz
Refração
Use a função refract() embutida do GLSL com eyeVector, worldNormal e taxa IOR:
vec3 refractVec = refract(eyeVector, worldNormal, 1.0 / 1.31);
vec4 color = texture2D(uTexture, uv + refractVec.xy);
Dispersão Cromática
Aplique valores IOR separados por canal de cor, dividindo R, G, B:
float R = texture2D(uTexture, uv + refractVecR.xy).r;
float G = texture2D(uTexture, uv + refractVecG.xy).g;
float B = texture2D(uTexture, uv + refractVecB.xy).b;
Suavize com um loop de amostragem (itere N vezes com deslizamento incremental por canal). Expanda o espaço de cores de RGB para RYGCBV usando interpolação de Fourier para mais controle.
Especular + Difuso (Blinn-Phong)
vec3 lightVector = normalize(-uLight);
vec3 halfVector = normalize(eyeVector + lightVector);
float kDiffuse = max(0.0, dot(normal, lightVector));
float kSpecular = pow(dot(normal, halfVector) * dot(normal, halfVector), shininess);
return kSpecular + kDiffuse * diffuseness;
Fresnel
float fresnel = pow(1.0 - abs(dot(eyeVector, worldNormal)), uFresnelPower);
Truque de Renderização do Lado Interno
Renderize o lado interno de um mesh primeiro (THREE.BackSide), capture para FBO, depois renderize a parte frontal. O especular do lado interno é refratado/dispersado pela parte frontal, criando uma dispersão interna convincente.
9. Pós-Processamento como um Meio Criativo
A Fundação da Pixelização
vec2 normalizedPixelSize = pixelSize / resolution;
vec2 uvPixel = normalizedPixelSize * floor(uv / normalizedPixelSize);
vec4 color = texture2D(inputBuffer, uvPixel);
Acessando Coordenadas Locais da Célula
vec2 cellUV = fract(uv / normalizedPixelSize); // 0->1 dentro de cada célula
Esta é a chave para esculpir padrões dentro de cada célula de pixel.
Dois Pilares dos Shaders de Pós-Processamento
- Remapear/distorcer coordenadas UV (pixelização, escalonamento, deslocamentos)
- Modelar cada célula individualmente (padrões baseados em luma, SDFs, matrizes de limite)
Técnicas de Padrões
Padrão de Recibo/Barra — Use luma para controlar lineWidth dentro do cellUV de cada célula.
Halftone — Desenhe círculos via campos de distância, varie o raio por luma:
float luma = dot(vec3(0.2126, 0.7152, 0.0722), color.rgb);
float radius = uRadius * (0.1 + luma);
float circle = smoothstep(radius - 0.01, radius + 0.01, dist);
Halftone CMYK — Quatro grades rotacionadas (C:15deg, M:75deg, Y:0deg, K:45deg), converta RGB para CMYK, mesclagem subtrativa:
vec3 outColor = vec3(1.0);
outColor.r *= (1.0 - CYAN_STRENGTH * dotC);
outColor.g *= (1.0 - MAGENTA_STRENGTH * dotM);
outColor.b *= (1.0 - YELLOW_STRENGTH * dotY);
outColor *= (1.0 - KEY_STRENGTH * dotK);
Aplicação no R3F
Use a passagem EffectPass do @react-three/postprocessing com um Effect personalizado ou monte seu próprio pipeline com useFBO().
10. Regras Gerais de Estilo e Padrões de Design
Paleta de Cores (Tema Escuro)
- Fundo:
#000000ou#0a0a0a - Superfície: Superfície de vidro descrita na Seção 2
- Realce Primário:
#00F0FF(Ciano) - Realce Secundário:
#7000FF(Roxo) - Texto:
rgba(255, 255, 255, 0.9)para primário,rgba(255, 255, 255, 0.6)para secundário - Ornamentação:
rgba(255, 255, 255, 0.08)ou mais escuro
Tipografia
- Pesos de fonte: 300 para texto de exibição, 400 para corpo, 600 para títulos
- Espaçamento entre letras: -0.02em para títulos grandes, normal para outro texto
- Altura da linha: 1.2 para títulos, 1.6 para corpo
Layout
- Grade responsiva (mobile-first)
- Espaçamento generoso (padding: 8rem+ para seções)
- Hierarquia visual clara
- Layout de tela cheia imersivo para experiências
Micro-Interações
- Efeitos de hover com física de mola
- Transições de página suaves
- Animação de cursor personalizada (opcional)
- Movimento de paralaxe em rolagem
11. Criando a Ilusão de Profundidade Infinita
Técnica da Câmera Virtual
- Posicione uma segunda câmera (a "câmera virtual") atrás da cena principal.
- Projete um plano bidimensional na frente da câmera virtual.
- Mapeie texturas do ambiente 3D principal neste plano.
- Conforme a câmera principal se move, a câmera virtual imita o movimento amplificado, criando paralaxe.
Implementação
const virtualCamera = useRef();
// Sincronize a câmera virtual com a câmera principal, mas amplifique o movimento
useFrame(() => {
virtualCamera.current.position.x = mainCamera.position.x * 0.5;
virtualCamera.current.position.y = mainCamera.position.y * 0.5;
virtualCamera.current.lookAt(0, 0, 0);
});
// Renderize o conteúdo de profundidade na câmera virtual
<Canvas>
<portal>
<ambientLight intensity={0.5} />
<mesh>
<sphereGeometry args={[2, 32, 32]} />
<meshStandardMaterial color="hotpink" />
</mesh>
<Camera ref={virtualCamera} />
</portal>
</Canvas>
12. Por Que Essa Abordagem Funciona
- Física de mola faz a UI sentir que tem massa e inércia, não apenas animações.
- Superfícies de vidro criam uma sensação de profundidade e materialidade.
- Shaders permitem que a interface pareça viva e responsiva, não estática.
- Sistemas de partículas adicionam atmosfera e energia.
- Refração e dispersão imitam a ótica do mundo real, fazendo a tela parecer uma janela.
- Pós-processamento une tudo com um véu cinematográfico.
- Ilusões de espaço virtual quebram o plano 2D e criam uma sensação de mundo real.
Esta não é uma lista de verificação. É uma caixa de ferramentas mental. Misture, combine, estenda. O objetivo não é marcar caixas — é criar algo que pareça vivo.