Estudio de renderizado volumétrico

Nubes por Raymarching

Estudio de muestreo volumétrico, autosombreado y absorción de luz en Unreal Engine 5.

Mi aportación
Investigación e implementación del shader volumétrico
Plataforma / entorno
Unreal Engine 5
Herramientas y técnicas
Unreal Engine 5HLSLMaterial FunctionsRaymarchingDistance Fields
Nubes por Raymarching — Estudio de muestreo volumétrico, autosombreado y absorción de luz en Unreal Engine 5.

El proyecto de un vistazo

El reto

Entender cómo un campo de densidad muestreado se convierte en un volumen iluminado, con self-shadowing, sombras de la escena y control de los artefactos de muestreo.

El enfoque

Descomponer el efecto en un rayo principal que acumula densidad, rayos secundarios hacia la luz, sombras suaves con los Distance Fields del motor, dithering espacio-temporal y absorción por canal.

Resultado y alcance

Un shader didáctico con etapas inspeccionables por separado. La conclusión principal: el raymarching volumétrico es muy caro incluso en hardware moderno.

Contexto y objetivo

El trabajo de Mike Turitzin, que comparte en redes demostraciones espectaculares de renderizado por raymarching, me dio la idea de replicar la técnica para renderizar nubes. Actualmente estoy desarrollando un motor de raymarching desde cero; este pequeño proyecto fue una forma de quitarme el gusanillo y entender las bases de la técnica dentro de un motor que ya conocía, Unreal Engine 5.

El proyecto no persigue el rendimiento ni la reutilización en producción: es una disección del proceso para entender bien cada pieza.

Qué es el raymarching

En el renderizado convencional, la GPU rasteriza triángulos: superficies sin interior. Una nube no tiene superficie: es un volumen de densidad variable que dispersa y absorbe la luz en todo su interior.

El raymarching resuelve esto avanzando un rayo por cada píxel a pasos discretos a través del volumen y acumulando lo que encuentra en cada paso. Este es el núcleo de RayStep, la función que se ejecuta en cada paso del rayo principal:

float cursample = PseudoVolumeTexture(VolTex, VolTexSampler, saturate(pos),
                                      rmParams.XYFrames, rmParams.NumFrames).r;
if (cursample > 0.001)
{
    float shadowdist = ComputeLighting(rmParams, VolTex, VolTexSampler, pos);  // self-shadowing
    float dfshadow   = ComputeDFShadows(rmParams, pos);                         // sombras de la escena

    // Ley de Beer-Lambert aplicada a la muestra actual
    cursample = 1 - exp(-cursample * rmParams.Density);

    // Acumulamos la luz que llega a este punto y se dispersa hacia la cámara
    lightEnergy   += exp(-shadowdist * rmParams.ShadowDensity) * cursample
                   * transmittance * rmParams.LightColor * dfshadow;
    transmittance *= 1 - cursample;
}

La atenuación sigue la ley de Beer-Lambert: la luz que atraviesa un medio decae exponencialmente con la densidad acumulada en su camino. transmittance guarda cuánta luz del fondo sigue atravesando el volumen, y lightEnergy, cuánta luz dispersada llega a la cámara.

Rayo principal y muestreo de densidad

La nube es un campo de densidad de ruido Perlin 3D dentro de una caja. En lugar de evaluar el ruido en cada muestra, lo leo de una pseudo volume texture: una textura 2D que guarda los cortes del volumen en una rejilla de frames, que Unreal sabe muestrear como si fuera una textura 3D. Para cada píxel, el rayo principal entra en la caja, avanza por ella y acumula las muestras. El kernel, implementado como Material Function con un nodo Custom, llama a RayStep en cada paso y termina con un paso parcial para no pasarse de la salida de la caja:

float3 lightEnergy = 0;
float transmittance = 1;

for (int i = 0; i < rmParams.MaxSteps; i++)
{
    // densidad e iluminación en la posición actual del rayo de vista
    RayStep(rmParams, VolTex, VolTexSampler, CurPos, i, lightEnergy, transmittance, DebugOutput);
    CurPos += -rmParams.LocCamVec;
}

// paso final parcial hasta la salida de la caja
CurPos += rmParams.LocCamVec * (1 - rmParams.FinalStepSize);
RayStep(rmParams, VolTex, VolTexSampler, CurPos, rmParams.MaxSteps, lightEnergy, transmittance, DebugOutput);

return float4(lightEnergy, transmittance);

El número de pasos es el parámetro que más condiciona el resultado. Con menos pasos el muestreo es más barato, pero se pierde detalle, aparece banding y, en casos extremos, la forma de la nube deja de verse. Elegí los valores ajustando las variables y comparando visualmente calidad y coste.

Self-shadowing

Una nube creíble se oscurece en las zonas a las que llega menos luz. Para calcularlo, desde cada punto evaluado por el rayo principal se lanza un segundo rayo hacia la luz direccional. Ese rayo acumula la densidad que encuentra en su camino: cuanta más densidad atraviesa, más ocluido está el punto.

Es la parte más cara del algoritmo, porque multiplica el número de muestras: cada paso del rayo principal lanza su propio rayo de sombra. Dos early exits evitan trabajo que no cambiaría el resultado:

  • El cálculo se detiene al salir de la caja del volumen.
  • También se detiene cuando la densidad acumulada supera un umbral a partir del cual el punto ya se considera completamente en sombra.
Nube con self-shadowing

Nube generada con ruido Perlin 3D, con self-shadowing.

Ambas salidas se ven en ComputeLighting, la función que avanza hacia la luz:

float ComputeLighting(RaymarchParameters rmParams, Texture2D VolTex, SamplerState VolTexSampler, float3 CurPos)
{
    float3 lpos = CurPos;
    float shadowdist = 0;

    for (int s = 0; s < rmParams.ShadowSteps; s++)
    {
        lpos += rmParams.LightVector;
        // muestra de densidad en la posición actual del rayo de luz
        float lsample = PseudoVolumeTexture(VolTex, VolTexSampler, saturate(lpos),
                                            rmParams.XYFrames, rmParams.NumFrames).r;

        // componentes a 1 si lpos está fuera de la caja (coordenadas locales)
        float3 shadowboxtest = floor(0.5 + abs(0.5 - lpos));
        float exitshadowbox = shadowboxtest.x + shadowboxtest.y + shadowboxtest.z;

        if (shadowdist > rmParams.ShadowThreshold || exitshadowbox >= 1)
            break;

        shadowdist += lsample;   // densidad acumulada = oclusión
    }

    return shadowdist;
}

Sombras de la escena con Distance Fields

El self-shadowing no basta: la nube también debe recibir las sombras de los objetos de la escena. Para ello recurrí a los Distance Fields que Unreal ya genera para cada malla, que permiten consultar en cualquier punto la distancia al objeto más cercano.

Desde el punto evaluado se avanza hacia la luz, pero no con un rayo infinitamente fino, sino con un cono que se ensancha al alejarse. Si un objeto entra en el cono, ocluye parte de la luz; cuanto más lejos está el oclusor, más ancho es el cono en ese punto y más suave es la penumbra (soft shadows), como ocurre con las sombras reales.

Como los Distance Fields se consultan en coordenadas de mundo, la función convierte las posiciones a World Space al comenzar.

Nube iluminada solo por la luz que entra por una ventana

Solo la luz que entra por la ventana ilumina la nube.

float ComputeDFShadows(RaymarchParameters rmParams, float3 CurPos)
{
    // posición en la caja -> world space, relativa a la cámara
    float3 dfpos = 2 * (CurPos - 0.5) * GetPrimitiveData(rmParams.MaterialParameters).LocalObjectBoundsMax;
    dfpos = LWCToFloat(TransformLocalPositionToWorld(rmParams.MaterialParameters, dfpos)) - rmParams.CameraPosWS;

    float dftracedist = 1;
    float dfshadow = 1;
    float curdist = 0;
    float DistanceAlongTrace = 0;

    for (int d = 0; d < rmParams.DFSSteps; d++)
    {
        DistanceAlongTrace += curdist;
        curdist = GetDistanceToNearestSurfaceGlobal(dfpos);

        // esfera virtual que crece con la distancia: penumbra más ancha
        float SphereSize = DistanceAlongTrace * rmParams.LightTangent;

        // 0 = totalmente en sombra, 1 = totalmente iluminado
        // cuanto más cerca del eje del cono está el oclusor, más dura es la sombra
        dfshadow = min(saturate(curdist / SphereSize), dfshadow);

        dfpos.xyz += rmParams.LightVectorWS * dftracedist * curdist;
        dftracedist *= 1.0001;
    }

    return dfshadow;
}

Luz ambiental

La luz direccional no es la única fuente: el cielo ilumina la nube desde todas las direcciones. Calcularlo con rayos en todas direcciones sería prohibitivo, así que RayStep lo aproxima con tres muestras de densidad hacia arriba desde el punto actual. Cuanta más densidad hay encima, menos luz de cielo recibe el punto:

shadowdist = 0;
shadowdist += PseudoVolumeTexture(..., saturate(pos + float3(0, 0, 0.25)), ...).r;
shadowdist += PseudoVolumeTexture(..., saturate(pos + float3(0, 0, 0.50)), ...).r;
shadowdist += PseudoVolumeTexture(..., saturate(pos + float3(0, 0, 0.75)), ...).r;

lightEnergy += exp(-shadowdist * rmParams.AmbientDensity) * cursample
             * rmParams.SkyColor * transmittance;

Es una aproximación muy barata, pero suficiente para que la base de la nube quede más oscura y azulada que su parte superior.

Reducir el banding

Como en cualquier raymarching, al reducir el número de pasos aparece banding: el proceso es discreto y el volumen, continuo. Todos los píxeles vecinos muestrean en las mismas profundidades, así que el error es coherente y forma escalones visibles.

Para mitigarlo, desplazo ligeramente cada posición de muestreo a lo largo del vector de cámara, con un patrón que varía por píxel y por frame (dithering espacio-temporal). Ese jitter rompe la coherencia de los errores de cuantización: el escalón se convierte en ruido de alta frecuencia, que el ojo percibe como una transición más suave y que el TAA o el TSR del motor promedian entre frames.

La componente espacial sale de una matriz de Bayer de 4 × 4, y la temporal la desplaza en cada frame:

static const float BayerMatrix4x4[16] = {
     0.0f,  8.0f,  2.0f, 10.0f,
    12.0f,  4.0f, 14.0f,  6.0f,
     3.0f, 11.0f,  1.0f,  9.0f,
    15.0f,  7.0f, 13.0f,  5.0f
};

float get_dither_pattern_value(float2 seedA, float seedB)
{
    int x = int(seedA.x) % 4;
    int y = int(seedA.y) % 4;

    float base_dither_threshold = BayerMatrix4x4[y * 4 + x] / 16.0f;   // patrón espacial: matriz de Bayer 4x4
    float temporal_offset = frac(seedB * 0.38196601125f);              // desplazamiento temporal que cambia en cada frame

    return frac(base_dither_threshold + temporal_offset);
}

Absorción de luz por canal

En el cálculo de la energía lumínica acumulada, el coeficiente de absorción (rmParams.ShadowDensity) no es un escalar sino un vector de tres componentes. Por defecto tiene el mismo valor en los tres canales, pero el shader permite asignar valores distintos a cada uno, de forma que el volumen absorba de forma diferente cada longitud de onda:

lightEnergy += exp(-shadowdist * rmParams.ShadowDensity) * cursample * transmittance * ...;
//                               ^ float3: un coeficiente de absorción por canal

Un canal con poca absorción atraviesa el volumen con facilidad y tiñe las zonas profundas de la nube; uno con mucha absorción desaparece enseguida. Da al equipo de arte un control muy directo sobre cómo transmite la luz el volumen.

Comparativa de dos vectores de absorción

Izquierda: vector de absorción (0, 0.7, 1). Derecha: vector de absorción (1, 0.1, 0).

Lo que aprendí

La lección principal fue de coste: renderizar volúmenes por raymarching es muy caro incluso en hardware moderno. El número de muestras crece con la resolución, los pasos del rayo principal y los pasos de cada rayo de luz, y cada muestra implica una lectura de textura más.

Las técnicas que hacen viables las nubes volumétricas en juegos actuales (renderizar a menor resolución, reproyectar resultados de frames anteriores, saltar el espacio vacío o aproximar la luz con menos muestras) atacan precisamente esas multiplicaciones, y entender de dónde viene el coste fue el mejor punto de partida para estudiarlas en mi propio motor.

← Todos los proyectosContactar ↗