{
Dalam pelajaran ini saya akan mengajari Anda cara menggunakan tiga metode pemfilteran tekstur yang berbeda.
Mengajari Anda cara menggunakan keyboard untuk memindahkan objek dalam pemandangan, dan juga mengajari Anda cara menerapkan pencahayaan sederhana dalam pemandangan OpenGL.
Pelajaran ini berisi banyak konten. Jika Anda memiliki pertanyaan tentang pelajaran sebelumnya, kembalilah dan ulas terlebih dahulu.
Sebelum masuk ke kode di baliknya, penting untuk memiliki pemahaman yang baik tentang dasar-dasarnya.
Kami masih memodifikasi kode dari pelajaran pertama.
Bedanya dengan sebelumnya adalah setiap kali ada perubahan besar, saya akan menulis seluruh kodenya.
Pertama kita harus menambahkan unit SysUtils dan unit Glaux.
}
Kegunaan
sistemUtils,
terbuka,
jendela,
Pesan,
Glaux Dalam '../../GLAUX/Glaux.pas';
//Baris berikut menambahkan variabel baru.
//Kami menambahkan tiga variabel Boolean.
// Variabel cahaya melacak apakah lampu menyala.
//Variabel lp dan fp digunakan untuk menyimpan apakah tombol 'L' dan 'F' ditekan.
//Saya akan menjelaskan pentingnya variabel-variabel ini nanti. Untuk saat ini, kesampingkan hal itu.
cahaya : Boolean; // sumber cahaya hidup/mati
lp : Boolean; // Apakah tombol L ditekan?
fp : Boolean; // Apakah tombol F ditekan?
//Sekarang atur 5 variabel untuk mengontrol ukuran langkah sudut rotasi di sekitar sumbu x dan sumbu y,
//Dan kecepatan putaran pada sumbu x dan sumbu y.
//Selain itu, variabel z dibuat untuk mengontrol jarak ke kedalaman layar.
xrot : GLfloat; // X rotasi
yrot : GLfloat; // rotasi Y
xspeed : GLfloat; // X kecepatan putaran
yspeed : GLfloat; // kecepatan putaran Y
z : GLfloat = -5.0 f; // Jarak jauh ke dalam layar
//Kemudian atur array yang digunakan untuk membuat sumber cahaya.
//Kita akan menggunakan dua lampu yang berbeda.
//Yang pertama disebut cahaya sekitar. Cahaya sekitar datang dari segala arah.
//Semua objek dalam pemandangan diterangi oleh cahaya sekitar.
//Jenis sumber cahaya kedua disebut cahaya menyebar.
//Cahaya menyebar dihasilkan oleh sumber cahaya tertentu dan menciptakan pantulan pada permukaan objek dalam pemandangan Anda.
//Permukaan objek apa pun yang disinari langsung oleh cahaya menyebar menjadi sangat terang,
//Area yang minim penerangan tampak lebih gelap.
//Ini akan menghasilkan efek bayangan yang sangat bagus pada tepi peti kayu yang kita buat.
//Proses pembuatan sumber cahaya sama persis dengan pembuatan warna.
//Tiga parameter pertama adalah komponen tiga warna RGB, dan yang terakhir adalah parameter saluran alfa.
// Oleh karena itu, dalam kode berikut kita mendapatkan cahaya sekitar putih setengah terang (0,5f).
//Jika tidak ada cahaya sekitar, area yang tidak terkena cahaya menyebar akan menjadi sangat gelap.
LightAmbient: Array[0..3] Of GLfloat = (0.5, 0.5, 0.5, 1.0); //Parameter cahaya sekitar (baru)
//Baris kode berikutnya kita menghasilkan cahaya menyebar paling terang.
//Semua nilai parameter diambil ke nilai maksimum 1.0f.
//Itu akan bersinar di bagian depan peti kayu kita dan terlihat bagus.
LightDiffuse: Array[0..3] Of GLfloat = (1.0, 1.0, 1.0, 1.0); // Parameter cahaya diffuse (baru)
//Terakhir kita simpan posisi sumber cahayanya.
//Tiga parameter pertama sama seperti di glTranslate.
//Perpindahan pada sumbu XYZ berturut-turut.
//Karena kita ingin cahaya bersinar tepat di depan kotak kayu, perpindahan pada sumbu XY keduanya 0,0.
//Nilai ketiga adalah perpindahan pada sumbu Z.
//Untuk memastikan cahaya selalu berada di depan kotak kayu,
//Jadi kita menjauhkan sumber cahaya dari layar menuju pengamat (yaitu Anda.).
//Kami biasanya menyebut posisi layar, yaitu kaca layar monitor, sebagai titik 0,0 pada sumbu Z.
//Jadi perpindahan pada sumbu Z akhirnya disetel ke 2.0.
//Jika Anda dapat melihat sumber cahaya, berarti sumber cahaya tersebut melayang di depan monitor Anda.
//Tentu saja, Anda tidak dapat melihat kotak kayu itu jika tidak berada di balik kaca layar monitor.
//『Catatan Penerjemah: Saya menghargai kesabaran NeHe.
//Sejujurnya, terkadang aku merasa kesal. Kenapa dia bicara omong kosong tentang hal sederhana seperti itu?
//Tetapi jika semuanya sudah jelas, apakah kamu masih akan membolak-balik halaman seperti ini tanpa henti? 』
//Parameter terakhir diambil sebagai 1.0f.
//Ini akan memberitahu OpenGL bahwa koordinat yang ditentukan di sini adalah posisi sumber cahaya. Saya akan menjelaskan lebih lanjut di tutorial selanjutnya.
LightPosition: Array[0..3] Of GLfloat = (0.0, 0.0, 2.0, 1.0); // Posisi sumber cahaya (baru)
//Variabel filter melacak tipe tekstur yang digunakan saat menampilkan.
//Tekstur pertama (tekstur 0) dibuat menggunakan metode pemfilteran gl_nearest (tidak halus).
//Tekstur kedua (tekstur 1) menggunakan metode gl_linear (pemfilteran linier),
//Gambar yang lebih dekat ke layar terlihat lebih halus.
//Tekstur ketiga (tekstur 2) menggunakan metode pemfilteran yang dipetakan,
//Ini akan menciptakan tekstur yang terlihat sangat bagus.
//Bergantung pada jenis penggunaan kita, nilai variabel filter masing-masing sama dengan 0, 1 atau 2.
//Mari kita mulai dengan tekstur pertama.
//texture mengalokasikan ruang penyimpanan untuk tiga tekstur berbeda.
//Mereka terletak di tekstur[0], tekstur[1] dan tekstur[2] masing-masing.
penyaring : Gluint; // Jenis penyaring
texture : Array[0..2] Of GLuint; // Ruang penyimpanan untuk 3 tekstur
Prosedur glGenTextures(n: GLsizei; Var tekstur: GLuint);
bukagl32;
Prosedur glBindTexture(target: GLenum; tekstur: GLuint);
bukagl32;
Fungsi gluBuild2DMipmaps(target: GLenum; komponen, lebar, tinggi: GLint;
format, atype: GLenum; data: Pointer): Integer;
'gluBuild2DMipmaps';
{
Sekarang muat bitmap dan gunakan untuk membuat tiga tekstur berbeda.
Pelajaran ini menggunakan perpustakaan tambahan glaux untuk memuat bitmap.
Oleh karena itu Anda harus mengonfirmasi apakah perpustakaan glaux disertakan saat kompilasi.
Saya tahu Delphi dan VC++ menyertakan perpustakaan glaux, tetapi bahasa lain tidak dijamin memilikinya.
"Catatan Penerjemah: glaux adalah perpustakaan tambahan OpenGL. Menurut karakteristik lintas platform OpenGL,
Kode harus umum di semua platform. Namun perpustakaan tambahan bukanlah perpustakaan standar OpenGL resmi.
Tidak tersedia di semua platform. Tapi kebetulan tersedia di platform Win32.
Haha, tentu saja BCB juga tidak masalah. 』Di sini saya hanya memberi anotasi pada kode yang baru ditambahkan.
Jika Anda memiliki pertanyaan tentang baris kode tertentu, silakan lihat Tutorial 6.
Pelajaran itu menjelaskan memuat dan membuat tekstur dengan sangat detail.
Setelah potongan kode sebelumnya dan sebelum glResizeWnd(),
Kami menambahkan kode berikut. Kode ini hampir sama dengan kode yang digunakan pada Pelajaran 6 untuk memuat bitmap.
}
Fungsi LoadBmp(nama file: pchar): PTAUX_RGBIImageRec;
Var
BitmapFile : Thandle; // pegangan file
Mulai
Jika Nama File = '' Lalu // Pastikan nama file diberikan.
hasil := Nihil; // Jika tidak diberikan, kembalikan NULL
BitmapFile := FileOpen(Nama file, fmOpenWrite); //Coba buka file
Jika BitmapFile > 0 Lalu // Apakah file tersebut ada?
Mulai
FileClose(BitmapFile); //Tutup pegangan
hasil := auxDIBImageLoadA(nama file); //Muat bitmap dan kembalikan penunjuk
Akhir
Kalau tidak
hasil := Nihil; // Jika pemuatan gagal, kembalikan NiL.
Akhir;
Fungsi LoadTexture: boolean; //Muat bitmap dan ubah menjadi tekstur
Var
Status : boolean; // Indikator status
TextureImage : Array[0..1] Of PTAUX_RGBImageRec; // Membuat ruang penyimpanan tekstur
Mulai
Status := salah;
ZeroMemory(@TextureImage, sizeof(TextureImage)); // Setel penunjuk ke NULL
TextureImage[0] := LoadBMP('Dinding.bmp');
Jika TextureImage[0] <> Nihil Lalu
Mulai
Status := BENAR; // Atur Status ke BENAR
glGenTextures(1, tekstur[0]); // Membuat tekstur
//Dalam Pelajaran 6 kita menggunakan pemetaan tekstur terfilter linier.
//Ini memerlukan kekuatan pemrosesan yang cukup tinggi dari mesin, namun tampilannya cukup bagus.
//Dalam pelajaran ini, tekstur pertama yang akan kita buat menggunakan metode GL_NEAREST.
//Pada prinsipnya, metode ini sebenarnya tidak melakukan pemfilteran.
//Ini hanya membutuhkan sedikit kekuatan pemrosesan dan terlihat buruk.
//Satu-satunya keuntungan adalah proyek kita dapat berjalan normal pada mesin yang cepat dan lambat.
//Anda akan melihat bahwa kami menggunakan GL_NEAREST untuk MIN dan MAG,
//Anda dapat menggabungkan GL_NEAREST dan GL_LINEAR.
//Teksturnya akan terlihat lebih baik, tapi kami lebih mementingkan kecepatan, jadi kami menggunakan semua peta berkualitas rendah.
//MIN_FILTER digunakan ketika gambar digambar lebih kecil dari ukuran tekstur aslinya.
//MAG_FILTER digunakan ketika gambar digambar lebih besar dari ukuran tekstur aslinya.
// Buat peta filter terdekat
glBindTexture(GL_TEXTURE_2D, tekstur[0]);
// Menghasilkan tekstur
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, 3, Gambar Tekstur[0].ukuranX,
Gambar Tekstur[0].ukuranY, 0, GL_RGB, GL_UNSIGNED_BYTE,
TeksturGambar[0].data);
//Tekstur berikutnya sama dengan yang ada di Pelajaran 6, pemfilteran linier. Satu-satunya perbedaan adalah kali ini ditempatkan
//tekstur[1]. Karena ini tekstur yang kedua. Jika ditempatkan
//texture[0], ini akan menimpa tekstur GL_NEAREST yang dibuat sebelumnya.
glBindTexture(GL_TEXTURE_2D, texture[1]); //Gunakan tekstur khas yang dihasilkan dari data bitmap
// Menghasilkan tekstur
glTexImage2D(GL_TEXTURE_2D, 0, 3, Gambar Tekstur[0].ukuranX,
Gambar Tekstur[0].ukuranY, 0, GL_RGB, GL_UNSIGNED_BYTE,
TeksturGambar[0].data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Pemfilteran linier
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Pemfilteran linier
//Berikut ini adalah cara baru untuk membuat tekstur. Pemetaan ulang!
//『Catatan Penerjemah: Saya tidak bisa menerjemahkan kata ini dalam bahasa Mandarin, tapi itu tidak masalah. Setelah membaca paragraf ini, Anda akan mengetahui bahwa maknanya adalah yang paling penting. 』
//Anda mungkin memperhatikan bahwa saat gambar menjadi lebih kecil di layar, banyak detail yang hilang.
//Pola yang terlihat bagus sekarang menjadi jelek. Saat Anda memberi tahu OpenGL untuk membuat tekstur yang dipetakan,
//OpenGL akan mencoba membuat tekstur berkualitas tinggi dengan ukuran berbeda. Saat Anda menggambar tekstur yang dipetakan ke layar,
//OpenGL akan memilih tekstur terbaik (dengan lebih detail) yang telah dibuat untuk digambar,
//Daripada hanya menskalakan gambar asli (yang akan mengakibatkan hilangnya detail).
//Saya pernah mengatakan bahwa ada cara untuk mengatasi keterbatasan OpenGL pada lebar dan tinggi tekstur - 64, 128, 256, dll.
//Solusinya adalah gluBuild2DMipmaps. Dari apa yang saya temukan, Anda dapat menggunakan bitmap sembarang untuk membuat tekstur.
//OpenGL secara otomatis akan menskalakannya ke ukuran normal.
//Karena ini tekstur ketiga, kita simpan ke tekstur[2]. Dengan cara ini, ketiga tekstur dalam pelajaran ini telah dibuat.
//Buat tekstur MipMapped
glBindTexture(GL_TEXTURE_2D, tekstur[2]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_NEAREST); // (baru)
//Baris berikut menghasilkan tekstur yang dipetakan.
//Kami menggunakan tiga warna (merah, hijau, biru) untuk menghasilkan tekstur 2D.
//TextureImage[0].sizeX adalah lebar bitmap,
//TextureImage[0].sizeY adalah tinggi bitmap,
//(====Untuk beberapa alasan, fungsi di Delphi ini tidak memiliki parameter ketinggian,
//Tapi ada bantuannya. Saya tidak tahu apa yang akan dilakukan Delphi lagi, yang membuat saya tertekan...
//Akhirnya, saya sendiri yang menulis gluBuild2DMipmaps sebelumnya,
//Untuk memuat fungsi gluBuild2DMipmaps di glu32.dll =====)
//GL_RGB artinya kita menggunakan warna RGB secara bergantian.
//GL_UNSIGNED_BYTE berarti satuan data tekstur adalah byte.
//TextureImage[0].data menunjuk ke bitmap yang kita gunakan untuk membuat tekstur.
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0].sizeX,
Gambar Tekstur[0].ukuran, GL_RGB, GL_UNSIGNED_BYTE,
TextureImage[0].data); //(baru) }
Akhir;
Jika ditugaskan(TextureImage[0]) Lalu // Apakah teksturnya ada
Jika ditugaskan(TextureImage[0].data) Lalu // Apakah gambar tekstur ada
TextureImage[0].data := Nihil; // Lepaskan memori yang ditempati oleh gambar tekstur
TextureImage[0] := Nihil; // Lepaskan struktur gambar
hasil := Status; // Status Pengembalian
Akhir;
//Kemudian saatnya memuat tekstur dan menginisialisasi pengaturan OpenGL.
//Baris pertama fungsi GLInit menggunakan kode di atas untuk memuat tekstur.
//Setelah membuat tekstur, kita memanggil glEnable(GL_TEXTURE_2D) untuk mengaktifkan pemetaan tekstur 2D.
//Mode bayangan diatur ke bayangan halus (smooth shading).
//Warna latar belakang disetel ke hitam, kami mengaktifkan pengujian kedalaman, dan kemudian kami mengaktifkan penghitungan perspektif yang dioptimalkan.
Prosedur glInit(); // Mulai semua pengaturan untuk OpenGL di sini
Mulai
If (Bukan LoadTexture) Then // Panggil subrutin pemuatan tekstur
exit; // Jika gagal memuat, keluar
glEnable(GL_TEXTURE_2D); // Aktifkan pemetaan tekstur
glShadeModel(GL_SMOOTH); // Aktifkan penghalusan bayangan
glClearColor(0.0, 0.0, 0.0, 0.0); // latar belakang hitam
glClearDepth(1.0); //Setel buffer kedalaman
glEnable(GL_DEPTH_TEST); // Aktifkan pengujian kedalaman
glDepthFunc(GL_LESS); // Jenis pengujian kedalaman selesai
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //Penghitungan proyeksi perspektif yang sangat optimal
//Sekarang mulailah menyiapkan sumber cahaya. Baris berikutnya di bawah ini mengatur jumlah cahaya sekitar yang dipancarkan,
//Sumber cahaya light1 mulai memancarkan cahaya.
//Di awal pelajaran ini, kita menyimpan jumlah cahaya sekitar di array LightAmbient.
//Sekarang kita akan menggunakan array ini (cahaya sekitar setengah kecerahan).
glLightfv(GL_LIGHT1, GL_AMBIENT, @LightAmbient[0]); // Mengatur cahaya sekitar
//Selanjutnya kita mengatur jumlah cahaya yang menyebar. Itu disimpan dalam array LightDiffuse (cahaya putih kecerahan penuh).
glLightfv(GL_LIGHT1, GL_DIFFUSE, @LightDiffuse[0]); // Mengatur cahaya menyebar
//Kemudian atur posisi sumber cahaya.
//Posisi disimpan dalam array LightPosition
//(Tepat di tengah depan kotak kayu, X-0.0, Y-0.0, dipindahkan 2 unit ke arah pengamat ke arah Z <di luar layar>).
glLightfv(GL_LIGHT1, GL_POSITION, @LightPosition); // Posisi sumber cahaya
//Terakhir, kita aktifkan sumber cahaya nomor satu. Kami belum mengaktifkan GL_LIGHTING,
//Jadi kamu tidak bisa melihat cahaya apa pun.
//Ingat: hanya mengatur, memposisikan, atau bahkan mengaktifkan sumber cahaya tidak akan berfungsi.
//Kecuali kita mengaktifkan GL_LIGHTING.
glEnable(GL_LIGHT1); // Aktifkan sumber cahaya No.1
Akhir;
//Potongan kode berikutnya menggambar kubus bertekstur. Saya hanya memberi anotasi pada kode baru.
//Jika Anda memiliki pertanyaan tentang kode tanpa anotasi, kembali ke Pelajaran 6.
Prosedur glDraw(); // Semua gambar dimulai dari sini
Mulai
glClear(GL_COLOR_BUFFER_BIT Atau GL_DEPTH_BUFFER_BIT); // Hapus layar dan buffer kedalaman
glLoadIdentity(); //Reset matriks observasi model saat ini
//Tiga baris kode berikutnya menempatkan dan memutar kubus tekstur.
//glTranslatef(0.0,0.0,z) memindahkan unit kubus Z sepanjang sumbu Z.
//glRotatef(xrot,1.0f,0.0f,0.0f) memutar kubus di sekitar sumbu X xrot.
//glRotatef(yrot,0.0f,1.0f,0.0f) memutar kubus yrot di sekitar sumbu Y.
glTranslatef(0.0, 0.0, z); // Memindahkan masuk/keluar layar z unit
glRotatef(xrot, 1.0, 0.0, 0.0); // Memutar pada sumbu X
glRotatef(yrot, 0.0, 1.0, 0.0); // Memutar pada sumbu Y
//Baris berikutnya mirip dengan apa yang kita lakukan di Pelajaran 6.
//Bedanya kali ini tekstur yang kita ikat adalah tekstur[filter],
//Daripada tekstur[0] pada pelajaran sebelumnya.
//Setiap kali kita menekan tombol F, nilai filter akan meningkat.
//Jika nilai ini lebih besar dari 2, filter variabel akan direset ke 0.
//Saat program diinisialisasi, nilai variabel filter juga akan disetel ke 0.
//Dengan menggunakan filter variabel kita dapat memilih salah satu dari tiga tekstur.
glBindTexture(GL_TEXTURE_2D, texture[filter]); //Pilih tekstur yang ditentukan oleh filter
glBegin(GL_QUADS); // Mulai menggambar segi empat
//glNormal3f baru dalam pelajaran ini. Biasa artinya biasa saja.
//Yang disebut normal mengacu pada garis lurus yang melalui suatu titik pada suatu permukaan (poligon) dan tegak lurus terhadap permukaan tersebut (poligon).
//Saat menggunakan sumber cahaya, nilai normal harus ditentukan. Normalnya memberitahu OpenGL orientasi poligon dan menunjukkan sisi depan dan belakang poligon.
//Jika normal tidak ditentukan, hal-hal aneh mungkin terjadi: permukaan yang tidak seharusnya disinari akan disinari, dan sisi belakang poligon juga akan disinari....
//Omong-omong, garis normalnya seharusnya mengarah ke luar poligon. Melihat bagian depan kotak Anda akan melihat bahwa garis normal searah dengan sumbu Z positif.
//Ini berarti garis normal menunjuk ke arah pengamat - diri Anda sendiri. Inilah yang kami harapkan.
//Untuk bagian belakang kotak kayu, seperti yang kita inginkan, posisi normalnya menghadap jauh dari penonton.
//Jika kubus diputar 180 derajat sepanjang sumbu X atau Y, garis normal di sisi depan masih menghadap pengamat, dan garis normal di belakang masih menjauhi pengamat.
//Dengan kata lain, apapun permukaannya, asalkan menghadap pengamat, garis normal permukaan tersebut menunjuk ke pengamat.
//Karena sumber cahaya berbatasan langsung dengan pengamat, setiap kali garis normal menghadap pengamat, permukaan ini akan diterangi.
//Dan semakin dekat garis normal ke arah sumber cahaya, maka akan semakin terang tampilannya.
//Jika kamu menempatkan titik pengamatan di dalam kubus, kamu akan mendapatkan kegelapan di dalam keadaan normal.
//Karena titik normalnya mengarah ke luar. Jika tidak ada sumber cahaya di dalam kubus tentu akan menjadi gelap gulita.
// Depan
glNormal3f(0.0, 0.0, 1.0); // titik normal ke pengamat
glTexCoord2f(0,0, 0,0);
glVertex3f(-1.0, -1.0, 1.0); // Tekstur dan kiri bawah segi empat
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, -1.0, 1.0); // Tekstur dan kanan bawah segi empat
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, 1.0); //Tekstur dan kanan atas segi empat
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, 1.0); //Tekstur dan kiri atas segi empat
// Nanti
glNormal3f(0.0, 0.0, -1.0); // Wajah normal menjauhi pemirsa
glTexCoord2f(1.0, 0.0);
glVertex3f(-1.0, -1.0, -1.0); // Tekstur dan kanan bawah segi empat
glTexCoord2f(1.0, 1.0);
glVertex3f(-1.0, 1.0, -1.0); //Tekstur dan kanan atas segi empat
glTexCoord2f(0.0, 1.0);
glVertex3f(1.0, 1.0, -1.0); //Tekstur dan kiri atas segi empat
glTexCoord2f(0,0, 0,0);
glVertex3f(1.0, -1.0, -1.0); // Tekstur dan kiri bawah segi empat
// permukaan atas
glNormal3f(0.0, 1.0, 0.0); // normal ke atas
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, -1.0); //Tekstur dan kiri atas segi empat
glTexCoord2f(0,0, 0,0);
glVertex3f(-1.0, 1.0, 1.0); // Tekstur dan kiri bawah segi empat
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, 1.0, 1.0); // Tekstur dan kanan bawah segi empat
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, -1.0); //Tekstur dan kanan atas segi empat
// Dasar
glNormal3f(0.0, -1.0, 0.0); // normal menghadap ke bawah
glTexCoord2f(1.0, 1.0);
glVertex3f(-1.0, -1.0, -1.0); // Tekstur dan kanan atas segi empat
glTexCoord2f(0.0, 1.0);
glVertex3f(1.0, -1.0, -1.0); //Tekstur dan kiri atas segi empat
glTexCoord2f(0,0, 0,0);
glVertex3f(1.0, -1.0, 1.0); // Tekstur dan kiri bawah segi empat
glTexCoord2f(1.0, 0.0);
glVertex3f(-1.0, -1.0, 1.0); // Tekstur dan kanan bawah segi empat
// Kanan
glNormal3f(1.0, 0.0, 0.0); // normal ke kanan
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, -1.0, -1.0); // Tekstur dan kanan bawah segi empat
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, -1.0); //Tekstur dan kanan atas segi empat
glTexCoord2f(0.0, 1.0);
glVertex3f(1.0, 1.0, 1.0); //Tekstur dan kiri atas segi empat
glTexCoord2f(0,0, 0,0);
glVertex3f(1.0, -1.0, 1.0); // Tekstur dan kiri bawah segi empat
// kiri
glNormal3f(-1.0, 0.0, 0.0); // normal ke kiri
glTexCoord2f(0,0, 0,0);
glVertex3f(-1.0, -1.0, -1.0); // Tekstur dan kiri bawah segi empat
glTexCoord2f(1.0, 0.0);
glVertex3f(-1.0, -1.0, 1.0); // Tekstur dan kanan bawah segi empat
glTexCoord2f(1.0, 1.0);
glVertex3f(-1.0, 1.0, 1.0); //Tekstur dan kanan atas segi empat
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, -1.0); //Tekstur dan kiri atas segi empat
glEnd();
xrot := xrot + xspeed; // xrot meningkatkan satuan xkecepatan
yrot := Yrot + yspeed; // yrot menambah satuan kecepatan y
Akhir;
//Sekarang masuk ke fungsi utama WinMain().
//Kita akan menambahkan kode kontrol di sini untuk menyalakan dan mematikan sumber cahaya, memutar kotak kayu, mengganti metode pemfilteran, dan mendekatkan dan menjauhkan kotak kayu.
// Menjelang akhir fungsi WinMain() Anda akan melihat baris kode SwapBuffers(hDC).
//Kemudian tambahkan kode berikut setelah baris ini.
//Kode akan memeriksa apakah tombol L telah ditekan.
//Jika tombol L sudah ditekan, tetapi nilai lp tidak salah, berarti kunci L belum dilepas, dan tidak terjadi apa-apa saat ini.
SwapBuffers(h_DC); // Tukar buffer (buffer ganda)
Jika (kunci[ord('L')] Dan Bukan lp) Lalu
Mulai
//Jika nilai lp salah,
//Artinya tombol L belum ditekan, atau sudah dilepas, maka lp akan diset menjadi TRUE.
//Alasan memeriksa kedua kondisi ini secara bersamaan adalah untuk mencegah penekanan tombol L.
//Kode ini dijalankan berulang kali dan menyebabkan form berkedip terus menerus.
//Setelah lp disetel ke true, komputer akan mengetahui bahwa tombol L telah ditekan.
//Kita dapat menyalakan/mematikan sumber cahaya sesuai kebutuhan: lampu variabel Boolean mengontrol nyala/mati sumber cahaya.
lp := benar; // lp disetel ke BENAR
cahaya := Tidak terang; // Ganti sumber cahaya ke TRUE/FALSE
Jika Tidak menyala Maka // Jika tidak ada sumber cahaya
glDisable(GL_LIGHTING) //Nonaktifkan sumber cahaya
Lainnya // Lainnya
glEnable(GL_LIGHTING); //Aktifkan sumber cahaya
Akhir;
Jika Bukan kunci[ord('L')] Lalu //Apakah kunci L dilepaskan?
lp := FALSE; // Jika ya, setel lp ke FALSE
//Kemudian lakukan pemeriksaan serupa untuk kunci "F".
//Jika tombol "F" ditekan dan tombol "F" tidak ditekan atau tidak pernah ditekan,
//Setel variabel fp ke true. Ini berarti tombolnya sedang ditekan.
//Kemudian tambahkan satu ke variabel filter. Jika variabel filter lebih besar dari 2
//(Karena array yang kita gunakan di sini adalah tekstur[3], tekstur yang lebih besar dari 2 tidak ada),
//Kami mereset variabel filter ke 0.
If (keys[ord('F')] And Not fp) Then // Apakah tombol F ditekan?
Mulai
fp := BENAR; // fp disetel ke BENAR
inc(filter); // Tambahkan satu ke nilai filter
Jika filter > 2 Lalu // Apakah lebih besar dari 2?
filter := 0; // Jika disetel ulang ke 0
Akhir;
Jika Bukan kunci[ord('F')] Lalu //Apakah kunci F sudah dilepas?
fp := SALAH; // Jika fp disetel ke SALAH
//Keempat baris ini memeriksa apakah tombol PageUp ditekan. Jika ya, turunkan nilai variabel z. Dengan cara ini panggilan ke glTranslatef(0.0f,0.0f,z) yang disertakan dalam fungsi DrawGLScene akan memindahkan kotak kayu lebih jauh dari penampil.
Jika tombol[VK_PRIOR] Lalu //PageUp ditekan?
z := z - 0.02; // Jika ditekan, pindahkan kotak kayu ke arah dalam layar.
//Empat baris berikutnya memeriksa apakah tombol PageDown ditekan. Jika ya, naikkan nilai variabel z. Dengan cara ini, panggilan glTranslatef(0.0f,0.0f,z) yang disertakan dalam fungsi DrawGLScene akan memindahkan kotak kayu lebih dekat ke pengamat.
Jika tombol[VK_NEXT] Lalu // Apakah PageDown ditekan?
z := z + 0.02; //Jika ditekan, gerakkan kotak kayu ke arah pengamat.
//Sekarang periksa tombol panah. Tekan tombol arah kiri dan kanan untuk mengurangi atau menambah kecepatan x.
//Tekan tombol arah atas dan bawah untuk mengurangi atau menambah kecepatan.
//Ingat bahwa pada tutorial selanjutnya, jika nilai xspeed dan yspeed ditingkatkan, kubus akan berputar lebih cepat.
//Jika Anda terus menekan tombol arah tertentu, kubus akan berputar lebih cepat ke arah tersebut.
Jika tombol[VK_UP] Lalu // Apakah tombol arah Atas ditekan?
xspeed := xspeed - 0.01; //Jika ya, kurangi xspeed
Jika tombol[VK_DOWN] Lalu //Apakah tombol arah Bawah sudah ditekan?
xspeed := xspeed + 0.01; //Jika ya, tambah xspeed
Jika tombol[VK_RIGHT] Lalu //Apakah tombol arah Kanan ditekan?
yspeed := yspeed + 0.01; //Jika ya, tambah kecepatan y
Jika tombol[VK_LEFT] Lalu //Apakah tombol arah kiri ditekan?
yspeed := yspeed - 0.01; //Jika ya, kurangi kecepatan y
If (keys[VK_ESCAPE]) Then // Jika tombol ESC ditekan
selesai := Benar
Jalankan dan lihat efeknya