Multipass Teknik
Bayangkan bahwa Anda ingin melukis dinding bata besar. Anda menggunakan pola bata ubin, yang memberikan dinding solid
melihat. Kita telah melihat bagaimana untuk mencapai hal ini dengan pemetaan tekstur konvensional. Tapi dinding bata yang jelas adalah
tidak terlalu menarik, sehingga Anda memutuskan untuk menambahkan kemampuan untuk mewakili tanda peluru dinamis di dinding sebagai
pemain menembak pistol itu. Untuk mencapai efek ini, Anda awalnya mempertimbangkan memiliki tekstur peta dua (salah satu
dinding kosong dan satu lagi dari dinding yang sama dengan tanda bullet), menggunakan yang sesuai di
tepat waktu. Tapi ini tidak praktis. Bagaimana jika pengguna tunas di lokasi yang berbeda di dinding, atau bahkan
lebih buruk, menembak beberapa kali? Apakah Anda akhirnya memiliki peta N tekstur untuk apa yang seharusnya menjadi sederhana
efek?
Solusi untuk masalah ini (dan banyak lainnya) adalah untuk multipass teknik rendering.Kita dapat menggunakan beberapa
lapisan tekstur, yang dapat dicampur bersama-sama, sehingga hasil komposit terlihat baik sekaligus menjaga
wajar memori tapak. Dengan pendekatan multipass, kita hanya akan memiliki tekstur bata dan kecil
tekstur peta mewakili tanda bullet (tanpa batu bata). Anda dapat melihat kedua peta dalam Gambar 18.5.
Gambar 18.5. Bata dan peluru, menunjukkan peta asli (kiri), tanda peluru
(Tengah), dan gambar komposit (kanan).
Kemudian, kita akan melukis lapisan pertama atau lulus dengan tekstur bata. Setelah lulus pertama, kami akan menambahkan
kedua lapisan dengan tekstur tanda peluru di tempat yang tepat di dinding. Kita hanya perlu berhati-hati untuk berbaur
kedua peta dengan baik, sehingga efek yang tepat tercapai. Multipass teknik rendering adalah alat untuk
meningkatkan realisme layar. Berikut adalah daftar dari kemungkinan menggunakan:
l Decals (peluru tanda, tato, langkah kaki, dan sebagainya)
l pencahayaan Per-pixel diffuse dan specular
l Tembus objek
l Tingkat detail texturing
Render multipass adalah, di sisi lain, lebih lambat dibandingkan dengan pendekatan tradisional, single-pass. Kami akan
mengirimkan geometri lebih untuk frame buffer karena kita akan menggunakan ekstra texturing lolos ke encode khusus
efek, sehingga aplikasi akan mengalami perlambatan yang signifikan.
Coding algoritma render multipass hanya sedikit lebih kompleks daripada coding render biasa
http://www.tar.hu/gamealgorithms/ch18lev1sec6.html (1 of 4) 2009/02/09 06:10:33
http://www.tar.hu/gamealgorithms/ch18lev1sec6.html
algoritma. Langkah-langkah kunci untuk blok render N-pass adalah
1. Cat lapisan 0 geometri dengan tekstur lapisan 0.
2. Siapkan Z-buffer untuk menerima data coplanar.
3. Meningkatkan kontra lapisan.
4. Mengatur operasi pencampuran tepat untuk lapisan saat ini.
5. Cat lapisan saat ini dengan teksturnya.
6. Jika Anda belum selesai, lanjutkan ke langkah 3.
Sebagai contoh, di sini adalah source code untuk membuat quad menggunakan pendekatan multipass dalam OpenGL:
/ / Set tekstur pertama
glBindTexture (GL_TEXTURE_2D, layer0id);
/ / Membuat quad, lulus pertama
glBegin (GL_QUADS);
glColor3f (1,1,1);
glTexCoord (0,0); glVertex3f (-1,0, -1);
glTexCoord (0,1); glVertex3f (-1,0,1);
glTexCoord (1,1); glVertex3f (1,0,1);
glTexCoord (1,0); glVertex3f (1,0, -1);
glEnd ();
/ / Menerima co-planar fragmen
glDepthFunc (GL_LEQUAL);
/ / Set blending mode
glEnable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
/ / Set tekstur kedua
glBindTexture (GL_TEXTURE_2D, layer1id);
/ / Membuat kedua lulus
glBegin (GL_QUADS);
glColor3f (1,1,1);
glTexCoord (0,0); glVertex3f (-1,0, -1);
glTexCoord (0,1); glVertex3f (-1,0,1);
glTexCoord (1,1); glVertex3f (1,0,1);
glTexCoord (1,0); glVertex3f (1,0, -1);
glEnd ();
glDepthFunc (GL_LESS); / / kembali ke modus kedalaman yang normal
glDisable (GL_BLEND); / / tidak perlu dicampur lagi
Lulus render pertama dari kode sebelumnya membutuhkan penjelasan. Itu hanya melukis quad dengan tekstur
peta. Tapi perhatikan bahwa kita akan rendering quad yang sama di kedua lulus, menggunakan tekstur yang berbeda
http://www.tar.hu/gamealgorithms/ch18lev1sec6.html (2 dari 4) 2009/02/09 06:10:33
http://www.tar.hu/gamealgorithms/ch18lev1sec6.html
saat ini. Itulah alasan kita perlu mengubah default Z-buffer perilaku. Secara default, Z-buffer
dimodifikasi oleh sebuah fragmen jika (dan hanya jika) fragmen Z-nilai adalah sangat kecil dibandingkan dengan nilai Z-disimpan dalam
Z-buffer. Untuk memungkinkan lulus render kedua, kita harus santai pembatasan ini dan memungkinkan fragmen jika yang Zvalue
lebih kecil atau sama dengan isi dari buffer Z-.
Item kedua yang harus diperhatikan adalah persamaan campuran. Jika kita tidak menggunakan blending, quad kedua akan
menimpa quad pertama, dan semua kita akan melihat akan menjadi peta tekstur kedua. Untuk menghindari hal ini, kita harus menggunakan
fungsi campuran, yang menggabungkan lapisan yang berbeda sesuai dengan persamaan campuran.
Persamaan Blending ditentukan dalam hal sumber dan fragmen tujuan. Untuk memahami peran
kedua, ingatlah bahwa fragmen sumber dicat dengan fragmen tujuan. Jadi, dalam dua-pass
render rutin seperti yang sebelumnya, fragmen sumber adalah apa yang akan kita cat untuk frame buffer
(Dengan demikian, data baru akan ditambahkan ke komposisi), sedangkan fragmen tujuan mewakili apa yang
sudah dalam frame buffer (biasanya, data dari tahap render sebelumnya).
Persamaan pencampuran menentukan bagaimana sumber dan tujuan fragmen akan dikombinasikan bersama dalam
multipass inti. Berikut ini adalah pandangan umum dari persamaan ini:
tujuan = tujuan * destination_factor + source * source_factor
Jelas, semua yang perlu kita lakukan adalah memberikan faktor perkalian sehingga kita dapat menghitung nilai output untuk itu
pixel. Faktor perkalian biasanya tidak diberikan langsung tapi sebagai sebuah konstanta simbolis Tabel 18,1 berisi.
simbolis konstanta.
Tabel 18.1. Konstanta simbolis untuk OpenGL dan DirectX
OpenGL DirectX
GL_ZERO D3DBLEND_ZERO
GL_ONE D3DBLEND_ONE
GL_SRC_ALPHA D3DBLEND_SRCALPHA
GL_DST_ALPHA D3DBLEND_DESTALPHA
GL_SRC_COLOR D3DBLEND_SRCCOLOR
GL_DST_COLOR D3DBLEND_DSTCOLOR
GL_ONE_MINUS_SRC_ALPHA D3DBLEND_INVSRCALPHA
GL_ ONE_MINUS_DST_ALPHA D3DBLEND_INVDESTALPHA
GL_ ONE_MINUS_SRC_COLOR D3DBLEND_INVSRCCOLOR
GL_ ONE_MINUS_DST_COLOR D3DBLEND_INVDESTCOLOR
Dan persamaan campuran ditentukan oleh panggilan berikut:
http://www.tar.hu/gamealgorithms/ch18lev1sec6.html (3 dari 4) 2009/02/09 06:10:33
http://www.tar.hu/gamealgorithms/ch18lev1sec6.html
OpenGL:
kekosongan glBlendFunc (source_factor, destination_factor);
DirectX:
pd3dDevice9-> SetRenderState (D3DRS_SRCBLEND, source_factor);
pd3dDevice9-> SetRenderState (D3DRS_DESTBLEND, destination_factor);
Kedua API benar-benar setara dalam hal ini, hanya perbedaan sintaksis kecil ada. Tapi mendapatkan
mode blending yang tepat membutuhkan latihan, jadi di sini adalah pengingat kombinasi yang paling populer
sumber dan tujuan:
l satu satu Aditif campuran; digunakan untuk "membakar" permukaan dengan sorot specular; caustic laut dan sebagainya
pada.
l src_alpha one_minus_src_alpha Filtered pencampuran; berguna untuk membuat permukaan kaca. Sumber
(Pass kedua) alpha akan mengatur opacity kaca itu. Hal ini juga berguna untuk peta terang.
Teknik multipass dapat diperpanjang ke sejumlah berlalu. Anda dapat menambahkan kotoran, kemudian menerapkan sebuah difus
pencahayaan efek, dan menambahkan specular highlights di atas itu. Tapi ingat bahwa kinerja akan menurun sebagai
meningkatnya jumlah segitiga yang diberikan. Selain itu, perhatikan bahwa geometri lukisan dengan pencampuran
diaktifkan sering lebih lambat dibandingkan tanpa campuran, sehingga kinerja akan menurun drastis jika Anda tidak
mengontrol penggunaan pencampuran.
Tekstur Optimasi
Menggunakan tekstur banyak kualitas penting untuk menciptakan dipercaya, tampan tingkat. Tapi tekstur yang mahal.
Sebuah tunggal 256 x 256 peta tekstur RGB mengambil sebagai sebanyak 192KB. Jika Anda ingin mipmapping di atas itu, Anda
jejak memori peta akan berlipat ganda. Dan, jujur saja, Anda akan memerlukan puluhan peta yang berbeda untuk membuat setiap
tingkat. Berhenti untuk kedua dan mencoba untuk memperkirakan berapa banyak memori yang Anda akan perlu untuk menyimpan semua Anda
tekstur peta. Seorang pengembang sesama pernah mengatakan kepada saya dia menggunakan antara 40 dan 100 peta per tingkat, dan bahwa
adalah permainan di dalam ruangan! Pada beberapa titik waktu (lebih baik lebih cepat daripada nanti), Anda akan menemukan Anda memiliki kurang
memori di platform target Anda dari yang Anda butuhkan. Hal ini terutama berlaku di konsol, di mana memori
merupakan sumber daya berharga, tetapi berlaku untuk pengembangan game PC juga. PC memiliki kolam memori yang lebih besar pada
subsistem grafis, tapi bus lebih lambat, dan dengan demikian mengurangi ukuran memori sangat penting utama di sini
juga. Anda bisa mencoba untuk menerapkan kebijakan caching, yang merupakan langkah yang baik, tetapi karena Anda akan menemukan di
selanjutnya bagian, yang tidak memecahkan semua masalah Anda. Pindah tekstur naik turun bus maka akan menjadi
pembunuh kinerja.
Jelas, Anda harus berpikir sangat hati-hati tentang berapa banyak memori yang akan mendedikasikan ke peta tekstur. Dalam
bagian, pertama kita akan mengeksplorasi ide-ide sederhana beberapa yang dapat sangat mengurangi jejak tekstur Anda. Sebagian besar
waktu, kita menyia-nyiakan bit berharga dengan menyimpan tekstur tidak efisien.Setelah Anda mampu untuk menjaga penggunaan memori untuk
minimal, kita akan terus mengeksplorasi teknik tekstur real-time kompresi.
Opsi pertama Anda dapat menjelajahi adalah untuk mengurangi kedalaman warna dalam peta Anda. API yang paling mendukung fitur ini
internal, sehingga Anda hanya harus menentukan ini pada waktu buka, dan GPU akan mengurusnya. Keuntungannya adalah
jelas: peta yang lebih kecil. The downside adalah hilangnya persepsi kualitas, yang dalam banyak kasus akan kentara
pula. Salah satu pengurangan warna format yang paling populer adalah RGB4 (RGB, empat bit per komponen), yang
membutuhkan 12 bit per pixel (dan 16 bit per pixel dalam RGBA4). Mode ini bekerja dengan sangat baik dalam tekstur yang melakukan
tidak memiliki gradien warna halus, yang untungnya merupakan mayoritas besar.Gradien seragam pada gambar di sebelah kiri
hilang pada gambar di sebelah kanan, jadi ini akan menjadi contoh yang sangat baik ketika teknik ini seharusnya tidak
digunakan. Perubahan warna halus tidak mengurangi baik. Tapi tekstur paling akan menghasilkan hasil yang lebih baik. Dalam Gambar 18,4,
Anda dapat melihat dua peta yang hampir persis sama. Satu peta dikodekan menggunakan RGB4, dan yang lainnya adalah
standar RGB. Dapatkah Anda tahu bedanya? Bahkan jika Anda bisa, ingat bahwa kartu grafis tampil penyaringan
dalam ruang RGB, jadi mereka akan membantu lebih banyak lagi untuk membuat pengurangan warna tidak terlalu mencolok. By the way,
peta RGB4 adalah satu di sebelah kanan.
Gambar 18.4. Sebuah gradien terlihat pada RGBA8 (kiri) dan RGBA4 (kanan) format.
http://www.tar.hu/gamealgorithms/ch18lev1sec5.html (1 of 4) 2009/02/09 06:09:58
http://www.tar.hu/gamealgorithms/ch18lev1sec5.html
Beberapa pengurangan warna format ada, dan RGB4 kebetulan menjadi sangat populer. Anda bisa, bagaimanapun, gunakan
format lain dalam situasi tertentu. Misalnya, Anda dapat menyimpan penerangan hanya tekstur dengan menggunakan ALPHA4
format (alpha saja, empat bit per pixel). Pada akhirnya, aturan praktis adalah untuk memeriksa API Anda dan pilih
format yang memberikan tampilan visual yang tepat menggunakan ruang kurang.DirectX adalah pemenang di sini karena
menyediakan format eksotis yang sangat berguna dalam situasi tertentu.
Mengambil skema warna-pengurangan yang ekstrim, kita bisa langsung menggunakan peta tekstur palletized. Ini adalah
8-bit bitmap di mana setiap pixel mewakili bukan nilai RGB, tetapi indeks ke tabel 256-entri, seperti
dalam skema kuantisasi klasik. Peta palletized sehingga menempati sekitar sepertiga ukuran RGB
tekstur peta (ditambah ruang untuk palet). Sekali lagi, memutuskan kapan harus menggunakan palet adalah masalah mengetahui
tekstur Anda. Gradien dan kaya warna peta mungkin menurunkan secara signifikan, tetapi banyak peta akan terlihat bagus di
8 bit. Juga, 8-bit tekstur medan biasanya terlihat bagus bila diterapkan pada beberapa jenis tekstur detail dan
pencahayaan. Seperti biasa, memiliki kedua pilihan di mesin permainan Anda pasti kebijakan terbaik.
Tekstur Kompresi
Setelah semua pilihan Anda telah dipertimbangkan dan mencoba, Anda masih mungkin perlu untuk mengurangi ukuran tekstur bahkan
lebih lanjut. Jika demikian, itu kemudian waktu untuk melaksanakan kompresi tekstur.Kemungkinan besar, Anda akan memiliki tekstur sudah
menyusut menggunakan warna-teknik pengurangan, jadi kompresi akan icing pada kue. Menggunakan kompresi ketika
sebagian besar ruang tekstur Anda tidak dikelola dengan baik tidak masuk akal.
Kompresi Tekstur mengambil peta dalam format kompresi dan hanya decompress mereka secara internal pada
GPU untuk ditampilkan. Dengan demikian, baik ukuran file dan jejak memori lebih kecil dari terkompresi dengan
peta. Kelemahannya adalah bahwa kompresi tekstur memiliki kinerja sukses kecil, karena kebutuhan GPU
siklus jam tambahan untuk memetakan texels ke layar. Skema kompresi Beberapa ada. Beberapa dari mereka adalah
berpemilik, dan beberapa publik. Demikian pula, beberapa menyediakan kompresi lossless, sedangkan yang lain menurunkan
kualitas tekstur dalam proses.
DirectX menyediakan dukungan yang sangat baik untuk kompresi tekstur yang elegan dibangun ke API inti. Untuk
Misalnya, baris berikut memuat peta tekstur dengan sifat penuh termasuk:
D3DXCreateTextureFromFileEx (pd3dDevice, strPath, D3DX_DEFAULT,
http://www.tar.hu/gamealgorithms/ch18lev1sec5.html (2 dari 4) 2009/02/09 06:09:58
http://www.tar.hu/gamealgorithms/ch18lev1sec5.html
D3DX_DEFAULT, D3DX_DEFAULT,
0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_FILTER_TRIANGLE | D3DX_FILTER_MIRROR,
D3DX_FILTER_TRIANGLE | D3DX_FILTER_MIRROR,
0, NULL, NULL, ppTexture);
Keindahan dari pendekatan ini adalah bahwa pada satu panggilan kita setting tekstur objek yang kita inginkan untuk memuat, yang
sumber data, pilihan penyaringan dan pilihan mipmapping, dan kompresi tekstur, yang dikenal otomatis
dari file tersebut kita lulus sebagai parameter. Dengan demikian, programmer tidak perlu khawatir tentang rincian tersebut.
Pengembang OpenGL akan memiliki waktu yang sedikit lebih terlibat karena mereka perlu secara manual menangani
kompresi. Ini digunakan untuk dilakukan melalui perpanjangan ARB_texture_compression, tetapi sekarang merupakan bagian dari
OpenGL inti. Urutan panggilan utama untuk ekstensi ini adalah
ddsimage = ReadDDSFile ("flowers.dds", & ddsbufsize, & numMipmaps);
glBindTexture (GL_TEXTURE_2D, already_compressed_decal_map);
glCompressedTexImage2D (GL_TEXTURE_2D, 0, ddsimage-> format,
ddsimage-> lebar, ddsimage-> tinggi, perbatasan, image_size,
ddsimage-> piksel);
yang secara langsung mendownload tekstur terkompresi di Permukaan Menggambar Langsung (DDS) format untuk OpenGL.
Ingat bahwa karena DDS adalah bagian dari DirectX, kita perlu melakukan termasuk jika kita ingin mengakses tekstur dalam
format ini. File DDS untuk kedua DirectX dan OpenGL dapat dibuat menggunakan DxTex, alat termasuk dalam
DirectX SDK.
Tekstur Caching dan Pager
Meskipun semua upaya pengurangan warna dan kompresi, dalam banyak kasus Anda tidak akan dapat menyimpan semua
tekstur di memori video. Ingat bahwa memori video Anda adalah sumber daya terbatas, dan juga harus
mengakomodasi buffer berbeda (dua untuk double buffering, ditambah Z-buffer, ditambah stensil, dan sebagainya) serta
sebagai geometri penduduk. Akibatnya, permainan yang paling menggunakan peta lebih dari yang mereka dapat disimpan dalam GPU. Jadi jelas,
beberapa kebijakan caching harus dilaksanakan.
Aturan akal praktis adalah bahwa himpunan tekstur yang dibutuhkan untuk membuat frame tertentu (kadang-kadang
disebut working set) harus sesuai dalam memori GPU sepenuhnya. Tekstur Swapping harus disimpan ke
minimum (seperti karakter Anda bepergian bersama tingkat dan menemukan daerah baru dengan berbagai
peta). Swapping secara frame-by frame adalah mimpi buruk kinerja dan harus dihindari di semua biaya.
Jika aturan ini diikuti, kita akan memiliki tekstur yang menghabiskan beberapa frame di memori video, dan karena mereka
menjadi tidak terpakai, bisa bertukar keluar untuk memberikan ruang bagi yang baru.Dengan pemikiran ini, kita bisa membangun
caching mesin.
Mesin akan memiliki kolam memori terdiri dari N tekstur (nilai N tergantung pada tersedia
memori fisik). Setiap tekstur cache harus terdiri dari struktur seperti ini:
typedef struct
{
texturedata * texdata;
timestamp unsigned long;
Cachedtexture};
Kita perlu cap waktu untuk mengontrol kapan tekstur yang terakhir diakses, sehingga kita dapat mengimplementasikan beberapa jenis
http://www.tar.hu/gamealgorithms/ch18lev1sec5.html (3 dari 4) 2009/02/09 06:09:58
http://www.tar.hu/gamealgorithms/ch18lev1sec5.html
swapping kebijakan. Jadi, untuk setiap frame yang diberikan, kita harus memperbarui atribut timestamp untuk tekstur masing-masing
peta yang sudah benar-benar digunakan. Ini memiliki biaya CPU yang sangat rendah dan memungkinkan kita untuk melacak yang tekstur adalah
"Segar" (sedang bertanya sepanjang waktu) dan yang "semakin tua."
Setiap kali kita mendapatkan permintaan tekstur, kita perlu melakukan hal berikut:
terlihat jika tekstur dalam cache
jika sudah, menggunakannya dan memperbarui timestamp
lain
/ / Kita punya rindu
memindai cache, mencari tekstur tertua
menukar-out tekstur yang dipilih
Swap-in yang baru
akhir jika
Perhatikan bahwa kami menerapkan terakhir-terakhir digunakan (LRU) kebijakan. Ini berarti kita membuang peta yang
adalah terakhir digunakan, dan menggunakan ruang itu untuk mengalokasikan peta baru. Sebuah kebijakan alternatif, pertama, keluar pertama (FIFO),
memastikan bahwa peta tertua dalam cache tersebut akan dibuang, tidak peduli seberapa baru itu digunakan. Karena ini
mesin cache akan memiliki hit kinerja yang sangat rendah (kecuali untuk yang sebenarnya swapping, yang akan tergantung pada
bus kecepatan anda), kita dapat menggunakan LRU, yang merupakan algoritma yang paling tepat karena menghasilkan sedikit
jumlah meleset.
Selain itu, perhatikan bahwa kita perlu cache yang setidaknya mampu menahan tekstur yang dibutuhkan untuk membuat satu
frame (ditambah beberapa ruang ekstra untuk memiliki margin tertentu). Mesin cache tidak dapat melakukan pekerjaan mereka pada bingkai per-
dasar. Jumlah meleset harus satu dari setiap frame N, dengan N yang lebih besar menghasilkan nilai yang lebih baik
kinerja.
Keterangan :
Terjemahan : Buku Core Techniques and Algorithms in Game Programming
Chapter 18. Tekture Mapping
Sub Texture Optimization
Multipass Techniques
Multipass Techniques
Tidak ada komentar:
Posting Komentar