RSS

Terjemahan buku “core techniques & algorithm in game programming”

19 Jun

Chapter 16 — Cinematography

 “Film harus dimulai dengan sebuah gempa bumi, dan terus berkembang dalam tindakan

(Cecil B De Mille)

Game lama sekolah tidak lebih dari beberapa peri-peri yang terlukis pada layar melalui speaker. Tetapi seperti teknologi yang telah berkembang dan kerajinan kami pun telah menjadi lebih canggih, perhatian terhadap rincian telah meningkat juga. Hari ini, permainan melibatkan jutaan poligon, visual dan efek audio tidak begitu berbeda dari yang digunakan dalam film, dan kuat nilai-nilai produksi sinematografi. Menempatkan kamera dan menerangi tempat kejadian sangat penting dari sudut pandang narasi. Ini membantu menyampaikan cerita, tapi juga dapat bertindak sebagai perbaikan gameplay. Berapa banyak permainan menarik telah dimanjakan karena buruknya suatu sudut kamera?
Bab ini mencoba untuk memberikan beberapa penerangan pada dunia sinematografi interaktif. Lebih dari bab yang terstruktur, ini adalah teknik koleksi yang tidak teratur yang dapat digunakan untuk mengontrol kamera dan pencahayaan dalam berbagai permainan. Sebagian besar algoritma ini tidak akan sangat kompleks. Beberapa trigonometri dan aljabar harus mencukupi. Tapi teknik ini sederhana pada akhirnya akan membuat perbedaan, yang memungkinkan Anda untuk membuat game yang benar-benar menampilkan pengalaman movielike kepada pemain.

a. First-Person Shooters (Penembak orang pertama)

Pendekatan kamera pertama kita akan membahas adalah kamera orang pertama digunakan di banyak first-person shooter judul, seperti Quake. Ini adalah kamera yang didefinisikan oleh setidaknya empat derajat kebebasan (X, Y, Z dan yaw), dengan pitch kadang-kadang ditambahkan ke dalam campuran. Sejauh kontrol berjalan, kamera menggunakan kursor kiri dan kanan untuk memutar, dan atas dan ke bawah digunakan untuk memajukan atau bergerak mundur ke arah yang kita hadapi. Gerakan sisi A yang disebut pangkalan musuh kadang-kadang hadir, memungkinkan kita untuk maju ke samping. Menembaki pangkalan musuh berguna dalam sudut berbahaya.

Matematika untuk kamera tersebut tidak terlalu kompleks. Untuk memulainya, terdapat kode (menggunakan input abstrak controller) untuk kursor kiri dan kanan:

yaw + = ROTSPEED * terlewati * (input.right-input.left);

Pada baris kode ini, input.left dan input.right mengembalikan 1 jika kursor tertentu ditekan, dan 0 jika sebaliknya. Ekspresi kurung akan kembali -1 jika kita menekan kiri, 0 jika kedua (atau tidak) adalah ditekan, dan 1 jika benar ditekan. Hasil dari ekspresi kurung akan bertindak sebagai pengubah ke pertama bagian dari ekspresi. Dasar fisika memberitahu kita bahwa

Kecepatan = Ruang / Waktu

Kemudian, pemecahan untuk Space kita mendapatkan
Spasi = Kecepatan * Waktu

yang pada dasarnya apa yang kita lakukan di sini (meskipun dalam mode sudut) – mengalikan konstanta ROTSPEED (yang akan menentukan seberapa cepat karakter kita bisa berubah) dengan waktu yang telah berlalu, yaitu, waktu yang diperlukan untuk menyelesaikan sebuah permainan lingkaran yang lengkap. Dengan menggunakan rumus ini, kita mendapatkan yang bagus, perangkat kecepatan rotasi independen. Karakter akan berputar pada kecepatan yang sama pada komputer yang berbeda.

Sekarang kita perlu kode yang menangani kursor atas dan bawah. Ini mengikuti strategi yang sama:

int dz = (input.up-input.down);

playerpos.x = SPEED * berlalu * dz * cos (yaw);

playerpos.z = SPEED * berlalu * dz * sin (yaw);
Di kode sebelumnya, dz hanya ide yang sama seperti yang kita gunakan tadi untuk mengontrol tombol tidak ditekan. Daging terletak pada dua baris berikutnya. Seperti yang kita lakukan sebelumnya, kita akan menggunakan SPEED* yang terlewati untuk memperoleh perangkat bebas. Untuk memahami bagian selanjutnya (dz * cos* (yaw)), diagram kecil dan beberapa trigonometri diperlukan. Lihat Gambar 16.1.

Gambar 16.1. Trigonometri bola, FPS kamera.

Ingat bahwa cosinus dan fungsi sinus berhubungan sudut dalam segitiga siku-siku dengan panjang sisi-sisinya. Di kasus kami, kami memiliki sudut (yaw), dan kita perlu menghitung panjang sisi berdekatan untuk itu (yang akan menjadi peningkatan dalam x) dan berlawanan dengan itu (yang akan z). Kami berasumsi miring untuk akan 1 dan skala oleh SPEED * berlalu * dz untuk mencapai hasil akhir.

Pemberondongan hanya varian dari kontroler sebelumnya hanya ditampilkan. Kuncinya adalah bahwa langkah memberondong dilakukan dengan memajukan samping-yaitu, dengan kenaikan 90 º sehubungan dengan gerakan teratur. Berikut adalah sumber kode:

int dstrafe = (input.straferightinput.strafeleft);

playerpos.x = STRAFESPEED * berlalu * dstrafe * cos (yaw 3,1416 / 2);

playerpos.z = STRAFESPEED * berlalu * dstrafe * sin (yaw 3,1416 / 2);

b. Handling Inertia

Kebanyakan penembak orang pertama (FPSS) melaksanakan inersia pada kontroler kamera mereka untuk realisme meningkat. Karakter kami mempercepat progresif dan juga berhenti bergerak dengan cara inersia. Hal ini membuat gerakan halus hampir tanpa biaya coding. Untuk menambahkan inersia, kita hanya perlu mengingat beberapa persamaan fisika, seperti
yang satu ini:

percepatan = kecepatan / waktu

Pemecahan untuk kecepatan, kita mendapatkan

kecepatan = percepatan * Waktu

Pertimbangkan bagaimana mobil bekerja: Anda tidak benar-benar mengatur kecepatan kendaraan namun menggunakan pedal untuk menambahkan percepatan (atau pengereman) untuk itu. Jadi kita benar-benar perlu untuk mengimplementasikan kontroler kami dalam hal percepatan, tidak kecepatan secara langsung. Kontroler yaw kami dengan demikian akan

yawvel + = ROTACCEL * berlalu * (input.right-input.left);

if (yawvel> ROTSPEED) yawvel = ROTSPEED;
if (yawvel <-ROTSPEED) yawvel =-ROTSPEED;
if (input.right-input.left == 0) yawvel = yawvel * BRAKINGFACTOR;
yaw + = yawvel * berlalu * (input.right-input.left);

Baris pertama adalah hanya versi percepatan kontroler awal kami. Kemudian, kami menggunakan dua baris untuk membatasi kecepatan, jadi kami tidak bisa berputar lebih cepat dari awal #ketetapan kami. Baris keempat mungkin yang paling tidak jelas dari keseluruhannya. Untuk memahaminya, perhatikan bahwa kondisi jika diaktifkan jika tidak kiri maupun kanan yang ditekan. Dalam hal ini, kami perlu memperlambat rotasi secara progresif. Kami mencapai hasil ini dengan mengalikan kecepatan saat ini dengan faktor pengereman (misalnya, 0,85). Baris terakhir hanya update yaw sesuai dengan kecepatan rotasi yang dihitung.

Hampir kode identik yang dapat menangani maju dan mundurnya gerakan:

dz = (input.up-input.down);
vel + = ACCEL * berlalu * dz;
if (vel> SPEED) vel = SPEED;
if (vel <-SPEED) vel =-SPEED;
if (dz == 0) = vel vel * BRAKINGFACTOR;
playerpos.x + = vel * berlalu * dz * cos (yaw);
playerpos.z + = vel * berlalu * dz * sin (yaw);

Sekarang kita telah melihat bagaimana menerapkan kamera untuk FPSS, sekarang saatnya untuk membuatnya. Dalam grafis API, seperti OpenGL dan DirectX, kami memiliki utinitas makro yang menempatkan kamera, mengingat posisi kamera dan melihat pada titiknya. Kami akan menggunakan primitif karena mereka (seperti OpenGL dan DirectX) menyediakan cara mudah untuk menentukan jenis kamera.

Menentukan lokasi kamera adalah sepele. Sekarang, untuk menentukan tampilan-pada titik, kita akan menggunakan beberapa trigonometri lagi. Jika Anda memahami sin dan cos digunakan untuk memajukan sesuai dengan sudut yaw, berikut ini harus menjadi jelas:

lookat.x = playerpos.x + cos (yaw);
lookat.z = playerpos.x + sin (yaw);

Secara intuitif, tampilan-pada titik ditempatkan dalam arah yang sama kami tuju, dengan demikian, menggunakan tahap yang sama untuk menghitung itu sangat mudah. Dengan asumsi konvensi itu, kita dapat menentukan kamera FPS kami di OpenGL dengan potongan kode berikut:

glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective (fovy, aspek, nearplane, Farplane);

glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
gluLookAt (playerpos.x, playerpos.y, playerpos.z, lookat.x, lookat.y,
lookat.z, 0,1,0);

Baris yang benar-benar menempatkan kamera adalah dua baris terakhir, tapi saya memberikan kode kamera setup penuh untuk kelengkapan. Ingat bahwa panggilan gluPerspective set parameter optik seperti bidang pandang, rasio aspek, dan sebagainya, sedangkan gluLookAt menempatkan kamera melalui sembilan parameter dikelompokkan dalam triplet. Triplet pertama adalah posisi kamera, yang kedua adalah tampilan-pada titik, dan yang ketiga adalah vektor mengarah ke atas, yang kita perlu untuk model kamera yang lebih canggih.

Pengaturan kamera sangat mirip di bawah DirectX. Sintaks di sini adalah

D3DXMATRIX matView;

D3DXMatrixLookAtLH (& matView, & D3DXVECTOR3 (playerpos.x, playerpos.y,

playerpos.z), & D3DXVECTOR3 (lookat.x, lookat.y, lookat.z),
& D3DXVECTOR3 (0,1,0));
g_pd3dDevice-> SetTransform (D3DTS_VIEW, & matView);


D3DXMATRIX matProj;
D3DXMatrixPerspectiveFovLH (& matProj, fovy, aspek, dekat, jauh);
g_pd3dDevice-> SetTransform (D3DTS_PROJECTION, & matProj);

dengan asumsi playerpos dan tampilan-pada saat semuanya telah dihitung dengan menggunakan algoritma kita hanya dieksplorasi.

Dikutip dari :

Buku “core techniques & algorithm in game programming”

atau ,

http://www.tar.hu/gamealgorithms/ch16.html2/9/2009

http://www.tar.hu/gamealgorithms/ch16lev1sec1.html

http://www.tar.hu/gamealgorithms/ch16lev1sec2.html

 

 
Leave a comment

Posted by on June 19, 2012 in Artikel, Kuliah

 

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: