Un visor 3D de producto funciona en local en una tarde. En producción aparecen problemas que la demo no enseña, como el peso del modelo, la escala de cada exportación, la luz, el scroll atrapado y la medición. Este artículo recoge cómo los resuelvo con React Three FiberGlosarioReact Three Fiber (R3F)React Three Fiber (R3F) es un renderizador declarativo de Three.js para React. Permite construir escenas 3D interactivas utilizando componentes React reutilizables con gestión de estado nativa y ciclo de vida de React., a partir del visor de la camiseta oficial de una 10K, un caso real en producción.
La página primero, el 3D después
Three.js, sus utilidades y el modelo suman cientos de kilobytes que la primera pintura no necesita. Importar el visor con lazy mueve todo ese peso a un trozo aparte que solo se descarga cuando la página lo monta.
const TShirtViewer = lazy(() => import('../components/3d/TShirtViewer'));
export const TShirt3DPage = () => (
<>
{/* Título, textos y detalles se pintan sin esperar a WebGL */}
<Suspense fallback={<Loader />}>
<TShirtViewer color="#ffffff" />
</Suspense>
</>
);El contenido de la página se pinta primero, y el visor entra cuando llega. Con esa separación, el visor no bloquea el FCPGlosarioFCP (First Contentful Paint)First Contentful Paint (FCP) es una métrica de rendimiento que mide el tiempo transcurrido desde que el usuario inicia la carga de la página hasta que el navegador dibuja el primer fragmento de contenido (texto, imagen o gráfico vectorial) en la pantalla. ni el LCPGlosarioLCP (Largest Contentful Paint)Largest Contentful Paint (LCP) es una métrica clave de Core Web Vitals que mide el tiempo necesario para renderizar y pintar el elemento visual o bloque de texto más grande en la pantalla (usualmente la imagen Hero o banner principal). de la página.
El modelo de este caso viajaba como OBJ, de unos 1,7 MB, con una textura JPG de 380 KB. Un GLB comprimido con Draco o meshopt pesa bastante menos y es la mejora más rentable si el modelo crece.
Un tamaño fijo para cualquier modelo
Cada diseñador exporta a una escala distinta. En lugar de ajustar el modelo a mano, el visor lee su caja envolvente y lo lleva a un tamaño fijo, centrado en el origen. Solo cuentan las mallas visibles.
const { positionOffset, scale } = useMemo(() => {
scene.updateMatrixWorld(true);
const box = new THREE.Box3();
scene.traverse((child) => {
if (child.isMesh) box.expandByObject(child);
});
const center = box.getCenter(new THREE.Vector3());
const size = box.getSize(new THREE.Vector3());
const maxDim = Math.max(size.x, size.y, size.z);
const targetSize = 2.2;
return {
positionOffset: new THREE.Vector3(-center.x, -center.y + yOffset, -center.z),
scale: maxDim > 0 ? targetSize / maxDim : 1,
};
}, [scene, yOffset]);El parámetro yOffset sube o baja el modelo respecto al centro, útil cuando la prenda tiene el peso visual en la mitad superior.
OBJ y GLTF no leen igual la textura
OBJ y GLTF no coinciden en la orientación de la textura. Con OBJ se invierte el eje vertical, con GLTF no. Una pequeña factoría decide según la extensión y deja el resto del visor ajeno al formato.
function ModelFactory({ url, color, textureUrl, yOffset = 0 }) {
const extension = url.split('.').pop().toLowerCase();
if (extension === 'glb' || extension === 'gltf') {
return <GltfModel url={url} color={color} textureUrl={textureUrl} flipY={false} yOffset={yOffset} />;
}
return <ObjModel url={url} color={color} textureUrl={textureUrl} flipY={true} yOffset={yOffset} />;
}La textura se marca con el espacio de color sRGB. Sin ese ajuste, los colores de marca salen apagados.
texture.colorSpace = THREE.SRGBColorSpace;
texture.flipY = flipY;
texture.needsUpdate = true;Luces que giran como en un escaparate
Una luz fija deja la tela plana. Un grupo de luces direccionales que gira despacio alrededor del modelo mueve las sombras y marca el relieve de las arrugas, como en un escaparate. Con useFrame y el delta de cada fotograma, la velocidad no depende de la tasa de refresco del dispositivo.
function RotatingLights() {
const groupRef = useRef();
useFrame((state, delta) => {
if (groupRef.current) groupRef.current.rotation.y += delta * 0.4;
});
return (
<group ref={groupRef}>
<directionalLight position={[4, 2, 4]} intensity={3} color="#C4AA93" />
<directionalLight position={[-4, 1, -4]} intensity={5} color="#5A2030" />
<directionalLight position={[0, 4, 0]} intensity={3} color="#ffffff" />
</group>
);
}Los colores de las luces salen de la paleta de la marca, y así el modelo parece parte de la web.
Nadie se queda atrapado en el visor
Arrastrar un modelo 3D en una pantalla táctil, o girar la rueda sobre él, puede dejar al usuario atrapado dentro del visor sin poder seguir bajando por la página. La solución es arrancar el visor en pausa, con los eventos del puntero desactivados, y activarlo a demanda con un botón.
const [isActive, setIsActive] = useState(false);
<div className={isActive ? 'pointer-events-auto cursor-grab' : 'pointer-events-none'}>
<Canvas camera={{ position: [0, 0, 4], fov: 40 }}>
<OrbitControls
enabled={isActive}
enableZoom={isActive}
enablePan={false}
minDistance={1.5}
maxDistance={4}
minPolarAngle={Math.PI / 6}
maxPolarAngle={Math.PI / 1.5}
/>
{/* modelo y luces */}
</Canvas>
</div>
{!isActive && <button onClick={() => setIsActive(true)}>Activar vista 3D</button>}Los límites de distancia y de ángulo polar mantienen la cámara dentro de un rango útil, sin que el usuario se pierda bajo la prenda ni se aleje hasta no verla. Con enablePan desactivado, el modelo siempre vuelve al centro. En este caso la pausa se aplicó en escritorio y en móvil, porque la rueda del ratón también roba el scroll.
Sin WebGL, nunca un recuadro vacío
Dos comprobaciones evitan un recuadro vacío. La primera, si el navegador no ofrece contexto WebGL, muestra un aviso en lugar del visor.
useEffect(() => {
try {
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
if (!gl) setWebGLSupported(false);
} catch {
setWebGLSupported(false);
}
}, []);La segunda, que uso en mi propia web, sirve una imagen estática en móvil o cuando el usuario pide menos movimiento.
const reduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
const showStatic = isMobile || reduced;
return showStatic ? <img src={STATIC_IMAGE} alt="Camiseta en 3D" width="800" height="600" /> : <ShirtScene />;La imagen con width y height explícitos reserva su hueco y evita saltos de diseño (CLSGlosarioCLS (Cumulative Layout Shift)Cumulative Layout Shift (CLS) es una métrica de Core Web Vitals que mide la frecuencia y la magnitud con la que los elementos visibles en la pantalla cambian de posición de forma inesperada durante la carga de la página.).
Cada giro, un evento en Analytics
Un visor 3D que no se mide no demuestra su valor. Con cada gesto convertido en evento de Google Analytics, el equipo puede saber cuántas personas lo activan, cuántas lo giran y cuántas lo amplían.
trackEvent('activate_3d', { category: 'T-Shirt 3D', label: 'Desktop Activation' });
<OrbitControls
onStart={() => trackEvent('interact_3d_tshirt', { category: 'T-Shirt 3D', label: 'Orbit Start' })}
/>Los botones de acercar y alejar emiten sus propios eventos, igual que la salida del visor. Eso separa a quien mira de quien explora. Cómo convertir esos eventos en informes comparables entre ediciones y por patrocinador se explica en SEO para la web de un evento deportivo.
Siete comprobaciones antes de publicar
- El visor se importa en diferido y el contenido de la página no depende de él.
- La escala y el centrado salen del modelo, no de ajustes manuales.
- Textura en sRGB y orientación según el formato.
- Luces con la paleta de la marca y velocidad basada en
delta. - Visor en pausa hasta que el usuario lo activa, con límites de cámara.
- Aviso sin WebGL e imagen estática con menos movimiento.
- Un evento de analítica por gesto relevante.
Un visor que cumple estos siete puntos convive con el rendimiento de la página y produce datos que un patrocinador puede usar.