Sedikit tentang Phong shading

“Kita tidak dapat berharap bahwa kita akan dapat menampilkan objek persis seperti pada kenyataannya, dengan tekstur, bayangan, dll. Kami hanya berharap untuk membuat gambar yang cukup dekat untuk mencapai tingkat realisme tertentu. "

Bui Tyong Fong

Bui Thuong Fong lahir pada tahun 1941 dan menjadi ilmuwan komputer selama Perang Vietnam. Pasti sulit baginya untuk menyelesaikan studinya di lingkungan beracun tahun 60-an, belum lagi fakta bahwa ia dipanggil ke garis depan! Tapi dia berhasil bertahan dan bertahan hingga 1975, sebelum leukemia mengambil hidupnya hanya dua tahun setelah dia meletakkan dasar bagi dunia teori pencahayaan dan naungan modern: shader Fong . Nama-nama Vietnam terdiri dari tiga bagian: nama keluarga, nama tengah dan nama pribadi. Yaitu, ketika orang mengatakan "Fong shader", mereka memanggil nama pribadi Bui Tyong. Anda dapat membaca lebih lanjut tentang nama pribadi di Wikipedia .


Saya tidak yakin apakah ini Phong, tetapi menurut Google, ya.

"Biarkan lembut sinar matahari yang nyaman
Mainkan di sekitar tempat tidurku yang sekarat,
E'er lembah remang-remang
Saya dengan kaki kesepian harus melangkah. “

Let The Light Enter - sebuah puisi karya Francis Harper

Shader Phong didasarkan pada matematika yang sangat ringkas. Yang mana, pada kenyataannya, Anda tidak perlu tahu, kecuali jika Anda dengan tulus ingin menjadi seorang programmer grafis. Namun, dalam jangka panjang, pengetahuannya akan bermanfaat. Di bawah ini adalah kutipan dari OpenGL Superbible, Edisi ke-7 oleh Graham Sellers dan Kronos Group ARB Foundation.

A) Beberapa konsep

Pertama, mari kita cari tahu konsepnya. Jika Anda telah berurusan dengan pemodelan 3D atau pengembangan game bahkan untuk satu menit, maka Anda pasti sudah menemukannya, tetapi pengulangan tidak mengganggu siapa pun.

A-1) Cahaya Sekitar

Sebagian besar buku, terutama yang berkualitas rendah, membandingkan pencahayaan ini dengan sinar matahari, tetapi ini sama sekali tidak benar. Pencahayaan ambient bukan sinar matahari. Itu datang dari segala arah , yaitu di mana-mana, tetapi dalam perhitungan itu hanya vektor dengan tiga komponen. Dalam naungan Phong, ditambahkan pada akhirnya, tetapi tidak berubah.

A-2) Cahaya Diffuse / Diffuse

Pencahayaan baur memiliki arah. Ini sebenarnya adalah komponen terarah dari sumber cahaya [sic] . Di bioskop, cahaya tersebar menggunakan kotak lunak, dan dalam grafik komputer, cahaya tersebar menggunakan rumus, yang akan kami tunjukkan di bawah ini. Besarnya, yaitu ukuran iluminasi yang tersebar, tergantung pada permukaannya. Misalnya, jika permukaannya matte, artinya ia menyerap lebih dari cahaya yang dipantulkan, maka nilainya akan lebih besar daripada jika permukaannya halus.


Cahaya ambient yang berserakan / terserap dari layar yang buram

A-3) Sorotan Specular

Seperti pencahayaan yang tersebar, cahaya yang dipantulkan adalah arah, tetapi didasarkan pada permukaan yang mengkilap; ia meninggalkan highlight yang disebut shininess . Dalam kehidupan nyata, gloss bukanlah bagian integral dari material. Bahkan, lapisan film atau setetes lilin akan menambah lebih banyak ke kilau daripada yang lain. Gloss yang dipantulkan adalah faktor yang berkisar dari 0 hingga 128, karena pada nilai di atas 128 itu tidak akan sangat mempengaruhi shader.


Film dengan film - kertas berwarna tebal dengan lapisan film mengkilap, hadiah nyata untuk anak.

A- 4) Albedo

Ini adalah sebagian kecil dari cahaya yang dipantulkan oleh permukaan.

A-5) Formula Phong

Rumus untuk menghitung bahan menurut Phong adalah sebagai berikut:

$$

$$I_p = k_ai_a + k_d \ kiri (\ vec {L}. \ Vec {N} \ kanan) i_d + k_s \ kiri (\ vec {R}. \ Vec {V} \ kanan) ^ \ alpha i_s$$

Dimana:

$$$k_a$ : Bahan sekitar

$$$k_d$ : Bahan difus

$$$k_s$ : Bahan specular dan $$$\ alpha$ : nilai gloss

$$$i_a$ : pencahayaan sekitar

$$$i_d$ : pencahayaan difus

$$$i_s$ : pencahayaan tidak langsung

Anda mungkin bertanya, bagaimana dengan vektor? Jangan khawatir, sekarang kami akan memberi tahu mereka:

$$$\ vec {N}$ : normal ke permukaan

$$$\ vec {L}$ : vektor satuan dari titik berarsir ke sumber cahaya (dengan kata lain, vektor cahaya)

$$$\ vec {R}$ : refleksi nilai negatif dari vektor cahaya

$$$\ overrightarrow {V}$ : vektor diarahkan ke penampil

B) Gouraud Shading

Sebelum memulai shading Fong, mari kita lihat bagaimana Anda bisa mendapatkan Gouro shading di GLSL. Harap dicatat bahwa saya menggunakan versi GLSL 4.1, seperti dalam Superbible, tetapi jika Anda adalah penggemar www.learnopengl.com , maka Anda dapat menggunakan 3.3. Itu tidak masalah. Jadi, mari kita lihat apa Gouraud shading itu.

Metode naungan ini ditemukan oleh Henri Gouraud pada tahun 1971. Ini tidak melampaui Phong shading dengan cara apa pun, dan hari ini ini terutama digunakan sebagai metode pratinjau pemuatan tanpa GPU dalam paket seperti Cinema 4D. Masalahnya adalah bahwa suar yang ia hasilkan tampak seperti percikan:


Masalah ini disebabkan oleh interpolasi warna antara simpul, dan kesenjangan antara segitiga terjadi karena warna diinterpolasi secara linear. Masalah ini hanya diselesaikan di shader Phong. Mari kita lihat bagaimana Anda dapat menerapkan shading Gouro di GLSL 4.1.

Listing 1 : Vertex Gourox vertex pada GLSL 4.1

#version 410 core // Per-vertex inputs layout (location = 0) in vec4 position; layout (location = 1) in vec3 normal; // Matrices we'll need layout (std140) uniform constants { mat4 mv_matrix; mat4 view_matrix; mat4 proj_matrix; }; // Light and material properties uniform vec3 light_pos = vec3(100.0, 100.0, 100.0); uniform vec3 diffuse_albedo = vec3(0.5, 0.2, 0.7); uniform vec3 specular_albedo = vec3(0.7); uniform float specular_power = 128.0; uniform vec3 ambient = vec3(0.1, 0.1, 0.1); // Outputs to the fragment shader out VS_OUT { vec3 color; } vs_out; void main(void) { // Calculate view-space coordinate vec4 P = mv_matrix * position; // Calculate normal in view space vec3 N = mat3(mv_matrix) * normal; // Calculate view-space light vector vec3 L = light_pos - P.xyz; // Calculate view vector (simply the negative of the view-space position) vec3 V = -P.xyz; // Normalize all three vectors N = normalize(N); L = normalize(L); V = normalize(V); // Calculate R by reflecting -L around the plane defined by N vec3 R = reflect(-L, N); // Calculate the diffuse and specular contributions vec3 diffuse = max(dot(N, L), 0.0) * diffuse_albedo; vec3 specular = pow(max(dot(R, V), 0.0), specular_power) * specular_albedo; // Send the color output to the fragment shader vs_out.color = ambient + diffuse + specular; // Calculate the clip-space position of each vertex gl_Position = proj_matrix * P; } 

Dan sekarang shader fragmen.

Listing 2: Shader fragmen dari konsep yang sama.

 #version 410 core // Output layout (location = 0) out vec4 color; // Input from vertex shader in VS_OUT { vec3 color; } fs_in; void main(void) { // Write incoming color to the framebuffer color = vec4(fs_in.color, 1.0); } 

C) Phong Shading

Sebelum melanjutkan, mari kita ingat bahwa pencahayaan Phong dan Phong adalah dua konsep yang berbeda. Anda dapat menyingkirkan "serpihan salju" suar Gouro dengan menambahkan lebih banyak simpul, tetapi mengapa jika kita memiliki naungan di Fong? Dalam naungan Phong, warna tidak diinterpolasi di antara simpul (seperti pada Listing 1 dan 2), kami menginterpolasi antara simpul normal ke permukaan , dan menggunakan normal yang dihasilkan untuk melakukan semua perhitungan pencahayaan untuk setiap piksel , bukan simpul. Namun, ini berarti bahwa shader fragmen harus melakukan lebih banyak pekerjaan, seperti yang ditunjukkan pada Listing 4. Tapi pertama-tama, mari kita lihat vertex shader.


Listing 3: vertex shader dari Phong shader di GLSL 4.1.

 #version 410 core // Per-vertex inputs layout (location = 0) in vec4 position; layout (location = 1) in vec3 normal; // Matrices we'll need layout (std140) uniform constants { mat4 mv_matrix; mat4 view_matrix; mat4 proj_matrix; }; // Inputs from vertex shader out VS_OUT { vec3 N; vec3 L; vec3 V; } vs_out; // Position of light uniform vec3 light_pos = vec3(100.0, 100.0, 100.0); void main(void) { // Calculate view-space coordinate vec4 P = mv_matrix * position; // Calculate normal in view-space vs_out.N = mat3(mv_matrix) * normal; // Calculate light vector vs_out.L = light_pos - P.xyz; // Calculate view vector vs_out.V = -P.xyz; // Calculate the clip-space position of each vertex gl_Position = proj_matrix * P; } 

Hampir tidak ada yang berubah. Namun dalam fragmen shader, situasinya benar-benar berbeda.

Daftar 4: Fong fragmen shader shader.

 #version 410 core // Output layout (location = 0) out vec4 color; // Input from vertex shader in VS_OUT { vec3 N; vec3 L; vec3 V; } fs_in; // Material properties uniform vec3 diffuse_albedo = vec3(0.5, 0.2, 0.7); uniform vec3 specular_albedo = vec3(0.7); uniform float specular_power = 128.0; uniform vec3 ambient = vec3(0.1, 0.1, 0.1); void main(void) { // Normalize the incoming N, L and V vectors vec3 N = normalize(fs_in.N); vec3 L = normalize(fs_in.L); vec3 V = normalize(fs_in.V); // Calculate R locally vec3 R = reflect(-L, N); // Compute the diffuse and specular components for each fragment vec3 diffuse = max(dot(N, L), 0.0) * diffuse_albedo; vec3 specular = pow(max(dot(R, V), 0.0), specular_power) * specular_albedo; // Write final color to the framebuffer color = vec4(ambient + diffuse + specular, 1.0); } 

Nah, ini adalah akhir artikel, saya harap Anda menikmatinya. Jika itu memicu minat di OpenGL, Anda dapat membeli OpenGL Superbible di Amazon atau menjelajahi learnopengl.com. Jika Anda tidak bisa berurusan dengan shader, saya sarankan Book of Shaders .