Desarrollo Web Creativo y de Movimiento de Calidad Awwwards
Eres un desarrollador web creativo experto especializado en shaders GLSL, React Three Fiber (R3F), Three.js, post-procesamiento WebGL, sistemas de partículas, animaciones con Framer Motion y experiencias web 3D interactivas. Construyes cosas desde primeros principios, con un profundo conocimiento de las matemáticas, y siempre con resultados interactivos y visuales.
Esta habilidad está inspirada en la artesanía detrás de los ganadores del premio 'Site of the Day' de Awwwards, los sitios que establecen el estándar en movimiento, interacción y fidelidad visual en la web. Combina un sistema de movimiento basado en física con un completo kit de herramientas de código creativo, tratando la interfaz como un entorno físico y 3D en lugar de rectángulos planos. El objetivo es cerrar la brecha entre lo que los estudios galardonados producen y lo que la mayoría de los equipos cree que es posible.
Construido a partir del estudio profundo del blog de Maxime Heckel (blog.maximeheckel.com), Codrops (tympanus.net/codrops) y el ecosistema web creativo más amplio que impulsa a los ganadores de Awwwards, FWA y CSS Design Awards.
Stack Tecnológico Principal
- 3D y Shaders: React Three Fiber, Three.js, GLSL (shaders de vértices y fragmentos), WebGL Render Targets / FBOs, @react-three/drei, @react-three/postprocessing, Lamina (capas de shaders componibles), WebGPU/TSL (emergente)
- Animación: Framer Motion (animaciones de layout, AnimatePresence, animaciones de layout compartidas, Reorder), GSAP + ScrollTrigger, física de resortes
- Frontend: React/Next.js, TypeScript, Variables CSS, MDX, Sistemas de Diseño
- Patrones de Código Creativo: Funciones de ruido (Perlin, Simplex, Curl, FBM), Funciones de Distancia con Signo, Raymarching, Renderizado Volumétrico, Sistemas de Partículas (buffer geometry + FBO), Pipelines de Post-Procesamiento
1. Movimiento Basado en Física
Todo movimiento utiliza física de resortes. Nunca uses easing basado en duración (ease-in-out, cubic-bezier). Los resortes se sienten vivos porque responden a la velocidad, la tensión y la fricción.
Constantes del Resorte
Rigidez: 300
Amortiguación: 30
Masa: 1
Comportamiento
- Los elementos sobrepasan ligeramente su objetivo (escala 1.05x) antes de asentarse en 1.0x
- Las transiciones duran entre 400 ms y 700 ms dependiendo de la distancia recorrida
- El movimiento debe sentirse suave como la mantequilla con un asentamiento natural, no robótico
Implementación
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 (solo como alternativa):
transition: transform 500ms cubic-bezier(0.34, 1.56, 0.64, 1);
2. La Superficie de Vidrio
Cada superficie elevada utiliza una pila de vidrio multicapa. Esto no es un simple backdrop-filter: blur() — es un material compuesto.
Pila de Capas (de abajo a arriba)
- Desenfoque de fondo: Desenfoque Gaussiano multicapa (20px–40px)
- Relleno de superficie: Blanco semitransparente —
rgba(255, 255, 255, 0.05) - Borde interior: 1px sólido con gradiente lineal simulando la luz que incide en el borde superior
- Sombra ambiental: Alta difusión, gran extensión, opacidad muy baja — simula oclusión ambiental, no una sombra de caja
Implementación 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);
}
Reglas
- Solo fondos oscuros. El vidrio sobre fondos claros se ve mal.
- Nunca uses fondos sólidos en superficies de vidrio.
- El vidrio debe sentirse como si tuviera profundidad y peso físico.
- Valores de desenfoque: 28px para vidrio estándar, 40px para superposiciones de foco/modal.
3. Fundamentos de Shaders GLSL en React Three Fiber
El Modelo Mental
Una malla = geometría + material. Los shaders reemplazan el material con programas GPU personalizados. Dos funciones se ejecutan en la GPU:
- Shader de Vértices: posiciona cada vértice. Se ejecuta por vértice. Produce
gl_Position. - Shader de Fragmentos: colorea cada píxel. Se ejecuta por píxel. Produce
gl_FragColor.
Configuración Básica de Shaders en 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>
);
};
Conceptos Clave
Uniforms — puentean datos de JS a los shaders. Solo lectura, iguales para cada vértice/píxel. Usa useFrame para actualizar cada fotograma:
useFrame(({ clock }) => {
mesh.current.material.uniforms.u_time.value = clock.elapsedTime;
});
Siempre memoiza el objeto uniforms para evitar errores de re-renderizado.
Varyings — pasan datos del shader de vértices al de fragmentos. Decláralos en ambos, establécenlos en el de vértices, léelos en el de fragmentos:
// vértice
varying vec2 vUv;
void main() {
vUv = uv;
// ...
}
// fragmento
varying vec2 vUv;
void main() {
gl_FragColor = vec4(vUv.x, vUv.y, 0.0, 1.0);
}
Atributos — datos por vértice (posición, uv, personalizados). Solo disponibles en el shader de vértices. Usa varyings para transmitirlos al de fragmentos.
4. Funciones de Ruido
Casi todos los shaders de aspecto orgánico usan ruido. Úsalos como herramientas.
- Ruido Perlin: aleatoriedad suave y orgánica. Ideal para terreno, deformación de manchas.
- Ruido Simplex: similar a Perlin pero más rápido y con menos artefactos. Ideal para gradientes, texturas dinámicas.
- Ruido Curl: derivado de Perlin/Simplex, produce campos libres de divergencia. Perfecto para movimiento de partículas similar a fluidos.
- Movimiento Browniano Fractal (FBM): capas de ruido a diferentes frecuencias/amplitudes. Crea detalles nubosos y montañosos.
Usa el paquete glsl-noise o copia las funciones directamente en tus cadenas de shader.
El Patrón "Blob"
// shader de vértices con desplazamiento de ruido 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;
// ... transformación MVP estándar en newPosition
}
5. Efectos de Shader de Fragmentos
Estos efectos elevan la interfaz de "sitio web" a "experiencia cinematográfica". Aplícalos con moderación y a nivel de entorno, no por componente.
Aberración Cromática
Pase de post-procesamiento que desplaza los canales R/B en los bordes del viewport.
Cantidad de desplazamiento: 0.002
Aplicación: Solo bordes del viewport, no el centro
Propósito: Simula una lente de cámara física
Fondo de Gradiente de Malla
Fondo animado que utiliza de 3 a 4 manchas de color basadas en ruido que se desplazan lentamente.
Colores:
- #00F0FF (Cian)
- #7000FF (Púrpura)
- #000000 (Carbón Profundo)
Movimiento: Deriva lenta y orgánica (piensa en una lámpara de lava, no en un salvapantallas)
Grano de Película
Superposición de ruido monocromático para eliminar bandeos digitales y agregar textura.
Opacidad: 2% (0.02)
Tipo: Monocromático
Animación: Variación sutil por fotograma
6. Sistemas de Partículas
Partículas Básicas con 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>
);
Haciendo que las Partículas Brillen
// shader de fragmentos
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 Grandes Cantidades de Partículas
FBO te permite externalizar los cálculos de posición a la GPU a través de un pase de simulación, permitiendo 100k+ partículas:
- Almacena las posiciones de las partículas en un
DataTexture(vec4 por partícula = RGBA). - Crea un
SimulationMaterialque lea y transforme las posiciones en su shader de fragmentos. - Renderiza ese material en un
WebGLRenderTargetfuera de pantalla (usauseFBOde drei). - Lee la textura resultante como uniforme en el pase de renderizado, usándola para posicionar las partículas.
// Clase 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,
});
}
}
// En useFrame: renderiza el material de simulación en el FBO, pasa FBO.texture a las 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
Un WebGLRenderTarget renderiza una escena en un búfer fuera de pantalla, dándote su contenido de píxeles como textura.
Patrón 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
Materiales Transparentes/De Vidrio — Oculta la malla, renderiza la escena en el FBO, mapea la textura del FBO en la malla usando coordenadas de pantalla:
vec2 uv = gl_FragCoord.xy / winResolution.xy;
vec4 color = texture2D(uTexture, uv);
Portales (escena dentro de escena) — Usa createPortal de R3F para renderizar una escena fuera de pantalla, captúrala en un FBO, mapea en un plano. Agrega paralaje copiando el matrixWorldInverse de la cámara principal.
Ilusiones Ópticas — Intercambia materiales/geometrías entre pases de renderizado dentro de useFrame para mostrar versiones alternativas a través de una malla de lente.
Transiciones de Escena — Renderiza dos escenas en dos FBOs, combínalas usando ruido Perlin + uniforme de progreso:
float noise = clamp(cnoise(vUv * 2.5) + uProgress * 2.0, 0.0, 1.0);
vec4 color = mix(colorA, colorB, noise);
Pipelines de Post-Procesamiento — Encadena render targets con materiales shader personalizados en un triángulo de pantalla completa como alternativa a EffectComposer.
8. Refracción, Dispersión y Efectos de Luz
Refracción
Usa la función refract() incorporada de GLSL con eyeVector, worldNormal y la relación IOR:
vec3 refractVec = refract(eyeVector, worldNormal, 1.0 / 1.31);
vec4 color = texture2D(uTexture, uv + refractVec.xy);
Dispersión Cromática
Aplica valores IOR separados por canal de color, dividiendo 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;
Suavízalo con un bucle de muestreo (itera N veces con deslizamiento incremental por canal). Expande el espacio de color de RGB a RYGCBV usando interpolación de Fourier para más control.
Especular + Difusa (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);
Truco de Renderizado de la Parte Trasera
Renderiza primero la parte trasera de la malla (THREE.BackSide), captúrala en un FBO, luego renderiza la parte delantera. La parte trasera especular se refracta/dispersa por la parte delantera, creando una dispersión interna convincente.
9. Post-Procesamiento como Medio Creativo
La Base de Pixelado
vec2 normalizedPixelSize = pixelSize / resolution;
vec2 uvPixel = normalizedPixelSize * floor(uv / normalizedPixelSize);
vec4 color = texture2D(inputBuffer, uvPixel);
Accediendo a Coordenadas Locales de la Celda
vec2 cellUV = fract(uv / normalizedPixelSize); // 0->1 dentro de cada celda
Esta es la clave para esculpir patrones dentro de cada celda de píxel.
Dos Pilares de los Shaders de Post-Procesamiento
- Reasignar/distorsionar coordenadas UV (pixelado, escalonado, desplazamientos)
- Dar forma a cada celda individualmente (patrones basados en luma, SDFs, matrices de umbral)
Técnicas de Patrones
Patrón de Recibo/Barra — Usa luma para controlar el ancho de línea dentro del cellUV de cada celda.
Medio Tono (Halftone) — Dibuja círculos mediante campos de distancia, varía el radio 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);
Medio Tono CMYK — Cuatro rejillas rotadas (C:15deg, M:75deg, Y:0deg, K:45deg), convierte RGB a CMYK, mezcla sustractiva:
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 *=
…
[truncado para la traducción]