Render yang efisien dengan banyak sumber cahaya

Untuk membuat adegan dengan sumber cahaya tunggal menggunakan phong shading, orang dapat menghitung warna akhir dari setiap fragmen yang dilewatkan ke dalam shader fragmen berdasarkan komponen ambient / difus / specular dari material dan sumber cahaya.

Ini dapat dengan mudah diperluas untuk mengakomodasi beberapa sumber cahaya dengan menambahkan bersama hasil penerapan masing-masing sumber cahaya ke fragmen seperti:

final_color = (0, 0, 0, 1)
for each light:
    final_color += apply_light(material, light)
final_color = clamp(final_color, (0,0,0,1), (1,1,1,1))

Namun, dengan jumlah sumber cahaya yang sangat besar, proses ini cukup lambat; dengan Nlampu, pendekatan ini membutuhkan perhitungan untuk phong shading dilakukan Nkali per fragmen.

Apakah ada pendekatan yang lebih baik untuk merender adegan dengan sejumlah besar sumber cahaya (ratusan, ribuan, dll.)?

Ya, tetapi Anda membutuhkan perubahan paradigma.

Apa yang Anda terbiasa disebut rendering maju. Anda mengirimkan geometri Anda dan kemudian Anda segera melanjutkan dengan shading pass. Dalam rendering dasar dasar Anda dapat memutar di dalam shader untuk setiap cahaya atau melakukan satu lintasan per cahaya dan mencampur hasilnya bersama-sama (dengan campuran aditif).

Tetapi banyak hal telah berkembang. Enters: Rendering Ditangguhkan

Sekarang begitu banyak varian yang menjelaskan semuanya secara terperinci akan membutuhkan lebih dari cukup untuk jawaban di sini. Jadi di sini saya hanya akan menjelaskan inti dari Deferred shading, ada banyak sumber daya lain yang dapat Anda temukan dengan mudah menggunakan google, semoga setelah membaca ini Anda akan memiliki kata kunci yang tepat untuk menemukan apa yang Anda butuhkan.

Ide dasarnya adalah untuk menunda naungan setelah turun pipa. Anda memiliki dua langkah utama:

1. Render geometri Anda dan semua informasi yang diperlukan untuk menaungi beberapa target render. Ini berarti bahwa biasanya dalam implementasi dasar Anda akan memiliki buffer kedalaman, buffer yang berisi normals dari geometri Anda dan warna albedo. Anda akan segera menemukan bahwa Anda memerlukan informasi lain dari bahan-bahan tersebut (mis. Faktor kekasaran, "logam", dll.).

Gambar ini dari wikipedia menunjukkan tiga buffer (warna, kedalaman dan normals)

Sekali lagi, jumlah, jenis dan isi buffer yang digunakan sangat bervariasi di antara berbagai proyek. Anda akan menemukan set buffer dengan nama GBuffers.

2. Setelah ini saatnya menerapkan pencahayaan yang sebenarnya. Selama lampu penerangan untuk setiap cahaya Anda ingin menggambar volume cahaya yang tergantung pada jenis cahaya:
   • Untuk cahaya directional, Anda membuat quad layar penuh.
   • Untuk titik cahaya Anda membuat bola di mana jari-jari didasarkan pada atenuasi titik cahaya Anda.
   • Untuk lampu sorot, Anda membuat kerucut yang dimensinya tergantung pada karakteristik cahaya Anda.

Dalam pixel shader pass ini, Anda melewatkan GBuffers dan melakukan pencahayaan dan naungan menggunakan informasi di dalamnya. Dengan cara ini Anda hanya memproses piksel yang dipengaruhi oleh masing-masing lampu yang memiliki kecepatan masuk akal jika dibandingkan dengan rendering maju klasik.

Ini juga memiliki berbagai kelemahan, terutama penanganan objek transparan dan konsumsi bandwidth dan memori video yang lebih tinggi. Tetapi juga sulit untuk menangani berbagai model bahan.

Anda memiliki kelebihan-kelebihan lain (karena memiliki banyak info yang siap untuk pasca-pemrosesan) dan juga cukup mudah untuk diterapkan. Tapi ini bukan hal yang paling keren untuk banyak lampu lagi.

Teknik yang lebih baru misalnya rendering ubin . Gagasan utama dari mereka adalah untuk membagi adegan di "layar" ruang layar dan menetapkan untuk setiap ubin lampu yang mempengaruhi itu. Ini ada dalam mode ditangguhkan dan maju. Teknik-teknik ini menyebabkan beberapa masalah ketika Anda memiliki berbagai diskontinuitas kedalaman dalam ubin, tetapi umumnya lebih cepat dari yang ditangguhkan klasik dan memecahkan berbagai masalah itu. Misalnya, di antara kelebihannya, dengan ubin yang ditangguhkan, Anda membaca GBuffers satu kali setiap fragmen dan piksel di ubin yang sama secara koheren memproses lampu yang sama.

Evolusi lebih lanjut pada sisi ini adalah naungan Clustered yang secara konseptual mirip dengan pendekatan berbasis ubin, memiliki alih-alih ubin ruang layar, cluster dengan tingkat 3D. Metode ini menangani lebih baik masalah diskontinuitas kedalaman dan umumnya berkinerja lebih baik daripada metode ubin.

CATATAN PENTING: Saya telah menjelaskan dasar-dasar naungan yang ditangguhkan. Ada beberapa variasi, optimisasi dan peningkatan di sekitar jadi saya mendorong Anda untuk bereksperimen dengan versi sederhana dan kemudian melakukan riset tentang teknik lain seperti yang saya sebutkan di atas.