Diffuse Cahaya Pemetaan

Diffuse Cahaya Pemetaan
Teknik pertama kita akan membahas ringan pemetaan difus, yang menggunakan cahaya untuk mensimulasikan peta Lambert
persamaan pencahayaan difus. Pada dasarnya, kami akan mencoba untuk tetap tidak berubah dalam bahan yang cukup terang daerah sementara
membuat mereka lebih gelap di daerah teduh. Jika Anda berpikir tentang ini dalam hal aritmatika dan meninjau difus yang
bagian dari persamaan pencahayaan dari bagian sebelumnya, Anda akan melihat bahwa situasi ini adalah setara dengan
tekstur perkalian. Peta cahaya akan menjadi putih (1,1,1) di zona terang dan hitam di sudut-sudut gelap. Jika kita melukis
tekstur dan kemudian kalikan dengan peta cahaya, efek shading meyakinkan difus akan tercapai.
Specular Cahaya Pemetaan
Pencahayaan specular juga dapat disimulasikan dengan peta cahaya. Di sini, kita mencoba untuk "membakar" tekstur karena cahaya menjadi
dipancarkan intens dalam arah tertentu. Pencahayaan specular memiliki potensi downside, meskipun. Ingat bahwa
komponen specular adalah sudut pandang tergantung, sehingga pemirsa bergerak sekitar objek akan melihat highlight bergerak juga. Karena kita membatasi diri kita untuk pemetaan cahaya statis sekarang, kita tidak dapat mensimulasikan
efek ini secara akurat. Tapi bayangkan bahwa jarak dari lampu ke dinding menyala jauh lebih kecil dari
jarak dari penampil ke dinding. Dalam hal ini, ketergantungan specular highlights berkaitan dengan
gerakan penampil akan sangat kecil, dan di situlah letak trik: pemetaan cahaya specular akurat dapat
Model menyoroti disebabkan bukan oleh lampu jauh menerangi permukaan yang sangat reflektif (memikirkan cahaya terang
dan bola logam), tetapi dengan lampu biasa ditempatkan dekat dengan permukaan, sehingga menghasilkan warna yang biasa membakar. Ini
menyoroti hampir sudut pandang independen dan terlihat meyakinkan ketika diberikan dengan peta cahaya.
Dalam hal aritmetika tekstur, peta cahaya specular dapat dianggap sebagai penambahan tekstur. Kami menambahkan cahaya
dengan materi dasar, sehingga mereka piksel dengan komponen specular tinggi tersebut disoroti. Sekali lagi, peta cahaya
akan menyandikan pencahayaan menggunakan murni putih (atau apa pun warna cahaya) untuk daerah specularly terang dan hitam untuk
nonspecular zona. Peta cahaya specular harus digunakan hemat. Kontribusi utama pencahayaan di setiap adegan
selalu menyebar, dan specular highlights digunakan hanya sebagai sentuhan akhir atas bahwa pencahayaan dasar
lapisan.
Global Penerangan Menggunakan Peta Cahaya
Kita dapat menggabungkan komponen menyebar dan specular peta cahaya untuk mencapai hasil yang berkualitas tinggi, sangat
mirip dengan solusi yang diusulkan pada bagian sebelumnya. Sekali lagi, itu semua bermuara pada aritmatika tekstur. Sebuah
iluminasi cahaya mesin peta global akan menggunakan tiga tekstur, dikombinasikan dengan cara berikut:
Warna = Material_Color * Diffuse_light_map + Specular_light_map
Pelaksanaan Pemetaan Light: OpenGL
Peta cahaya dapat diimplementasikan dalam OpenGL melalui render multipass atau dengan menggunakan multitexture pada mampu
perangkat keras. Pilihan multipass agak lebih lambat, tetapi kode mungkin lebih mudah dimengerti, jadi mari kita
mencakup keduanya. Untuk kelengkapan, kami akan meliputi solusi, pencahayaan lebih kompleks global, yang menangani
berdifusi serta pencahayaan specular.
Multipass Versi
Kami akan menerapkan peta cahaya menggunakan tiga lewat: Yang pertama akan membuat sebuah objek dasar yang sesuai dengan
material. Kemudian, kedua lulus akan bertambah banyak, simulasi komponen menyebar. Sebuah lulus ketiga akan melakukan
campuran aditif untuk menggabungkan specular highlights. Mari kita lihat beberapa kode, dan komentar itu:
/ / Pertama lulus
glBindTexture (GL_TEXTURE_2D, basematerialid);
glDisable (GL_BLEND);
glDepthFunc (GL_LESS);
/ / Di sini Anda akan membuat geometri
(...)
/ Pass / kedua: multiply menyebar
glBindTexture (GL_TEXTURE_2D, diffusematerialid);
glEnable (GL_BLEND);
glBlendFunc (GL_DST_COLOR, GL_ZERO);
glDepthFunc (GL_LEQUAL);
/ / Di sini Anda akan mengirim ulang geometri, hanya koordinat pemetaan akan berbeda

(...)
/ Pass / ketiga: aditif specular
glBindTexture (GL_TEXTURE_2D, specularmaterialid);
glEnable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glDepthFunc (GL_LEQUAL);
/ / Penyerahan geometri lalu, hanya koordinat pemetaan akan berbeda
(...)
Itu semua bermuara pada pengaturan blending mode yang tepat dan mengirimkan geometri sebanyak yang diperlukan.
Pelaksanaan Pemetaan Light: DirectX
Pada bagian ini, saya akan mengungkapkan kode yang diperlukan untuk menangani pemetaan cahaya di bawah DirectX 9. Kode ini
menyeluruh berkomentar dan sebenarnya cukup mudah. Jika Anda tidak akrab dengan tahap texturing
operasi, lihat bagian "Tekstur Aritmatika" dalam Bab 18, "Pemetaan Tekstur," untuk lebih
informasi. Dalam contoh pertama, kami menerapkan pemetaan cahaya menyebar hanya menggunakan dua melewati: satu untuk
dasar tekstur dan kedua lulus digunakan untuk memodulasi dengan lightmap tersebut.
/ / Contoh ini mengasumsikan bahwa d3dDevice adalah pointer yang valid ke
/ / IDirect3DDevice9 antarmuka.
/ / LptexBaseTexture adalah pointer yang valid untuk tekstur.
/ / LptexDiffuseLightMap adalah pointer yang valid untuk tekstur yang berisi
/ / RGB berdifusi data peta cahaya.
/ / Set tekstur dasar.
d3dDevice-> SetTexture (0, lptexBaseTexture);
/ / Set operasi dasar tekstur dan args.
d3dDevice-> SetTextureStageState (0, D3DTSS_COLOROP,
D3DTOP_SELECTARG1);
/ / Pertama operator: tekstur dasar
d3dDevice-> SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
/ / Set peta terang.
d3dDevice-> SetTexture (1, lptexDiffuseLightMap);
/ / Set tahap campuran. Kami ingin kalikan dengan tahap sebelumnya
d3dDevice-> SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_MODULATE);
Parameter / / pertama adalah peta cahaya
d3dDevice-> SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
/ / Parameter kedua adalah tahap sebelumnya
d3dDevice-> SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
Sekarang, contoh yang lebih terlibat yang menangani kedua specular dan menyebar menggunakan tiga tahap:
/ / Contoh ini mengasumsikan bahwa d3dDevice adalah pointer yang valid ke
/ / IDirect3DDevice9 antarmuka.
/ / LptexBaseTexture adalah pointer yang valid untuk tekstur.
/ / LptexDiffuseLightMap adalah pointer yang valid untuk tekstur yang berisi
/ / RGB berdifusi data peta cahaya.
/ / Set tekstur dasar.
d3dDevice-> SetTexture (0, lptexBaseTexture);
/ / Set operasi dasar tekstur dan args.
d3dDevice-> SetTextureStageState (0, D3DTSS_COLOROP,
D3DTOP_SELECTARG1);
/ / Pertama operator: tekstur dasar
d3dDevice-> SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
/ / Set peta terang.
d3dDevice-> SetTexture (1, lptexDiffuseLightMap);
/ / Set tahap campuran. Kami ingin kalikan dengan tahap sebelumnya
d3dDevice-> SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_MODULATE);
Parameter / / pertama adalah peta cahaya
d3dDevice-> SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
/ / Parameter kedua adalah tahap sebelumnya
d3dDevice-> SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
/ / Set peta cahaya specular.
d3dDevice-> SetTexture (2, lptexDiffuseLightMap);
/ / Set tahap campuran. Kami ingin menambahkan dengan tahap sebelumnya
d3dDevice-> SetTextureStageState (2, D3DTSS_COLOROP, D3DTOP_ADD);
Parameter / / pertama adalah peta cahaya
d3dDevice-> SetTextureStageState (2, D3DTSS_COLORARG1, D3DTA_TEXTURE);
/ / Parameter kedua adalah tahap sebelumnya
d3dDevice-> SetTextureStageState (2, D3DTSS_COLORARG2, D3DTA_CURRENT);
Seperti yang Anda lihat, keduanya adalah kompleks: Ini semua adalah masalah mengetahui matematika di belakang lightmapping dan
mengekspresikan dengan benar dalam API pilihan Anda.
Membuat Peta Cahaya
Peta cahaya dapat dibuat dalam berbagai cara. Sebuah pendekatan, pertama naif akan melukis mereka dengan
tangan. Hal ini dapat dicapai dengan perangkat lunak pengolah gambar seperti Adobe Photoshop, dan tergantung
pada bakat artis, dapat menghasilkan hasil yang mencolok baik. Tapi itu adalah proses yang memakan waktu, dan mendapatkan
kanan interaksi halus cahaya pada permukaan terkadang lebih mudah diucapkan daripada dilakukan. Beberapa iluminasi
efek cukup tidak terduga, dan seniman mungkin gagal untuk menyampaikan kompleksitas dunia nyata pencahayaan.
Alternatif kedua adalah dengan menghitung mereka dengan bantuan paket rendering. Paket render paling bisa
membantu kita, dengan berbagai tingkat keberhasilan, dalam proses membuat peta cahaya. Namun, sebagian dari mereka akan
memerlukan pengolahan pasca karena mereka jarang menawarkan "cradle-to-kuburan" pilihan peta penciptaan cahaya. Dengan demikian,
Alternatif ketiga dan cukup populer adalah untuk menghitung peta ini dengan alat proprietary, yang melakukan
pencahayaan yang lengkap analisis, tekstur menghitung, dan menyimpannya dalam format yang sesuai.
Paket perangkat lunak yang dapat membantu Anda menghitung peta cahaya. Renderers komersial dapat membuat gambar terlihat
dari sumber cahaya, sehingga Anda dapat menggunakan kembali ini peta bayangan. Radiositas prosesor dapat menganalisis pencahayaan dalam sebuah adegan
dan output informasi per titik, dan dalam beberapa kasus, bahkan menghasilkan peta cahaya yang dibutuhkan.
Kadang-kadang, bahkan ditambah dengan radiositas preprocess untuk memastikan bahwa data pencahayaan adalah benar untuk hidup.
Peta Perhitungan Light: Phong Cara pertama dan paling sederhana dari menghitung peta cahaya adalah hanya mengevaluasi diffuse dan specular
komponen pencahayaan dengan mengambil lampu menjadi pertimbangan, tetapi melupakan occluders dan bayangan. Itu
proses relatif mudah dan akan memimpin jalan untuk solusi yang lebih terlibat terbuka di
mengikuti bagian. Untuk menjaga hal-hal yang lebih sederhana, mari kita lupakan tentang peta cahaya kemasan untuk kedua dan fokus
pada pembuatan peta cahaya untuk quad tunggal, diterangi beberapa sumber cahaya berwarna.
Keputusan pertama untuk membuat adalah ukuran peta cahaya. Ketika Anda akan segera melihat, ukuran ini menentukan bukan hanya
kualitas hasil, tetapi juga jejak memori dari aplikasi kita. Peta cahaya biasanya rendah
resolusi karena mereka mewakili gradien pencahayaan. Jadi, ketika diperbesar, interpolasi tidak menghasilkan
visual yang artefak, melainkan membantu kelancaran keluar pencahayaan. Isu lain yang harus diperhatikan ketika memilih
ukuran yang tepat adalah bahwa untuk mencapai hasil yang realistis, semua peta cahaya harus lebih atau kurang dari skala yang sama: Sebuah
quad lebih besar akan membutuhkan peta cahaya yang lebih besar, dan sebagainya. Dengan demikian, akan sangat berguna untuk berpikir tentang peta cahaya dalam hal
dunia-ruang ukuran. Sebagai contoh, apa frekuensi sampling yang Anda ingin membangun dalam satuan dunia? Will salah satu
lumel (setara dengan piksel pada peta cahaya) sesuai dengan satu sentimeter, 10 sentimeter, atau setengah
kilometer?
Sebagai contoh sederhana kita, mari kita asumsikan quad kita adalah 1X1 meter persegi. Kita akan menggunakan peta cahaya 64x64, sehingga
pencahayaan akan memiliki resolusi 1,5 sentimeter per sampel sekitar.
Setelah resolusi peta cahaya telah ditetapkan, kita perlu menghitung koordinat setiap titik pengambilan sampel, sehingga kami
kemudian dapat menerangi itu. Titik pengambilan sampel komputasi pada quad adalah interpolasi bilinear sederhana, yang
membagi quad di ubin sehalus ukuran peta cahaya. Berikut adalah kode untuk menghitung koordinat peta cahaya
(Dalam ruang 3D) untuk lumel (lu, lv):
titik Create3Dpoint (float lu, float lv)
{
/ / Interpolasi sepanjang sumbu U
titik v1 = p2-p1;
titik v2 = p3-p4;
titik v1 = p1 + v1 * (lu / LIGHTMAPSIZEU);
titik v2 = p4 + v2 * (lu / LIGHTMAPSIZEU);
/ / Interpolasi sepanjang sumbu V
titik w1 = v2-v1;
titik w2 = v1 + w1 * (lv / LIGHTMAPSIZEV);
kembali w2;
}
Sekarang kita memiliki titik 3D kita ingin menghitung pencahayaan untuk. Tapi ini adalah bagian yang mudah, karena kita
dibahas persamaan ambien-baur-specular pencahayaan klasik sebelumnya dalam bab ini. Sekarang, itu semua
masalah dari perulangan melalui lampu adegan, menghitung kontribusi mereka terhadap pencahayaan lumel yang kita
kerjakan. Semua dalam semua, menghitung peta cahaya tunggal dipengaruhi oleh jumlah lampu adalah O (n ^ 3) proses. Kita
harus mengulang melalui array bidimensional dari lumels, masing-masing dipengaruhi oleh beberapa lampu. Mengingat
bahwa ini hanyalah cahaya yang paling sederhana (dan tercepat) peta proses komputasi, Anda akan memahami mengapa cahaya
Peta ini biasanya dibuat dalam preprocess, sering mengambil beberapa menit untuk menyelesaikannya.
Singkatnya, di sini adalah pseudocode untuk prosesor peta cahaya yang menangani adegan lengkap. Untuk
mempermudah, saya telah mengasumsikan setiap peta cahaya disimpan dalam peta tekstur yang berbeda. Kami akan mencakup peta cahaya
packing di bagian "Menyimpan Peta Cahaya." untuk setiap primitif dalam adegan
menghitung ukuran cahaya peta yang ideal
untuk setiap posisi dalam peta cahaya sepanjang sumbu u
untuk setiap posisi dalam peta cahaya sepanjang sumbu v
un-proyek U, V untuk 3D koordinat
menginisialisasi kontribusi pencahayaan ke 0
untuk setiap lampu dalam adegan
menambahkan pengaruh lampu untuk kontribusi keseluruhan
akhir untuk
menyimpan kontribusi pencahayaan ke peta cahaya
akhir untuk
akhir untuk
menyimpan peta cahaya
akhir untuk
Perhatikan bahwa, tergantung pada bagaimana Anda menghitung pencahayaan, Anda dapat menghasilkan menyebar-only, specular-only, atau keduanya
specular dan diffuse cahaya peta dengan algoritma sebelumnya. Semuanya tergantung pada bagaimana Anda menerapkan
pencahayaan persamaan. Namun, beberapa efek tidak akan diberikan dengan benar. Bayangan, misalnya, tidak akan
dipertanggungjawabkan. Kami akan membutuhkan algoritma yang lebih terlibat untuk meningkatkan realisme.
Cahaya Peta Perhitungan: Ray Tracing
Kami dapat menghasilkan hasil cari yang lebih baik dengan memperkenalkan teknik ray tracing ke dalam algoritma sebelumnya.
Algoritma inti akan tetap sama, tapi sebelum mempertimbangkan kontribusi lampu diberikan kepada sebuah lumel,
kami akan menembakkan sinar bayangan dari lumel untuk lampu dan tes untuk persimpangan dengan seluruh TKP.
Dengan cara ini kita dapat menangani bayangan untuk realisme jauh meningkat. Perhatikan bagaimana kita tidak akan menggunakan sinar rekursif
tracing, yang disediakan untuk refleksi dan transparansi. Sebuah sinar tunggal bayangan dari lumel ke
cahaya akan memberitahu kami jika lumel harus diterangi lampu atau jika tetap di tempat teduh.
Dengan demikian, penambahan utama dengan algoritma sebelumnya adalah baik konstruksi dari sinar bayangan dan
bayangan sinar-adegan tes persimpangan. Konstruksi sangat sederhana: Sinar biasanya diwakili oleh
asal (dalam kasus kami, lumel yang sedang menyala) dan arah vektor satuan:
ray.origin = lumel;
ray.direction = lamp.pos - lumel;
ray.direction.normalize ();
Sekarang, komputasi sinar-adegan tes persimpangan adalah masalah yang berbeda (sedih, yang lebih kompleks). Efisien
sinar-segitiga tes set sulit ditemukan. Saya akan mengekspos tes sederhana (yang kebetulan satu paling lambat)
dan juga tes yang sangat efisien, yang akan menghasilkan dekat-optimal hasilnya.
Dalam sebuah adegan sederhana, cara termudah untuk menghitung persimpangan antara sinar dan satu set segitiga adalah untuk
memeriksa satu per satu segitiga dan segitiga-test masing-masing. Jika salah satu segitiga efektif memotong
ray, lumel kita adalah di dalam bayangan. Uji sinar-segitiga adalah sebagai berikut:
1. Melakukan uji sinar-pesawat antara ray dan dukungan pesawat segitiga.
2. Jika mereka berpotongan, menghitung titik persimpangan.
3. Menggunakan aturan segitiga berkelok-kelok, pastikan titik persimpangan adalah di dalam segitiga. Anda dapat membuat tes penolakan awal dengan memastikan asal ray efektif terletak di depan setiap segitiga
Anda uji (menggunakan segitiga normal). Hanya terlihat (nonculled) segitiga sebenarnya dapat menyebabkan titik di tingkat
berada dalam bayangan.
Algoritma ini berjalan di O (jumlah segitiga dalam adegan). Sekarang, karena prosesor peta cahaya biasanya
menjalankan offline, biaya tinggi ini mungkin tidak menjadi masalah. Tapi ingat untuk mengawasi total Anda
komputasi biaya. Ray tracing adalah suatu algoritma yang intensif, dan waktu pengolahan dapat meroket jika Anda tidak
hati-hati. Sebagai contoh, berikut adalah biaya komposit prosesor peta cahaya menggunakan ray tracing dengan
persimpangan uji:
O (jumlah segitiga * lightmap U V lightmap ukuran * Ukuran * (jumlah lampu * nomor
segitiga))
Perhatikan bagaimana biaya dalam kurung dalam adalah untuk lulus ray tracing. Setiap lumel harus menembak sinar ke
setiap lampu, dan sinar ini perlu diuji terhadap semua tingkat geometri-semua dalam semua, O (n ^ 5).
Sekarang, kita dapat menggunakan tes sinar-segitiga persimpangan lebih baik untuk membantu mengurangi waktu pengolahan. Yang akan kita gunakan
mengambil keuntungan dari perhitungan visibilitas. Dengan mengetahui area mana dari tingkat terlihat dari yang diberikan
lumel, kita dapat mengurangi potensi lampu dan set occluder. Bayangkan, misalnya, bahwa Anda bekerja dengan
pendekatan portal. Kemudian, diberi lumel (dalam koordinat 3D), Anda dapat menghitung mana sel-sel yang terlihat dari
titik itu. Karena kita hanya mempertimbangkan pencahayaan langsung, lampu hanya dalam sel terlihat berpotensi dapat
menerangi lumel, sehingga kita bisa mulai dengan menghilangkan semua yang lain sebagai calon.
Sebuah perbaikan kedua muncul dalam tes persimpangan sinar-segitiga. Untuk segitiga membayangi lumel tersebut,
segitiga harus terletak di salah satu sel terlihat juga. Jika segitiga tidak dalam Set Berpotensi Terlihat (PVS) dari
lumel, bagaimana bisa itu bayangan lumel itu?
Dengan demikian, algoritma pemetaan pemrosesan yang lebih baik cahaya dapat dibangun. Berikut adalah pseudocode untuk algoritma ini:
untuk setiap primitif dalam adegan
menghitung ukuran cahaya peta yang ideal
untuk setiap posisi dalam peta cahaya sepanjang sumbu u
untuk setiap posisi dalam peta cahaya sepanjang sumbu v
un-proyek U, V untuk 3D koordinat
menginisialisasi kontribusi pencahayaan ke 0
menghitung sel yang berpotensi terlihat dari lumel
untuk setiap lampu di set terlihat
menghitung sinar bayangan dari lumel untuk lampu
untuk setiap segitiga pada set terlihat
tes untuk persimpangan antara sinar dan segitiga
akhir untuk
jika tidak ada persimpangan terjadi
menambahkan pengaruh lampu pada kontribusi dunia
akhir jika
akhir untuk
menyimpan kontribusi pencahayaan ke peta cahaya
akhir untuk
akhir untuk
menyimpan peta cahaya
akhir untuk
Perhatikan bagaimana versi baru ini jauh lebih efisien daripada menggunakan brute force sinar-segitiga persimpangan. Dalam tingkat besar dengan segitiga tinggi (dan lampu) jumlah, perbedaan antara menggunakan brute force ray tracing dan ini
baru, metode dipercepat akan sangat lipat, mengingat sifat intensif ray tracing
pendekatan.
Sebagai catatan akhir, Anda juga dapat mempercepat tes sinar-segitiga langsung jika Anda tidak dapat mengandalkan visibilitas
struktur. Banyak metode telah dirancang selama bertahun-tahun-yang paling efisien mungkin sedang di Fujimoto
algoritma. Metode ini, bersama dengan tes persimpangan untuk bola dan kotak, dijelaskan sepenuhnya dalam Bab
20, "Rendering Organik."
Lanjutan Cahaya Peta Menggunakan Ray Tracing
Teknik ray tracing lebih kuat dapat digunakan untuk menghitung efek kompleks pemetaan cahaya. Dalam
bagian, saya akan memberikan daftar efek dan teknik yang sesuai.
Penumbras, misalnya, dapat dengan mudah ditambahkan ke lulus ray tracing dengan menggunakan Stochastic (Monte-Carlo) ray
pelacakan. Di sini kita memperpanjang sinar bayangan kepada sekelompok ray, yang diarahkan dalam distribusi Poisson
menuju sumber cahaya (yang pada gilirannya perlu menjadi cahaya area) dalam sebuah kerucut. Ray Setiap kemudian diuji
dengan adegan untuk oklusi. Dengan sampling daerah pencahayaan keseluruhan, bayangan tidak lagi biner, tetapi bisa
menawarkan gradasi halus (lihat Gambar 17.5). Stochastic ray tracing secara signifikan lebih lambat dari klasik
algoritma, namun hasil telah meningkatkan kualitas. Juga, kita dapat kembali menggunakan teknik visibilitas untuk mempercepat
proses. Kami hanya akan api sinar terhadap mereka beberapa lampu itu, yang terlihat dari lumel, memiliki suatu daerah.
Gambar 17.5. Umbras dan penumbras.

  Varian dari ray tracing disebut pemetaan foton dapat digunakan untuk precompute fenomena konsentrasi cahaya
atau caustic. Di sini, preprocess kebakaran sejumlah sinar dari sumber cahaya yang berbeda (biasanya, beberapa
ratus ribu) dan membuat mereka memantul dari permukaan yang berbeda. Setiap kali sebuah lumel terkena sinar, kita
meningkatkan counter. Jadi pada akhir ini preprocess, kita dapat melihat apakah sebuah lumel menerima banyak penerangan atau jika
itu tetap di tempat teduh. Jika kita menganggap benda semitransparan menggunakan hukum Snellius, konsentrasi cahaya
h
fenomena akan berlangsung, dan dengan demikian akan dimasukkan ke dalam peta cahaya.
Tapi jangan melebih-lebihkan peta cahaya. Karena kita menghitung mereka sebagai preprocess, bayangan tidak akan
sebagai langkah menghidupkan lampu, dan caustic dibuat oleh kolam renang akan tetap bergerak.
Peta cahaya Perhitungan: radiositas
Sebuah alternatif untuk ray tracing, dan mungkin metode yang memberikan hasil terbaik, menggunakan sebuah radiositas
prosesor untuk menghitung peta cahaya. Radiositas adalah analisis algoritma pencahayaan yang berbasis di fisika nyata, dengan masing-masing
elemen permukaan bertindak baik sebagai penyerap cahaya yang masuk dan reflektor. Dengan demikian, radiositas bisa
secara akurat menghitung bagaimana cahaya bereaksi dalam sebuah adegan, dimana konsentrat, dan di mana bayangan muncul.
Algoritma radiositas cukup terlibat. Dengan demikian, banyak perusahaan menggunakan perangkat lunak komersial untuk menghitung
solusi untuk masalah. Jika Anda ingin kode Anda sendiri, bagian ini memberi Anda gambaran umum.
Radiositas mencoba untuk menghitung pencahayaan global dalam hal transfer energi antara permukaan yang berbeda dalam
adegan. Dimulai dengan membagi adegan ke patch dan menugaskan dua nilai untuk masing-masing: nilai iluminasi
(Yang merupakan seberapa banyak cahaya itu menerima dari patch lainnya) dan energi radiasi (jumlah
energi pada patch). Seperti mungkin Anda ketahui, tidak ada sumber cahaya di radiositas. Sebuah sumber cahaya adalah
hanyalah patch dengan energi radiasi. Sekarang, kita perlu menghitung transfer energi dari setiap pasangan
permukaan, yang merupakan O (n2) masalah. Kami mengambil setiap patch dan menghitung faktor yang tergantung pada
jarak, bentuk, dan orientasi, dan mewakili berapa banyak energi dapat ditransfer dari satu patch untuk
yang lain. Faktor ini dikenal sebagai faktor bentuk.
Faktor bentuk yang tercantum dalam matriks nxn, yang mewakili semua hubungan antara patch. Kemudian, untuk
menghitung transfer energi, kita memindai matriks mencari patch dengan energi radiasi. Ketika kita menemukan
satu, kita mengalihkan sebagian energi itu untuk patch lain dengan menggunakan faktor bentuk, dengan demikian melaksanakan satu langkah
dalam proses iluminasi. Kami kemudian memulai lagi, menganalisa lagi yang masih memegang posisi matriks radiasi
energi. Dalam gelombang kedua, kita akan mempertimbangkan kedua emitter awal dan emitter yang menerima energi
pada langkah sebelumnya, yang menjadi penghasil emisi sekunder. Proses ini iterasi sampai transfer energi adalah
bawah ambang batas, dan kita dapat mengatakan solusinya adalah stabil.
Ada sejumlah isu tentang pendekatan ini. Matriks dapat menjadi besar, terutama jika kita ingin
solusi pixel akurat. Tingkat 1.000-segitiga membutuhkan 1.000 x1, 000 matriks, dengan asumsi satu kebutuhan segitiga
satu patch persis. Itu jarang terjadi, karena kita akan membutuhkan resolusi lebih dan akan membagi segitiga
untuk menghitung hasil yang lebih halus. Solusi untuk masalah ini berasal dari perbaikan progresif, perbaikan
atas dasar algoritma radiositas diusulkan oleh Cohen, Chen, Wallace, dan Greenberg pada tahun 1988.
Dalam perbaikan progresif, kita tidak lagi menggunakan matriks radiositas untuk menghitung solusi. Sebaliknya, kita
menghitung permukaan larutan dengan permukaan. Kami memindai daftar permukaan dan pilih permukaan dengan yang paling
energi radiasi untuk berkontribusi ke tempat kejadian. Kemudian, kita "menembak" energi itu dan menyebarkannya ke tempat kejadian
menggunakan faktor bentuk. Hal ini menghasilkan redistribusi energi di seluruh patch. Kami kemudian memilih
permukaan dengan energi yang paling radiasi. Permukaan asli mungkin berada pada daftar calon, tetapi tidak dengan
jumlah energi yang sama: Energi itu sudah ditembak. Jadi, kita memilih radiator baru dan iterate
proses. Algoritma berhenti setiap kali radiator terbesar berikutnya memiliki tingkat energi bawah ambang batas,
dan dengan demikian kita dapat mengasumsikan kontribusinya terhadap solusi akhir adalah minimal. Seperti yang Anda lihat, kami belum berbicara
tentang matriks sama sekali. Yang kita butuhkan untuk menyimpan untuk perbaikan progresif untuk bekerja adalah tingkat energi dari semua
permukaan pada saat tertentu. Berikut adalah algoritma:
ulangi
pilih permukaan i dengan energi radiasi tertinggi
menyimpan faktor radiasi yang menghitung energi bentuk dari i ke semua permukaan lainnya j Fij
untuk setiap j permukaan
memperbarui pencahayaan berdasarkan Fij dan radiositas i
memperbarui energi radiasi berdasarkan Fij dan radiositas I
akhir untuk
mengatur emisi dari i ke nol
sampai energi radiasi dari permukaan yang dipilih <ambang
Keuntungan lain dari perbaikan progresif adalah bahwa pengamat bisa sangat baik mengawasi bangunan solusi
proses. Ini akan mulai dengan layar hitam, dan sebagai energi yang dipancarkan, adegan akan menyala. Ini
memungkinkan untuk penolakan yang cepat dari adegan yang solusinya tidak mencari yang baik dan untuk melihat dulu hasilnya.
Isu lain yang populer tentang radiositas adalah bagaimana faktor bentuk dihitung. Sejumlah solusi memiliki
telah diusulkan, dari ray tracing dan menghitung persentase sinar yang mencapai permukaan tujuan untuk
solusi analitis dan tekstur berbasis pendekatan. Definisi formal adalah sebagai berikut:
Fij = (cos  saya cos  j) / (pi * r2) * Hij DAJ
Dalam persamaan ini, cosinus merupakan selisih sudut antara kedua patch. Untuk menghitung mereka, kita
hanya perlu:
l Hitunglah vektor V yang merupakan arah dari pusat dari patch transmisi ke
pusat dari patch penerima.
l kosinus pertama adalah hasil dari perkalian titik dari vektor V dengan normal transmisi
patch.
l kosinus kedua adalah hasil dari perkalian titik dari vektor V dengan normal dari menerima
patch.
l Karena hasil dari perkalian titik adalah kosinus (asumsi vektor normal), kita memilih ini
kompak notasi.
Lalu, kita membagi hasilnya dengan Pi * r2 untuk memperhitungkan jarak antara patch. Lebih jauh patch harus memiliki
faktor bentuk yang lebih kecil karena kemungkinan cahaya dari satu mencapai yang lain berkurang. Faktor Pi adalah
diperlukan untuk menjelaskan sifat hemispherical dari energi yang dipancarkan. Tunas Patch transmisi keluar
energi dalam distribusi hemispherical, tidak dalam satu arah, dan faktor Pi yang menggabungkan ke dalam
membentuk faktor.
Fungsi H merupakan visibilitas dari patch untuk menambal i j. Bagaimana kita menangani occluders? Kita membutuhkan
membentuk faktor untuk memasukkan setiap oklusi potensial, sehingga dua patch dengan faktor bentuk yang besar dengan dinding
antara tidak memancarkan energi satu sama lain. H adalah sekedar faktor visibilitas yang skala hasil dari 0 ke 1
tergantung pada berapa banyak patch yang terlihat dari yang lain. H nama berasal dari visibilitas
algoritma yang digunakan oleh prosesor radiositas banyak, yang merupakan algoritma hemicube. Tempatkan hak hemicube
patch di atas pertimbangan dan discretize itu. Kemudian, menganalisis visibilitas secara sel demi sel dan
menyimpan sebagian kecil dari sel-sel terlihat pada parameter H. Pendekatan populer lainnya melibatkan sinar menembak menggunakan
sinar nonrecursive menelusuri pendekatan dan menyimpan sebagian kecil dari sinar yang benar-benar memukul patch berlawanan.
Parameter DAJ digunakan untuk menyatakan faktor bentuk dalam hal daerah diferensial. Faktor bentuk adalah
didefinisikan per elemen daerah sangat kecil dari patch menerima, sehingga harus kita ingin menghitung itu untuk seluruh
jalan, kita perlu kalikan dengan daerah patch itu.
Dengan ini penjelasan tentang bagaimana radiositas bekerja, mari kita periksa bagaimana kita dapat membangun peta cahaya berdasarkan radiositas.
Pada dasarnya, kita perlu representasi halus dari geometri tingkat, dimana setiap cahaya peta Texel
merupakan salah satu titik sampling dalam prosesor radiositas kami. Kami akan mulai dengan geometri tingkat, pengaturan
tingkat detail kita ingin bekerja dengan. Apakah salah satu Texel dalam peta cahaya merupakan salah satu sentimeter atau satu
meter? Dari analisis pertama, peta cahaya dengan ukuran yang tepat harus dialokasikan. Kemudian, setiap Texel di setiap
peta cahaya dapat digunakan untuk memicu loop pengolahan radiositas. Sebelum itu, kita perlu mengatur patch yang akan
menjadi radiasi, sehingga adegan kami memiliki beberapa informasi pencahayaan. Hal ini biasanya tertanam dalam pembuatan konten
alat. Kemudian, kita harus melakukan algoritma radiositas. Perbaikan progresif di sini adalah pilihan terbaik
karena matriks radiositas untuk setiap tingkat yang layak ukuran dapat menjadi tidak terkendali. Bayangkan bahwa Anda permainan
tingkat terdiri dari 10.000 segitiga (tidak jarang untuk Quake gaya penembak), namun karena peta cahaya
resolusi, yang diubah menjadi 2.560.000 patch (rata-rata, setiap peta cahaya yang texels 16x16 di
ukuran). Karena matriks radiositas adalah nxn, bersiaplah untuk menangani matriks 2Mx2M!
Kemudian, algoritma perbaikan progresif akan bekerja pada satu set tekstur yang menyandi baik
penerangan (yang merupakan bagian dari solusi akhir) dan energi radiasi, yang adalah apa yang kita akan mencoba untuk
meminimalkan dengan iterasi proses. Visibilitas dapat dihitung dengan berbagai cara, beberapa dari mereka dibantu oleh
penggunaan grafik adegan sendiri mesin, entah itu sebuah Partisi Ruang Binary (BSP) atau semacam portal
mesin. Komputasi Hij adalah salah satu hambatan utama dalam setiap pengolah radiositas.
Menyimpan Peta Cahaya
Menggunakan hanya satu peta cahaya mungkin baik untuk demo kecil, tapi begitu Anda ingin menerangi lengkap
tingkat permainan kebutuhan untuk menyimpan sejumlah besar peta cahaya muncul. Setelah semua, setiap dinding dan detail memiliki unik
sifat pencahayaan, sehingga jumlah peta cahaya harus berkorelasi dengan jumlah geometri dalam permainan
tingkat.
Tapi ini mungkin menjadi masalah besar sebagai persyaratan tekstur tumbuh: Berapa banyak peta cahaya yang akan kita
menyimpan? Apa ukuran masing-masing akan menjadi? Ini dan pertanyaan lain memiliki programer bermasalah mesin grafis
selama bertahun-tahun, dan untungnya beberapa solusi pintar telah ditemukan.
Untuk mulai dengan, peta cahaya biasanya tekstur resolusi sangat rendah, sering hanya beberapa piksel di seluruh. Ukuran
16x16, misalnya, tidak biasa. Alasan untuk resolusi ini berasal dari penyaringan tekstur: The
kartu grafis akan interpolasi antara texels berbeda, jadi peta lampu kecil dapat meregang selama
patch yang relatif besar. Bayangan tajam dan perubahan mendadak penerangan hanya akan mungkin jika lebih besar
peta cahaya yang digunakan. Namun untuk radiositas seperti kamar klasik dengan kontribusi pencahayaan diffuse besar, lowres
Peta harus sempurna.
Keputusan lain yang menarik adalah untuk pak peta cahaya beberapa tekstur, komposit global yang unik yang
merangkum mereka. Pikirkan tentang hal ini untuk kedua: Jika setiap peta cahaya membentang di satu atau dua segitiga saja,
kita akan berakhir dengan ratusan tekstur kecil, dan kita perlu menukar tekstur aktif sepanjang waktu.
Ingat bahwa swap tekstur yang mahal. Jadi, adalah sangat umum untuk menyimpan peta cahaya banyak di peta besar,
sehingga kami dapat membuat mereka semua dengan satu panggilan. Namun, ide ini jika tidak besar memiliki potensi downside:
menemukan algoritma yang secara otomatis dapat pak peta cahaya secara optimal. Tidak terdengar seperti masalah besar,
benar? Sayangnya, kejahatan mengintai dari sudut-sudut tak terduga, dan pengepakan peta cahaya pada tekstur yang lebih besar mungkin
jauh lebih sulit dari yang Anda bayangkan. Bahkan, ini merupakan contoh dari masalah komputasi klasik yang disebut "set
kemasan ": menempatkan objek N, masing-masing dengan bentuk yang berbeda, di dalam sebuah wadah untuk menemukan distribusi yang
memungkinkan alokasi ruang yang lebih baik. Masalah ini sangat terkenal, dan studi menunjukkan bahwa adalah sebuah NPHard
masalah.
NP-Hard masalah (seperti set kemasan dari pedagang keliling) adalah masalah begitu kompleks, tidak ada algoritma
dirancang untuk bekerja dalam waktu polinomial dapat menyelesaikannya. Dengan demikian, kita harus kembali ke pendekatan eksponensial,
yang merupakan "elegan" cara untuk menunjuk brute force pendekatan. Dalam contoh peta terang kita, kita perlu
untuk menguji semua konfigurasi yang mungkin untuk menemukan satu yang optimal. Dan, dengan ratusan bahkan ribuan
peta cahaya, algoritma eksponensial dapat berlangsung cukup lama untuk menghitung. Jadi beberapa algoritma heuristik telah dirancang. Algoritma ini jauh dari optimal, sehingga solusi
tidak akan sempurna. Tapi mereka berjalan di saat yang wajar. Sekarang saya akan menjelaskan salah satu algoritma yang
menggabungkan kecepatan dengan hasil yang cukup baik.
Idenya cukup sederhana: Mengalokasikan peta cahaya satu per satu, membangun sebuah pohon biner sepanjang jalan. Kami akan menggunakan
pohon untuk menentukan zona yang diduduki dan gratis sampai semua peta cahaya telah dimasukkan. Kemudian, untuk setiap cahaya
peta, kita menggunakan wilayah pohon di mana dapat dipasang lebih baik. Setiap kali kita menempatkan peta cahaya baru, kami
membagi node baru sehingga pohon mengembang dan melacak semua peta cahaya