Journey to a Black Hole’da her astronomik piksel için kameradan geriye doğru bir ışın izliyorum. Işının yolu, o pikselde ne görüneceğini belirliyor: gökyüzü, diskten gelen ışık ya da ışın yakalandığında siyah.
Aşağıda Schwarzschild sürümünün nasıl çalıştığını, kamera ışınından son piksellere kadar anlatıyorum. WGSL örnekleri görüntüleyiciden kısaltılmış parçalar. Import’lar, binding’ler ve Bevy kurulumunun tamamı bağlantıdaki kaynak kodda var.
Referansı çalıştır
Proje Rust ve Bevy 0.19.1 kullanıyor. Buradaki örnekler bd964932 commit’ine karşılık geliyor. Rust 1.95 veya daha yenisi kuruluysa:
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
Test edilen sistem, RTX 4060 üzerinde Windows/Vulkan. Diğer donanımlar ve grafik altyapıları doğrulanmış değil. Bu sürümün tarayıcıda oynanabilen bir yapısı yok. itch.io’da Windows indirmesi de var.
Schwarzschild seçili kalsın. F2 diski gizliyor, F7 pikselli sunumu kaldırıyor, G ise gökyüzü ızgarasını açıyor. Işın hesabı üzerinde çalışırken merceklenmeyi bu görünümde daha rahat inceleyebilirsin.
Birimler ve koordinatlar
Hesaptaki bütün konumlar kara deliğe göre tanımlı. Işını izlemeye başlamadan önce kara deliğin dünya konumunu kameranın konumundan çıkar.
Geometrikleştirilmiş birimler kullanıyorum:
G = c = 1
rs = 2M
rs Schwarzschild yarıçapı; M ise uzunluk birimiyle ifade edilen kütle. rs = 1 seçmek sahneyle çalışmayı kolaylaştırıyor. Bu durumda yarıçapı 20 olan bir konumdaki kamera, yirmi Schwarzschild yarıçapı uzakta. Fiziksel birimlerle rs = 2GM/c².
- Olay ufku
r = rskonumunda - Dairesel foton yörüngesi
r = 1.5rskonumunda - Disk maddesinin en iç kararlı dairesel yörüngesi
r = 3rskonumunda
Kodda x konum, r = length(x) ve v = dx/dlambda. Bunlar alan yarıçapına göre tanımlanmış Kartezyen koordinatlar: r, Schwarzschild alan yarıçapı. Bu geometride fiziksel uzaklıklar tüm uzay boyunca Öklid uzaklıkları gibi davranmıyor.
lambda, ışın boyunca kullanılan afin parametre. Kamera zamanı ya da fotonun öz zamanı değil. Korunan foton enerjisinin büyüklüğü bire normalize edildiğinde, lambda adımı uzunluk birimi taşıyor. İngilizce matematik notlarında da aynı tanım kullanılıyor.
Pikselden ışına
Tam ekran shader’ı, kamera bazını kullanarak her fragment’ın UV koordinatını bir yöne çeviriyor:
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 sahnenin içine doğru bakıyor. Baz vektörleri ortonormal, aspect genişliğin yüksekliğe oranı, tan_half_fovy ise dikey görüş açısının yarısının tanjantı. Burada UV başlangıcı sol üstte. Kullandığın geçişte farklı bir tanım varsa dikey işareti değiştir.
Bu yönle şimdiden bir cubemap ya da gökyüzü ızgarası örnekleyebilirsin. Kamera dönerken yıldızlar dünya yönlerinde sabit kalmalı. Benim gökyüzü shader’ım, örtüşen yön haritalarında deterministik yıldızlar üretiyor. Fragment giriş noktası, kamera ışınının bu sorguya nasıl ulaştığını gösteriyor.
İntegrasyondan önce yerel kamera yönünü koordinatlara dönüştürmek gerekiyor. Ufkun dışındaki durağan bir gözlemci için:
er = x / r
mu = dot(d, er)
f0 = 1 - rs / r0
v = mu er + (d - mu er) / sqrt(f0)
d kameranın birim yönü, r0 gözlemcinin yarıçapı, er ise radyal olarak dışarı bakan yön. Dönüşüm radyal bileşeni koruyor, teğetsel bileşeni 1/sqrt(f0) ile ölçekliyor:
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);
}
Sonrasında v vektörünü normalize etme. Bu bir koordinat türevi; büyüklüğü, denklemlerde kullanılan afin normalizasyonu taşıyor. Kamera da ufkun dışında kalmalı. Bu görüntüleyicide kamerayı hareket ettirmek, art arda farklı durağan gözlemci görüntüleri veriyor. Hesap, kameranın fiziksel hızı için bir Lorentz dönüşümü ya da bunun yol açtığı aberasyonu içermiyor.
Eğriyi izlemek
Schwarzschild uzaysal null yörünge denklemi şöyle:
L = cross(x, v)
L2 = dot(L, L)
dx/dlambda = v
dv/dlambda = -(3/2) rs L2 x / r^5
L, normalize edilmiş birim foton enerjisi başına korunan açısal momentum; birimi uzunluk. L2 değerini başlangıç durumundan bir kez hesapla.
Bu denklem radyal null koşulundan geliyor:
vr^2 + (1 - rs/r) L2/r^2 = 1
vr = dot(x, v) / r
Türev alındığında bir merkezkaç terimi ve bir görelilik düzeltmesi çıkıyor. İvme Kartezyen vektör olarak yazıldığında merkezkaç terimi sadeleşiyor ve geriye şu kalıyor:
// 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));
}
Radyal bir ışın için L2 = 0. Işın içeri doğru ilerleyip yakalandığında bile uzaysal yolu düz kalıyor. Shader’ın tamamında bu yardımcı fonksiyonun paydası ayrıca korunuyor.
Schwarzschild yolu için ikinci dereceden velocity Verlet kullanıyorum. Önce konum ilerliyor, yeni konumda ivme hesaplanıyor, ardından hız güncelleniyor:
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);
}
Bu adımları güvenli tutmak çağıran döngünün sorumluluğu. a1 hesaplanmadan önce deneme adımının son noktası ufkun dışında kalacak şekilde h değerini sınırla ya da küçült. Yalnızca eski konumu kontrol etmek yeterli değil.
İlk denemede, kamera çok yakında değilken küçük ve sabit bir adım iş görür. Projedeki uzaklığa bağlı kural şöyle başlıyor:
h = step_scale * min(0.16r, 0.12r^2 / (sqrt(L2) + 0.01))
Sonra h sınırlandırılıyor ve length(v) kullanılarak uzaysal yer değiştirmeye üst sınır konuyor. 0.01, sahne birimlerinde sayısal bir düzenleyici. Bu sezgisel bir yöntem: yerel hata tahmini yok ve sabit minimum adım bir noktadan sonra daha fazla inceltmeyi engelliyor. Demoyla karşılaştırırken bütün sınırlarıyla birlikte tam adım kuralını kullan.
İzleme döngüsünün sözde kodu:
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
Yakalama, ufkun dışındaki sayısal güvenlik payı olan 1.015rs konumunda duruyor. Kaçış için hem yeterince büyük bir yarıçap hem de dışarı yönelen hareket gerekiyor. O noktada v vektörünün normalize edilmiş bir kopyası gökyüzü yönünü veriyor. İntegrasyon boyunca asıl hız vektörünü normalize etmeden koru.
Projede en fazla 768 adım var. Zor ışınlar bu bütçeyi yine de tüketebiliyor. Bu yüzden sonuçta “tamamlanamadı” ve “yakalandı” ayrı durumlar. F11, tamamlanamayan ışınları magenta gösteriyor. Normal görüntüde siyah oldukları için gölgenin bir parçası sanılabiliyorlar.
Diskle kesişmeler
Disk, merkezden geçen, birim normali n olan ince bir halka. Schwarzschild için iç kenarı 3rs ile başlat. Işık yayımını eklemeden önce şekli kontrol etmek için sabit, parlak bir renk yeterli.
Çoğu ışın diski integrasyon örneklerinin arasında kesiyor. Her adımın iki ucundaki işaretli düzlem uzaklıklarını karşılaştır:
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)
inner_radius < length(hit) < outer_radius olduğunda kesişmeyi kabul et. Paydayı koru ve tam uç noktaya denk gelen bir kesişmenin iki kez sayılmaması için tutarlı, yarı açık bir geçiş kuralı kullan.
Kısa parçalar için doğrusal interpolasyon iş görüyor. Projenin kesişme hesabı ise uç noktaların konum ve hızlarından kübik Hermite interpolasyonu yapıyor, ardından on ikili bölme adımı uyguluyor.
İki yöntem de kesişmeyi iki yandan sınırlayan bir aralığa ihtiyaç duyuyor. Büyük bir adım düzlemi iki kez kesip uç noktalarını aynı tarafta bırakabilir. Düzleme teğet geçen ışınlara da dikkat etmek gerekiyor. Tam düzlem üzerinde kalan bir ışın, bu sıfır kalınlıklı model için tekil bir durum. Eğik bakış açılarını daha küçük adımlarla kontrol et ve kamerayı disk düzleminin biraz üzerinde tut.
Opak bir disk ilk geçerli kesişmede izlemeyi durdurabilir. Benimki, her geçişte yaklaşık 0.04 geçirgenlikle ışık yayımını biriktiriyor. İki ışık yayan geçişten sonra kalan geçirgenlik ihmal edilebilir olduğunda duruyor. Sonuç, hacimsel plazma hesabı yapmayan ince bir ışık yayan yüzey.
Yana doğru hareket ettiğinde ışınların diskte ulaştığı yerler değişiyor. Diskin bazı parçaları karanlık merkezin üstünde ve altında görünüyor:

Diskin ışık yayımı
Diskin radyal profili şöyle:
F(r) = (r_in/r)^3 (1 - sqrt(r_in/r))
T(r) = T_scale * F(r)^(1/4)
F boyutsuz bağıl bolometrik akı, r_in iç yarıçap, T_scale ise kelvin cinsinden sıcaklık ölçeği. Varsayılan değer 18.000 K. Sıfır tork çarpanı, iç kenarda akıyı sıfıra indiriyor; akı biraz daha dışarıda tepe yapıyor.
Bu, iç kenarda torkun sıfır olduğu basitleştirilmiş Newtoncu bir profil. Sıcaklık ölçeği ayarlanabiliyor; kütleden ve madde birikim hızından çıkarılmıyor. Tam görelilik içeren bir disk modeli farklı bir akı hesabı gerektirir.
Spektral shader, Planck spektrumunu 380 ile 780 nm arasında 41 dalga boyunda örnekliyor. CIE renk eşleme fonksiyonlarıyla integralini alıyor, sonra XYZ’den doğrusal sRGB’ye çeviriyor. Kullandığı spektral şekil şu:
B(lambda, T) ∝ 1 / [lambda^5 (exp(14387.76877 / (lambda T)) - 1)]
Buradaki lambda, mikrometre cinsinden dalga boyu; yukarıdaki afin parametreyle aynı şey değil. T kelvin cinsinden. Fiziksel sabitler ve ortak dalga boyu aralığı normalizasyona dahil edilmiş. Renk doğrusal HDR olarak kalıyor. CIE tablosunun ayrı bir atıf ve lisans dosyası var. Veriyi yeniden kullanırsan bu bilgi de yanında kalmalı.
Kırmızıya kayma ve yörünge hareketi
Kütleçekimi ve diskin hareketi, gözlemciye ulaşan frekansı değiştiriyor. Schwarzschild diski için:
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, dairesel yörüngedeki ışık kaynağının koordinat zamanına göre açısal hızı. Genellikle u^t olarak yazılan ut, dört-hızının kontravaryant zaman bileşeni. L_n, ışının disk normali etrafındaki işaretli açısal momentumu. Frekans oranı g, gözlenen frekansın yayılan frekansa bölümü. Birden büyük değerler maviye kayma veriyor.
1 + Omega L_n içindeki artı işareti, ışını geriye doğru izlemekten geliyor. Metrik imzası (-,+,+,+) olduğunda geriye izlenen ışının korunan kovaryant zaman momentumu p_t = +1. İleri giden foton momentumu kullanan bir formülü burada kullanmadan önce işaretini dönüştürmek gerekiyor.
u^t çarpanı, kütleçekimsel katkının yanında enine Doppler kaymasını da içeriyor. Uygulama dönmeyi de hesaba katıyor; buradaki denklemler dönmeyi sıfıra ayarlıyor.
Isıl ışınım gT sıcaklığında görülüyor. Bolometrik şiddet g^4 ile dönüşüyor. Frekansa özgü şiddette ise frekans argümanı kaydırılarak g^3 kullanılıyor. Diskin thermal_rgb fonksiyonu renk integralini T^4 ile bölüyor; böylece birim bağıl bolometrik akı başına renk elde ediliyor:
// 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;
Bu normalizasyon önemli. Renk fonksiyonun gT için tam, normalize edilmemiş Planck şiddetini döndürüyorsa tekrar g^4 ile çarpmak enerji kaymasını iki kez sayar. Son shader ayrıca disk kenarlarını yumuşatıyor ve görsel amaçlı bir HDR parlaklık ölçeği uyguluyor.
Bevy geçişi
Rust tarafındaki uniform yapısı, WGSL düzeniyle eşleşmek için ShaderType ve Vec4 alanlarını kullanıyor. Bu düzeni değiştirirsen, özellikle üç bileşenli vektörlerin çevresinde hizalamayı kontrol et.
Render geçişi, mevcut HDR sahnesini, derinlik dokusunu ve ayar tamponunu okuyor. Sonraki post-processing işlemlerinden önce Rgba16Float hedefe tam ekran bir üçgen çiziyor.
Ön plan pikselleri korunuyor. Shader yalnızca derinliğin sıfır olduğu yerlerde ışın izliyor; Bevy’nin ters derinlik tanımında bu, ön plan nesnesiyle kapatılmamış arka plan demek. Başka bir motora taşıyorsan bu tanımı kontrol et.
Dolayısıyla sonda normal perspektif projeksiyonunu koruyor. Kara delik onu merceklemiyor ya da arkasında gizlemiyor. Bunu desteklemek, eğri ışın yolları boyunca ön plan geometrisiyle kesişmeleri hesaplamayı gerektirir. Mevcut derinlik dokusunda yalnızca nesnelerin normal kamera projeksiyonu var.
Pikselli sunum
Bu görünüm HDR sahnesinden sonra uygulanıyor:
HDR scene and geodesic background
→ bloom and exposure
→ tone mapping
→ area reduction
→ tonal quantization and ordered dither
→ nearest-neighbour expansion
→ UI
Varsayılan olarak HDR görüntüyü 960×540 çiziyor, büyütmeden önce 480×270 boyutunda bir sunum ızgarasına indiriyorum. Küçültme shader’ı, kesirli piksel kapsamını da dahil ederek kaynak alanın ortalamasını örtüşme ağırlıklarıyla alıyor. Bu, her hücre için tek kaynak örneği seçmeye kıyasla ince ve parlak ayrıntılardaki titreşimi azaltıyor.
Tonal nicemleme, algısal kanal değerlerini ayarlanabilir sayıda seviyeye yuvarlıyor. Sabit bir 4×4 Bayer deseni, yuvarlama hatasını sunum ızgarasına dağıtıyor. En yakın komşu yöntemiyle büyütmek de hücrelerin keskin kalmasını sağlıyor. Dither desenini kareler arasında sabit tut.
F7 bu işlemi atlıyor. Işın hesabındaki değişiklikleri, ton eşleme ve küçültmenin etkilerinden ayırmayı kolaylaştırıyor.
Sonucu kontrol etmek
Disk ve bloom kapalıyken her ışın boyunca null koşulunu izle:
residual = abs(vr^2 + (1 - rs/r) L2/r^2 - 1)
Değer sıfıra yakın kalmalı. Shader, yol boyunca karşılaştığı en büyük kalıntının normalize edilmiş hâlini kaydediyor. Açısal momentum sürüklenmesini kontrol etmek için cross(x, v) değerini de başlangıç değeriyle karşılaştır.
İşe yarayan birkaç referans durum var:
- Radyal olarak içeri ve dışarı giden ışınların uzaysal yolları düz. İçeri giden ışın yakalama eşiğine ulaşıyor
- Uzaktan gelen bir ışının zayıf alan sapması
2rs/bradyana yaklaşıyor. Buradab, çarpma parametresi - Kritik gelen ışın için çarpma parametresi
b_critical = 3sqrt(3)rs/2. Bu değerin iki yanındaki yakın ışınlar, integrasyonu incelttikçe yakalama ve kaçış olarak ayrılmalı r0 > 1.5rskonumundaki durağan bir kamera için gölge yarı açısısin(alpha) = b_critical sqrt(1 - rs/r0) / r0bağıntısını sağlıyor
Gölge, ufkun Öklid geometrisindeki açısal boyutundan daha büyük. Bu yüzden yarıçapı rs olan sıradan bir küre yanlış referans olur.
Adım ölçeğini yarıya indirip daha fazla adıma ve afin mesafeye izin verdikten, kaçış yarıçapını artırdıktan sonra sonuçları karşılaştır. Minimum adım inceltmeyi engelliyorsa onu da küçült. Yakalamanın yanında disk kesişmelerini ve gökyüzü yönlerini de kontrol et. Küçük bir koşul kalıntısı, kritik ışının yakınında tek başına doğruluk kanıtlamaz ve kaçırılmış bir disk kesişmesini tespit etmez. Sonlu kaçış sınırı, geriye kalan sapmanın bir kısmını da dışarıda bırakıyor.
CPU referans testleri, GPU’dan daha yüksek hassasiyet kullanıyor. Bu testlerden geçmek her f32 pikseli doğrulamıyor. İngilizce doğrulama notları, proje için yapılan testleri ve yerel çalıştırmaları kaydediyor.
Kerr ve kalan işler
Dönen sürüm, ayrı bir Kerr–Schild Hamiltonyen shader’ı kullanıyor. Analitik metrik türevleriyle, konumu ve kanonik momentumu RK4 kullanarak birlikte integre ediyor. Dönme; ufku, diskin kararlı iç kenarını ve çerçeve sürüklenmesi yoluyla ışınların yollarını değiştiriyor. Korunan açısal momentum bileşeni, yukarıdaki tam vektör yerine eksensel kanonik Lz = x p_y - y p_x.
İki sürümde de disk analitik bir yüzey. Akışkan dinamiği, türbülans, kalınlık ya da gecikmeli ışık yayımı geçmişi yok. Hareketli gözlemci ve ön planın eğri ışınlar üzerinden görünürlüğü de daha fazla çalışma gerektiriyor.
Eric Bruneton’un Real-time High-Quality Rendering of Non-Rotating Black Holes çalışması, geometriyi ve yerel çerçeveleri daha ayrıntılı ele alıyor; ışın izlemeyi hızlandırmak için arama tabloları kullanıyor. Bu görüntüleyicinin arkasındaki dosyalar için İngilizce mimari notlarına bakabilirsin.
