En Journey to a Black Hole sigo un rayo hacia atrás desde la cámara por cada píxel astronómico. Su recorrido determina qué termina ahí: el cielo, la luz del disco o negro donde el rayo queda capturado.

Así funciona la versión de Schwarzschild, desde el rayo de cámara hasta los píxeles finales. Los ejemplos WGSL son fragmentos abreviados del renderizador. El código enlazado tiene los imports, los bindings y la configuración completa de Bevy.

Ejecutá la referencia

El proyecto usa Rust y Bevy 0.19.1. Los ejemplos corresponden al commit bd964932. Con Rust 1.95 o posterior instalado:

git clone https://github.com/furkanmamuk/journey-to-a-black-hole.git
cd journey-to-a-black-hole
git checkout bd964932ee1751ea65e2cb2c403cbd50589b0468
cargo run --release --locked -- --preset 2

La configuración probada es Windows/Vulkan con una RTX 4060. Otros equipos y backends no están verificados y esta revisión no tiene una versión jugable en el navegador. También hay una descarga para Windows en itch.io.

Dejá seleccionado Schwarzschild. F2 oculta el disco, F7 quita la presentación cuantizada y G muestra la cuadrícula celeste. Así tenés una vista clara de la lente gravitacional mientras trabajás en el cálculo de los rayos.

Unidades y coordenadas

Todas las posiciones del cálculo son relativas al agujero negro. Restá su posición en el mundo a la posición de la cámara antes de trazar los rayos.

Uso unidades geometrizadas:

G = c = 1
rs = 2M

rs es el radio de Schwarzschild; M es la masa expresada como longitud. Poner rs = 1 facilita trabajar con la escena. Una cámara en el radio 20 queda a veinte radios de Schwarzschild. En unidades físicas, rs = 2GM/c².

  • El horizonte de sucesos está en r = rs.
  • La órbita circular de los fotones está en r = 1.5rs.
  • La órbita circular estable más interna de la materia del disco está en r = 3rs.

En el código, x es la posición, r = length(x) y v = dx/dlambda. Son coordenadas cartesianas areales: r es el radio areal de Schwarzschild, aunque las distancias físicas en esta geometría no sean globalmente euclidianas.

lambda es el parámetro afín del rayo. No es el tiempo de la cámara ni el tiempo propio del fotón. Al normalizar a uno el módulo de la energía conservada del fotón, un paso de lambda tiene unidades de longitud. Las notas matemáticas, en inglés, usan la misma convención.

De un píxel a un rayo

El shader de pantalla completa convierte la coordenada UV de cada fragmento en una dirección usando la base de la cámara:

fn camera_ray(
    uv: vec2<f32>,
    forward: vec3<f32>,
    right: vec3<f32>,
    up: vec3<f32>,
    aspect: f32,
    tan_half_fovy: f32,
) -> vec3<f32> {
    let q = uv * vec2<f32>(2.0, -2.0) + vec2<f32>(-1.0, 1.0);
    return normalize(
        forward
        + right * q.x * aspect * tan_half_fovy
        + up * q.y * tan_half_fovy
    );
}

forward apunta hacia la escena. Los vectores de la base son ortonormales, aspect es el ancho dividido por la altura y tan_half_fovy es la tangente de la mitad del campo de visión vertical. Acá el origen UV está arriba a la izquierda; cambiá el signo vertical si tu pasada usa otra convención.

Ya podés usar esa dirección para muestrear un cubemap o una cuadrícula celeste. Las estrellas deberían mantener una dirección fija en el mundo mientras gira la cámara. Mi shader del cielo genera estrellas deterministas en mapas direccionales superpuestos. La entrada del fragmento muestra cómo el rayo de cámara llega a esa búsqueda.

Antes de integrar, hay que convertir la dirección local de la cámara a las coordenadas usadas. Para un observador estático fuera del horizonte:

er = x / r
mu = dot(d, er)
f0 = 1 - rs / r0

v = mu er + (d - mu er) / sqrt(f0)

d es la dirección unitaria de cámara, r0 es el radio del observador y er apunta radialmente hacia afuera. La conversión conserva la parte radial y multiplica la tangencial por 1/sqrt(f0):

struct RayState {
    x: vec3<f32>,
    v: vec3<f32>,
}

// Preconditions: d is a unit local direction; r0 > rs > 0.
fn initial_state(x: vec3<f32>, d: vec3<f32>, rs: f32) -> RayState {
    let r0 = length(x);
    let er = x / r0;
    let mu = dot(d, er);
    let f0 = 1.0 - rs / r0;
    let v = mu * er + (d - mu * er) / sqrt(f0);
    return RayState(x, v);
}

No normalices v después. Es una derivada respecto de coordenadas y su módulo lleva la normalización afín de las ecuaciones. La cámara también debe permanecer fuera del horizonte. En este renderizador, moverla produce una secuencia de vistas de observadores estáticos; el cálculo no incluye la transformación por la velocidad física de la cámara ni la aberración que produciría.

Seguir la curva

La ecuación espacial de la órbita nula de Schwarzschild es:

L = cross(x, v)
L2 = dot(L, L)

dx/dlambda = v
dv/dlambda = -(3/2) rs L2 x / r^5

L es el momento angular conservado por unidad de energía normalizada del fotón y tiene unidades de longitud. Calculá L2 una sola vez a partir del estado inicial.

La ecuación sale de la restricción radial nula:

vr^2 + (1 - rs/r) L2/r^2 = 1
vr = dot(x, v) / r

Al derivarla aparece un término centrífugo y una corrección relativista. El término centrífugo se cancela al escribir la aceleración vectorial cartesiana, y queda:

// Evaluate only on the supported exterior ray path.
fn acceleration(x: vec3<f32>, l2: f32, rs: f32) -> vec3<f32> {
    let r2 = dot(x, x);
    return -1.5 * rs * l2 * x / (r2 * r2 * sqrt(r2));
}

Para un rayo radial, L2 = 0. Su recorrido espacial sigue siendo recto, incluso si va hacia adentro y es capturado. El shader completo agrega una protección para el denominador.

Uso velocity Verlet de segundo orden para el recorrido de Schwarzschild. Avanza la posición, evalúa allí la aceleración y después actualiza la velocidad:

a0 = acceleration(x)
x1 = x + h v + (h^2 / 2) a0
a1 = acceleration(x1)
v1 = v + (h / 2) (a0 + a1)
fn verlet_step(y: RayState, h: f32, l2: f32, rs: f32) -> RayState {
    let a0 = acceleration(y.x, l2, rs);
    let x1 = y.x + h * y.v + 0.5 * h * h * a0;
    let a1 = acceleration(x1, l2, rs);
    let v1 = y.v + 0.5 * h * (a0 + a1);
    return RayState(x1, v1);
}

El bucle que lo llama tiene que mantener seguros esos pasos. Limitá o acortá h para que el extremo de prueba quede fuera del horizonte antes de evaluar a1. Comprobar solo la posición anterior no alcanza.

Un paso fijo pequeño sirve para una primera versión a una distancia moderada. La regla del proyecto dependiente de la distancia empieza con:

h = step_scale * min(0.16r, 0.12r^2 / (sqrt(L2) + 0.01))

Después limita h y el desplazamiento espacial usando length(v). El 0.01 es un regularizador numérico en unidades de la escena. Es una heurística: no tiene una estimación local del error y el paso mínimo fijo termina limitando el refinamiento. Para comparar con la demo, usá la política completa de pasos, con todos sus límites.

El bucle de trazado, en pseudocódigo:

state = initial_state(camera_position, camera_direction)
L2 = squared_length(cross(state.x, state.v))

repeat up to the step budget:
    if the affine-distance budget is exhausted:
        return UNFINISHED
    if radius is inside the capture threshold:
        return CAPTURED
    if outside the escape radius and moving outward:
        return SKY(normalize(state.v))

    choose a step
    next = verlet_step(state, step, L2)
    test the segment for a disk event
    state = next

return UNFINISHED

La captura se detiene en 1.015rs, un margen numérico de seguridad fuera del horizonte. Escapar requiere un radio suficientemente grande y movimiento hacia afuera. Ahí, una copia normalizada de v da la dirección del cielo. Mantené la velocidad original sin normalizar durante la integración.

El proyecto permite un máximo de 768 pasos. Los rayos difíciles todavía pueden agotar ese presupuesto, por eso el resultado distingue incompleto de capturado. F11 muestra los incompletos en magenta; en la imagen normal son negros y se pueden confundir con parte de la sombra.

Intersecciones con el disco

El disco es un anillo delgado que pasa por el origen y tiene una normal unitaria n. Para Schwarzschild, empezá con el borde interior en 3rs. Un color brillante constante alcanza para revisar la forma antes de agregar emisión.

La mayoría de los rayos cruza el disco entre las muestras de integración. Compará las distancias con signo al plano en los extremos de cada paso:

d0 = dot(old_position, n)
d1 = dot(new_position, n)

if d0 and d1 have opposite signs:
    t = d0 / (d0 - d1)
    hit = mix(old_position, new_position, t)

Aceptá la intersección cuando inner_radius < length(hit) < outer_radius. Protegé el denominador y usá una regla de cruce semiabierta consistente para no contar dos veces una intersección que cae justo en un extremo.

La interpolación lineal funciona para segmentos cortos. El cálculo de eventos del proyecto usa interpolación cúbica de Hermite con las posiciones y velocidades de los extremos y después diez iteraciones de bisección.

Los dos métodos necesitan que el cruce quede delimitado. Un paso grande puede atravesar el plano dos veces y dejar ambos extremos del mismo lado. Los rayos rasantes también requieren cuidado, y uno exactamente coplanar es singular para este modelo sin espesor. Revisá las vistas inclinadas con pasos más chicos y mantené la cámara un poco por encima del plano del disco.

Un disco opaco puede detener el trazado en la primera intersección válida. El mío acumula emisión con una transmisión aproximada de 0.04 por cruce y se detiene después de que dos cruces emisores dejan una transmisión despreciable. El resultado es una superficie emisora delgada, sin cálculo de plasma volumétrico.

Ahora moverte hacia un costado cambia qué partes del disco alcanzan los rayos. Algunas aparecen por encima y por debajo del centro oscuro:

Un disco visto casi de canto cuya imagen se curva por encima y por debajo del centro oscuro

Emisión del disco

El perfil radial del disco es:

F(r) = (r_in/r)^3 (1 - sqrt(r_in/r))
T(r) = T_scale * F(r)^(1/4)

F es el flujo bolométrico relativo sin dimensiones, r_in es el radio interior y T_scale está en kelvin. El valor predeterminado es 18.000 K. El factor de torque nulo lleva el flujo a cero en el borde interno y deja un máximo más afuera.

Es un perfil newtoniano simplificado sin torque. La escala de temperatura se puede ajustar; no se infiere de la masa y la tasa de acreción. Un modelo de disco completamente relativista necesitaría otro cálculo del flujo.

El shader espectral muestrea el espectro de Planck en 41 longitudes de onda entre 380 y 780 nm, integra con las funciones de correspondencia de color CIE y convierte XYZ a sRGB lineal. Usa esta forma espectral:

B(lambda, T) ∝ 1 / [lambda^5 (exp(14387.76877 / (lambda T)) - 1)]

Acá lambda es la longitud de onda en micrómetros, no el parámetro afín, y T está en kelvin. Las constantes físicas y el intervalo común entre longitudes de onda están absorbidos en la normalización. El color se conserva en HDR lineal. La tabla CIE tiene su propia atribución y licencia, que deben acompañar los datos si los reutilizás.

Corrimiento al rojo y movimiento orbital

La gravedad y el movimiento del disco cambian la frecuencia que llega al observador. Para el disco de Schwarzschild:

M = rs / 2
Omega = sqrt(M / r^3)
ut = 1 / sqrt(1 - 3M/r)
L_n = dot(n, cross(hit_position, hit_velocity))
f0 = 1 - rs/r0

g = 1 / [sqrt(f0) ut (1 + Omega L_n)]

Omega es la velocidad angular del emisor circular en tiempo de coordenadas. ut, que normalmente se escribe u^t, es la componente temporal contravariante de su cuadrivelocidad. L_n es el momento angular con signo del rayo respecto de la normal del disco. La relación de frecuencias g es observada sobre emitida, así que los valores mayores que uno indican un corrimiento al azul.

El signo más de 1 + Omega L_n aparece porque trazamos hacia atrás. Con signatura métrica (-,+,+,+), el rayo hacia atrás tiene momento temporal covariante conservado p_t = +1. Antes de usar una fórmula basada en el momento de un fotón que avanza hacia adelante hay que convertir su signo.

El factor u^t incluye el Doppler transversal además de la contribución gravitatoria. La implementación también contempla rotación; estas ecuaciones la fijan en cero.

La emisión térmica se ve a temperatura gT. La intensidad bolométrica se transforma con g^4; la intensidad por frecuencia usa g^3 con un argumento de frecuencia desplazado. La función thermal_rgb del disco divide su integral de color por T^4, dando color por unidad de flujo bolométrico relativo:

// thermal_rgb must have the repository's per-bolometric-flux normalization.
let observed_temperature = emitted_temperature * g;
let colour = thermal_rgb(observed_temperature)
    * relative_flux
    * pow(g, 4.0)
    * artistic_hdr_scale;

Esa normalización importa. Si tu función devuelve una intensidad de Planck completa sin normalizar a gT, multiplicar otra vez por g^4 cuenta dos veces el cambio de energía. El shader final también atenúa los bordes y aplica una escala artística de brillo HDR.

La pasada de Bevy

Del lado de Rust, la estructura de uniformes usa ShaderType y campos Vec4 para coincidir con la disposición WGSL. Revisá la alineación si la cambiás, especialmente alrededor de vectores de tres componentes.

La pasada de renderizado lee la escena HDR existente, su textura de profundidad y el buffer de configuración. Dibuja un triángulo de pantalla completa en un destino Rgba16Float antes del posprocesado posterior.

Los píxeles del primer plano se conservan. El shader solo traza donde la profundidad vale cero, que en la convención de profundidad invertida de Bevy significa fondo sin cubrir. Revisá esa convención si lo llevás a otro motor.

Por eso la sonda mantiene su proyección de perspectiva habitual. No recibe lente gravitacional ni queda oculta por el agujero negro. Para soportarlo harían falta intersecciones con la geometría de primer plano a lo largo de los rayos curvos; la textura de profundidad actual solo contiene la proyección ordinaria de los objetos desde la cámara.

El tratamiento de píxeles

La presentación gruesa viene después de la escena HDR:

HDR scene and geodesic background
    → bloom and exposure
    → tone mapping
    → area reduction
    → tonal quantization and ordered dither
    → nearest-neighbour expansion
    → UI

Por defecto renderizo HDR a 960×540 y lo reduzco a una cuadrícula de presentación de 480×270 antes de ampliarlo. El shader de reducción promedia el área cubierta de origen con pesos de superposición, incluida la cobertura fraccionaria de píxeles. Eso reduce el parpadeo de los detalles brillantes y finos en comparación con tomar una sola muestra por celda.

La cuantización tonal redondea los valores perceptuales de los canales a un número configurable de niveles. Un patrón Bayer fijo de 4×4 reparte el error de redondeo por la cuadrícula y la ampliación por vecino más cercano mantiene las celdas nítidas. Mantené estable el patrón de tramado entre fotogramas.

F7 omite este tratamiento. Ayuda a separar los cambios del cálculo de rayos de los introducidos por el mapeo tonal y la reducción.

Comprobar el resultado

Con el disco y el bloom desactivados, seguí la restricción nula a lo largo de cada rayo:

residual = abs(vr^2 + (1 - rs/r) L2/r^2 - 1)

Debería permanecer cerca de cero. El shader registra una versión normalizada del residuo máximo encontrado. Compará también cross(x, v) con su valor inicial para comprobar la deriva del momento angular.

Hay casos de referencia útiles:

  1. Los rayos radiales hacia adentro y afuera tienen trayectorias espaciales rectas. El rayo que va hacia adentro llega al umbral de captura.
  2. Para un rayo que llega desde lejos, la deflexión de campo débil se aproxima a 2rs/b radianes, donde b es su parámetro de impacto.
  3. El parámetro de impacto crítico de entrada es b_critical = 3sqrt(3)rs/2. Los rayos cercanos a cada lado deberían separarse en captura y escape al refinar la integración.
  4. Para una cámara estática en r0 > 1.5rs, el semiángulo de la sombra cumple sin(alpha) = b_critical sqrt(1 - rs/r0) / r0.

La sombra es mayor que el tamaño angular euclidiano del horizonte; una esfera plana de radio rs sería una referencia incorrecta.

Compará después de reducir a la mitad la escala de paso, permitir más pasos y distancia afín y aumentar el radio de escape. Reducí también el paso mínimo si impide refinar. Revisá las intersecciones con el disco y las direcciones del cielo además de la captura: un residuo pequeño no demuestra por sí solo exactitud cerca de un rayo crítico ni detecta un cruce perdido del disco. El límite finito de escape también omite parte de la deflexión restante.

Las pruebas de referencia en CPU usan más precisión que la GPU. Pasarlas no certifica cada píxel f32. Las notas de validación, en inglés, registran las pruebas y ejecuciones nativas del proyecto.

Kerr y lo que queda

La versión con rotación usa un shader hamiltoniano de Kerr–Schild separado. Integra posición y momento canónico juntos con RK4 y derivadas analíticas de la métrica. La rotación cambia el horizonte, el borde interno estable del disco y las trayectorias por arrastre de marcos. La componente conservada del momento angular es la axial canónica Lz = x p_y - y p_x, no el vector completo usado arriba.

En ambas versiones el disco sigue siendo una superficie analítica. No hay dinámica de fluidos, turbulencia, espesor ni historia de emisión retardada. Un observador en movimiento y la visibilidad del primer plano mediante rayos curvos también necesitan más trabajo.

Real-time High-Quality Rendering of Non-Rotating Black Holes, de Eric Bruneton, trata con más detalle la geometría y los marcos locales y usa tablas de consulta para acelerar el trazado. Para ver los archivos de este renderizador, están las notas de arquitectura, en inglés.