Un paisaje procedural puede comenzar con una función de dos variables: dada una coordenada horizontal (x,z), devuelve una altura y. Esa abstracción permite generar montañas sin modelarlas vértice por vértice, pero una función de ruido no es todavía un terreno renderizable. Entre la función y la imagen hay una secuencia de decisiones: muestreo, triangulación, normales, continuidad espacial, selección de detalle y comunicación con la GPU.
Este artículo desarrolla el recorrido ruido → campo de alturas → malla → chunks → LOD → render, con énfasis en sus invariantes matemáticos y sus compromisos de ingeniería. No se construye un motor 3D ni una demo; los experimentos propuestos están pendientes de ejecución y no se presentan cifras propias de FPS. La referencia principal para el tratamiento de detalle es Terrain Rendering Using GPU-Based Geometry Clipmaps, de Asirvatham y Hoppe.
1. La promesa y el límite de una función h(x,z)
Definimos un terreno como una superficie:
T(x, z) = (x, h(x, z), z)
Para un punto del plano horizontal existe una sola altura. Este modelo se llama heightfield o heightmap cuando está discretizado. Es eficiente porque requiere almacenar una magnitud por muestra y una triangulación regular, pero tiene un límite geométrico: no puede representar una cueva ni un voladizo donde existan varias alturas para la misma posición (x,z). Para esos casos habría que cambiar de representación, por ejemplo a un campo volumétrico y otra técnica de extracción de superficie.
Una altura procedural depende normalmente de una semilla s, una posición en coordenadas globales, un conjunto de parámetros θ y la versión del algoritmo:
h(x, z) = Height(s, x, z, θ, algorithm_version)
El determinismo significa que entradas y reglas idénticas producen el mismo resultado dentro de las garantías de la implementación. La semilla sola no garantiza reproducibilidad si cambian el algoritmo, el orden de operaciones, los tipos de datos o el comportamiento de punto flotante entre CPU y GPU. Para persistir mundos grandes hay que fijar también versión de función y convenciones de coordenadas.
2. Value noise, gradient noise y por qué no son lo mismo
Una distribución de números aleatorios independientes por celda produce una superficie visualmente rugosa, sin correlación espacial. Para obtener formas conectadas necesitamos ruido que varíe suavemente en el espacio.
Value noise: se asigna un valor pseudoaleatorio determinista a cada punto entero de una rejilla y se interpola entre esquinas. Es simple y pedagógico. La interpolación lineal produce cambios bruscos en la pendiente en algunas fronteras; funciones de transición suaves mejoran la continuidad de derivadas.
Gradient noise (Perlin): se asigna un vector gradiente a cada vértice entero. En un punto cualquiera calculamos productos escalares entre gradientes y desplazamientos hacia las esquinas, y los interpolamos. No es lo mismo que interpolar valores aleatorios. La función fade clásica mejorada 6t⁵ − 15t⁴ + 10t³ tiene derivadas convenientes en los extremos de celda.
Simplex noise: utiliza otra partición del espacio y otro patrón de evaluación; es útil comprenderlo como una alternativa de ruido gradiente, no como una palabra intercambiable con Perlin. Las afirmaciones sobre patentes, licencias de implementaciones y rendimiento deben verificarse para el algoritmo y la biblioteca concretos, no inferirse del nombre genérico.
La fuente The Book of Shaders, capítulos de ruido permite inspeccionar cómo la interpolación y los gradientes transforman funciones discretas en texturas continuas. Para un motor real, elegir una implementación depende de estabilidad de API, reproducibilidad, requisitos de licencia y perfil de evaluación.
Una función de ruido que respeta coordenadas negativas
El siguiente fragmento es value noise 2D, deliberadamente distinto de Perlin. Produce muestras deterministas en una grilla infinita de coordenadas enteras, usando un hash de 32 bits con operaciones enteras de JavaScript y una interpolación quintica. Se incluye como pieza matemática verificable, no como generador de terreno completo.
function lattice(ix: number, iz: number, seed: number): number {
let h = (Math.imul(ix, 374761393) ^ Math.imul(iz, 668265263) ^ seed) | 0;
h = Math.imul(h ^ (h >>> 13), 1274126177);
h ^= h >>> 16;
return ((h >>> 0) / 0xffffffff) * 2 - 1;
}
const fade = (t: number): number => t * t * t * (t * (t * 6 - 15) + 10);
const mix = (a: number, b: number, t: number): number => a + (b - a) * t;
function valueNoise(x: number, z: number, seed: number): number {
const ix = Math.floor(x), iz = Math.floor(z);
const tx = fade(x - ix), tz = fade(z - iz);
const a = mix(lattice(ix, iz, seed), lattice(ix + 1, iz, seed), tx);
const b = mix(lattice(ix, iz + 1, seed), lattice(ix + 1, iz + 1, seed), tx);
return mix(a, b, tz);
}
El uso de Math.floor, no truncamiento hacia cero, evita discontinuidades artificiales al cruzar coordenadas negativas. Este hash usa enteros de 32 bits y una normalización a [-1,1] aproximada; no es criptográfico ni afirma distribución estadística perfecta. Para pruebas estrictas de igualdad entre CPU y shaders hay que comparar un mismo algoritmo de enteros, redondeo y formato en ambas plataformas.
3. fBm: superponer escalas no equivale a simular geología
El llamado fractal Brownian motion en gráficos suele implementarse como la suma de varias octavas de ruido con frecuencias crecientes y amplitudes decrecientes:
fBm(x, z) = Σ[k=0..K−1] a_k · noise(f_k x, f_k z)
f_k = f_0 · lacunarity^k
a_k = a_0 · persistence^k
Lacunarity controla cuánto aumenta la frecuencia; persistence, cuánto sobrevive la amplitud de cada escala. Si |noise| ≤ 1, podemos establecer la cota |fBm| ≤ Σ|a_k| y normalizar dividiendo por esa suma cuando sea positiva. Ese método da una cota de amplitud, no fuerza la distribución del resultado a ser uniforme ni garantiza que alcance los extremos -1 y +1.
function fbm(x: number, z: number, seed: number, octaves = 5): number {
let amplitude = 1, frequency = 1, total = 0, norm = 0;
for (let octave = 0; octave < octaves; octave++) {
total += amplitude * valueNoise(x * frequency, z * frequency, seed + octave);
norm += amplitude;
amplitude *= 0.5;
frequency *= 2;
}
return norm > 0 ? total / norm : 0;
}
Una función de tipo ridge transforma valores absolutos para acentuar crestas; domain warping usa otros campos para deformar las coordenadas de entrada y romper alineaciones evidentes. Son operaciones de síntesis visual, no modelos de erosión hidráulica, tectónica o sedimentación. Añadir octavas no «aumenta el realismo» por definición: puede crear ruido de alta frecuencia que la malla no puede representar.
Aliasing y resolución
Si el espaciado espacial de la rejilla es Δ, la frecuencia más alta representable en una dimensión no debería superar aproximadamente la frecuencia de Nyquist 1/(2Δ) en ciclos por unidad. Octavas superiores pueden aliasar y producir patrones que cambian al mover la cámara o al reducir el LOD. Una generación robusta filtra o elimina frecuencias no representables en cada nivel, en lugar de evaluar todas las octavas idénticamente en todas las resoluciones.
4. Del campo de alturas a triángulos
Un chunk de N × N muestras contiene (N−1) × (N−1) celdas cuadradas. Si dividimos cada celda en dos triángulos, obtenemos exactamente:
vértices = N²
triángulos = 2(N−1)²
índices = 6(N−1)²
Para N = 65, eso equivale a 4.225 vértices, 8.192 triángulos y 24.576 índices. Estas cifras son conteos matemáticos, no un benchmark ejecutado. Si se comparten vértices mediante un index buffer, evitamos repetir posiciones en cada triángulo; la elección entre índices de 16 y 32 bits depende del número de vértices indexables y del diseño de buffers.
Un vértice local (i,j) se coloca en coordenadas de mundo usando un origen global (X0, Z0) y el paso de muestreo Δ:
x = X0 + iΔ
z = Z0 + jΔ
y = h(x,z)
El orden de índices determina la orientación de cada triángulo (winding). Si el sistema usa eje Y vertical y superficies miran hacia arriba, debemos mantener el mismo orden de triángulos para que el back-face culling no borre parches enteros. Nunca deducir la orientación simplemente del nombre de los ejes: depende de cómo se construyan los índices y de la convención de cámara.
5. Normales: las alturas no contienen la iluminación
Para T(x,z) = (x,h(x,z),z), dos vectores tangentes son (1, h_x, 0) y (0, h_z, 1). Con la orientación que apunta hacia arriba, una normal es proporcional a:
n(x,z) = normalize(−∂h/∂x, 1, −∂h/∂z)
Podemos aproximar ambas derivadas mediante diferencias centrales, usando alturas a ambos lados del punto. En zonas planas h_x = h_z = 0, de modo que n = (0,1,0). Es un caso de prueba sencillo y útil. Para un borde de chunk, no debemos calcular la derivada con muestras faltantes y confiar en que el chunk vecino hará exactamente lo mismo. Hay que consultar muestras globales adicionales o un sistema compartido de normales.
Si las normales se promedian a partir de triángulos, el resultado depende del triángulo escogido, su área y los vecinos disponibles. Una función continua de altura puede producir costuras visibles de iluminación incluso con posiciones perfectamente coincidentes si cada chunk promedia sus normales de modo independiente.
Las coordenadas UV suelen derivarse de x,z globales o locales según la textura. UV locales reiniciadas en cada chunk pueden introducir discontinuidades evidentes en materiales repetidos. Elegir UV globales evita ciertas costuras, pero en mundos muy grandes también requiere gestionar precisión y escalas de muestreo.
6. Chunks: la frontera debe ser una identidad matemática
Supongamos que cada chunk cubre M intervalos de anchura Δ, por tanto posee M+1 muestras por lado. Para un índice de chunk (cx, cz) y muestra local (i,j) definimos:
x_global = (cx·M + i)·Δ
z_global = (cz·M + j)·Δ
El borde derecho del chunk cx usa i = M; el borde izquierdo de cx+1 usa i = 0. Ambos producen exactamente las mismas coordenadas algebraicas. Si calculamos h mediante la misma función determinista global, obtenemos alturas coincidentes salvo posibles diferencias de redondeo debidas al orden de operaciones.
Por eso el ejemplo anterior calcula primero el índice global entero y luego escala: permite comparar muestras compartidas de manera inequívoca. La semilla pertenece al mundo, no al chunk. Dar a cada chunk una semilla distinta sin garantizar continuidad provoca escalones en el borde aunque cada textura individual parezca suave.
El mismo principio debe mantenerse con coordenadas negativas. Un mundo con cámara a la izquierda del origen tiene chunks con índices negativos; dividir por M y truncar hacia cero puede asignar una posición al chunk equivocado. La convención correcta para particionar en coordenadas negativas depende de floor, no de un cast entero accidental.
Tres tipos de costura
Geométrica: posiciones compartidas no coinciden; aparece una grieta real. De shading: alturas iguales pero normales o materiales distintos; se ve una línea luminosa. De LOD: parches vecinos usan triangulaciones diferentes; un lado introduce vértices intermedios que el otro no representa, creando T-junctions y posibles huecos. Resolver una de estas costuras no implica resolver las otras dos.
7. LOD: gastar triángulos donde tienen valor visual
En un terreno extenso no conviene renderizar la misma densidad geométrica a un kilómetro que a un metro de la cámara. Level of Detail reduce geometría o frecuencia de muestras a cambio de un error visual controlado. La distancia es un proxy útil, pero el criterio ideal considera error proyectado en pantalla: un acantilado lejano puede necesitar más detalle que una llanura cercana.
Geomipmapping divide el terreno en bloques y selecciona una versión de malla por bloque. Es directo de gestionar pero debe resolver saltos de LOD; puede usar bordes adaptados (stitching), skirts o morfología geométrica para limitar grietas y popping. Las skirts ocultan huecos dibujando geometría adicional, pero no corrigen por sí solas la continuidad de todas las normales o materiales.
Geometry clipmaps conservan ventanas de rejillas regulares anidadas alrededor de la cámara. Las escalas se organizan en anillos; cuando avanza el observador, se actualizan las regiones que entran en las ventanas. Asirvatham y Hoppe explican cómo representar alturas mediante texturas y reutilizar una geometría regular para generar detalle, así como transiciones geomorfológicas entre niveles. No se trata de «un quadtree más» ni garantiza por sí mismo ausencia de artefactos: la actualización, el filtrado de alturas y el blending de niveles son partes imprescindibles del método.
Una arquitectura de LOD requiere fijar también presupuesto de memoria, criterio para cargar y liberar chunks, margen de precarga y comportamiento cuando el generador no termina a tiempo. Mostrar un chunk de baja resolución temporalmente puede ser preferible a bloquear el render, pero la transición debe explicarse y medirse.
8. ¿Generar alturas en CPU o en GPU?
Hay varias arquitecturas legítimas, no una dicotomía «CPU lenta / GPU rápida»:
| Arquitectura | Qué calcula CPU | Qué hace GPU | Riesgo principal |
|---|---|---|---|
| Malla generada en CPU | Alturas, normales, índices | Rasteriza malla | Subidas de buffers y CPU para chunks nuevos |
| Heightmap generado en CPU | Alturas | Muestrea texturas y desplaza vértices | Transferencia de texturas, selección de formato |
| Heightmap generado en GPU | Parámetros y scheduling | Genera alturas en compute/render pass y dibuja | Dependencias entre pasadas y depuración |
| Ruido por vértice | Coordenadas, semilla | Evalúa función directamente en vertex shader | Repetición de cálculos y coherencia CPU/GPU |
WebGL2 permite usar vertex y fragment shaders, buffers, texturas y framebuffers; no expone un compute shader general como WebGPU. Puede resolver tareas numéricas mediante render-to-texture, dentro de sus limitaciones de formato, capacidades y readback. WebGPU dispone de compute passes y storage resources, pero sus capacidades deben comprobarse en el dispositivo efectivo: usar WGSL no elimina requisitos de alineación, sincronización ni soporte de navegadores.
Una simulación/renderizador que requiere colisiones en CPU puede verse obligado a duplicar el cálculo de alturas o leer datos de vuelta desde GPU; eso invalida una comparación ingenua que solo mida el tiempo del shader. Las transferencias y esperas por GPU pueden dominar el pipeline si se sincroniza en cada frame.
9. Precisión a gran escala
En mundos grandes, sumar posiciones globales de magnitud elevada en float32 reduce la resolución disponible para pequeños desplazamientos. Es común guardar coordenadas del mundo en mayor precisión en CPU y enviar a la GPU posiciones relativas a la cámara o al origen local del chunk. Esto reduce jitter sin exigir que cada operación del shader tenga precisión de 64 bits.
La reproducibilidad entre plataformas tiene otra frontera: evaluar las mismas octavas con distinto orden de suma, FMA, tipos y formatos de textura puede producir alturas ligeramente distintas. Para una aplicación donde la física depende de la altura, conviene definir una fuente de verdad de colisión y una tolerancia geométrica explícita, en vez de presuponer coincidencia bit a bit entre JavaScript y WGSL.
10. Un laboratorio que permite distinguir errores
El dossier propone una construcción incremental. La convertiría en una especificación de pruebas, no en una demostración ya existente:
- Campo determinista: mismo
(seed, x, z, versión)produce la misma altura, incluso con coordenadas negativas. - Octavas: registrar parámetros y verificar que cada frecuencia agregada es representable a la resolución de muestreo.
- Plano analítico: usar
h=constantey confirmar que todas las normales apuntan hacia arriba y las alturas son idénticas. - Malla: comprobar conteos
N²,2(N−1)²e índices dentro de rango, además del winding. - Chunks: comparar exactamente las coordenadas globales y alturas de muestras compartidas de vecinos horizontales y verticales.
- LOD: inspeccionar costuras de geometría y normales en pares de niveles distintos; registrar error proyectado y popping.
- Rendimiento: separar generación CPU, carga de recursos, tiempo GPU, draw calls, triángulos visibles, memoria y latencia de streaming.
En una comparación entre estrategias CPU y GPU usaríamos el mismo terreno lógico, cámara, viewport, resolución de salida, semilla, filtros y presupuesto de memoria. Registraríamos versión de navegador, dispositivo, resolución física, límites gráficos y calentamiento. No sería válido comparar una malla CPU con geometría muy detallada contra una GPU que renderiza menos triángulos y llamar «aceleración GPU» a la diferencia.
Los casos de referencia deben incluir una llanura, una pendiente analítica h(x,z)=ax+bz, un campo fractal suave y un par de chunks con LOD diferente. Un resultado esperado no debe confundirse con una medición: que dos bordes deberían coincidir es una condición verificable; decir que esta implementación ya los une sin errores exigiría ejecutar el código del motor.
11. De terreno generado a mundo convincente
La altura sola aporta silueta. Para crear un paisaje creíble hay que componer materiales por altitud y pendiente, humedad, temperatura, erosión, drenaje y vegetación. Son modelos adicionales: una textura de nieve aplicada por altitud no simula acumulación física de nieve; un patrón de ruido elevado no simula erosión geológica. Pueden ser decisiones artísticas perfectamente válidas siempre que no se describan como validación científica.
La conclusión de ingeniería es que el terreno procedural no se optimiza únicamente acelerando el ruido. La malla, la política de LOD, la continuidad de costuras, la precisión y los movimientos de datos suelen ser tan importantes como la función que genera alturas. El camino de implementación correcto es aislar estas responsabilidades y verificarlas de forma reproducible.
Lecturas y fuentes
- Arul Asirvatham y Hugues Hoppe — Terrain Rendering Using GPU-Based Geometry Clipmaps, GPU Gems 2. Rejillas anidadas, transiciones y uso de vertex textures.
- Hugues Hoppe — publicación y materiales del artículo de geometry clipmaps. Fuente del autor para revisar los supuestos del enfoque.
- Patricio González Vivo y Jen Lowe — The Book of Shaders, ruido. Explicación visual de funciones de ruido en shaders.
- MDN — WebGL2RenderingContext. Contrato del pipeline WebGL2.
- MDN — WebGPU API. Compute shaders y límites de dispositivos.
Ampliaciones visuales previstas: comparación animada de ruido y fBm, continuidad de dos chunks y anillos de LOD. La portada y un diagrama conceptual del pipeline ya están incorporados; no hay motor 3D ni demostración ejecutable. Las especificaciones adicionales continúan en docs/BLOCK-08-FIGMA-SHOTLIST.md.