TUGAS PRAKTIKUM 4

GKV LAB A2

‘Depth dan Lighting di OpenGL dan Realisasinya dalam Membuat Truk’

NATASHA PUTRI

24060119130073

Asisten Praktikum :

Muhammad Rizqi Arya Pradana - Hanifah Gladis Amalia

DEPARTEMEN ILMU KOMPUTER / INFORMATIKA

FAKULTAS SAINS DAN MATEMATIKA

UNIVERSITAS DIPONEGORO

2021
 PEMBAHASAN SOURCE CODE TRUK CHOCOBERRY

Sebelum membuat prosedur dan fungsinya, pertama yang perlu

dilakukan adalah mendefinisikan variabel – variabel yang akan digunakan
dalam pembuatan objek truk gandeng dua 3 dimensi ini, sebagai berikut :

double rotAngle = 0; // rotation angle (BEWARE:

Global) double rotAngle1 = 0; // rotation angle
(BEWARE: Global)
float angle=0.0, deltaAngle = 0.0, ratio;
float x=0.0f,y=1.75f,z=25.0f; // posisi awal kamera
float lx=0.0f,ly=0.0f,lz=-1.0f;
int deltaMove = 0,h,w;
int bitmapHeight=12;
const double PI = 3.141592653589793;
int i,j,radius,jumlah_titik,x_tengah,y_tengah;

Berikut rincian penjelasannya :

a. rotAngle = 0 : variabel untuk sudut rotasi, bertipe data double

b. rotAngle1 = 0 : variabel untuk sudut rotasi, bertipe data double
c. angle = 0.0 : variabel untuk sudut, bertipe data float
d. deltaAngle : bertipe data float
e. x = 0.0f, y = 1.75f, z = 25.0f : posisi awal kamera
f. lx = 0.0f, ly = 0.0f, lz = -1.0f : definisi dan inisialisasi variabel lx, ly, lz
g. deltaMove = 0,h,w : definisi dan inisialisasi variabel deltaMove
h. bitmapHeight = 12 : definisi dan inisialisasi variabel bitmapHeight
i. PI = 3.14159265… : sebuah konstan phi (π)
j. i, j, radius, jumlah_titik, x_tengah, y_tengah
merupakan definisi dan spesifikasi variabel i, j, radius, jumlah_titik,
x_tengah, dan y_tengah.

Selanjutnya, setelah semua variabel yang nantinya akan digunakan

dalam semua prosedur dan fungsi dalam source code didefinisikan, akan
dibahas satu – persatu semua prosedur dan fungsi yang ada.

1) Prosedur Reshape
Berikut bagian dari source code yang menunjukkan prosedur Reshape :

void Reshape(int w1, int h1)

{
//prosedur reshape
if(h1 == 0) h1 = 1;
w = w1;
h = h1;
ratio = 1.0f * w / h;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
 Fungsi reshape merupakan fungsi callback (panggilan balik).
Jadi dengan memanggil fungsi reshape dengan glutReshapeFunc()
yang berada pada fungsi main, sebuah pointer GLUT akan diberikan
ke fungsi Reshape. Lalu GLUT akan menyimpan pointer tersebut.
Kemudian akan memanggil fungsi reshape dengan parameter –
parameter yang dibutuhkan, sesuai yang telah dispesifikasikan.

Fungsi panggilan balik untuk Reshape dipicu ketika sebuah

jendela dibentuk ulang (diubah). Fungsi panggilan balik untuk
Reshape juga dapat dipicu segera sebelum sebuah panggilan balik
untuk tampilan pertama jendela setelah jendela dibuat atau setiap kali
sebuah lapisan (overlay) untuk jendela dibentuk. Parameter lebar dan
tinggi dari panggilan balik menentukan ukuran jendela baru dalam
pixel.

Sebelum panggilan balik, jendela saat ini diatur menjadi jendela yang
telah dibentuk ulang.

Jadi kesimpulannya, fungsi reshape adalah sebuah fungsi

callback yang jika digunakan, maka GLUT akan memberi pointer
pada fungsi reshape, lalu GLUT akan memanggil fungsi reshape
tersebut kapan pun ukuran atau bentuk dari jendela aplikasi berubah.
Fungsi reshape mempunyai 2 parameter, yaitu lebar dan tinggi dari
jendela yang bentuknya berubah. Biasanya parameter tersebut
digunakan untuk mengatur sebuah viewport yang baru.

Berikut viewport yang dimaksud :

 Gambar 1. Proyeksi (Tinjau Viewport)

Dalam prosedur Reshape terdapat beberapa fungsi, yaitu :

a. glViewport
mengatur viewport. Seperti diketahui, ketika
mentransformasikan benda 3D menjadi 2D, bentuk terakhir dari
benda yang ditampilkan di layar akan dipetakan di viewport.
Mempunyai empat parameter, di antaranya :

x, y : menspesifikasi titik pojok kiri bawah dari

segiempat viewport. Nilai awalnya (0,0)

width, height : menspesifikasikan lebar dan tinggi viewport

b. glMatrixMode
menspesifikasikan matriks mana yang merupakan matriks saat ini.
Mempunyai parameter mode, mode matriks yang dapat digunakan

:
GL_MODELVIEW : menerapkan operasi matriks
berikutnya ke tumpukan matriks modelview,

GL_PROJECTION : menerapkan operasi matriks

berikutnya ke tumpukan matriks proyeksi,

GL_TEXTURE : menerapkan operasi matriks

berikutnya ke tumpukan matriks tekstur.

c. glLoadIdentity
menggantikan matriks saat ini dengan matriks identitas.
d. gluPerspective
menyiapkan matriks proyeksi perspektif. Mempunyai empat
parameter, yaitu :

fovy : menspesifikasikan bidang sudut pandang, dalam

derajat, dalam arah y
 aspect : menspesifikasi rasio aspek yang menentukan
bidang tampilan dalam arah x. Rasio aspek adalah rasio x (lebar)
ke y (tinggi)

zNear : menentukan jarak dari penampil ke plane dekat

(selalu positif)

zFar : menentukan jarak dari penampil ke plane jauh

(selalu positif)

e. gluLookAt
gluLookAt digunakan untuk menentukan tampilan dari hasil
transformasi. gluLookAt mempunyai 9 parameter, di antaranya :

a) GLdouble eyeX
b) GLdouble eyeY
c) GLdouble eyeZ
ketiga parameter di atas untuk menentukan posisi mata saat
memandang objek berdasarkan koordinat x, y, z.

d) GLdouble centerX
e) GLdouble centerY
f) GLdouble centerZ
ketiga parameter di atas digunakan untuk menentukan posisi near
plane berdasarkan koordinat x, y, z.

g) GLdouble upX
h) GLdouble upY
i) GLdouble upZ
Berikut gambar ilustrasi untuk memperjelas
2) Prosedur moveMeFlat
Berikut bagian dari source code yang menunjukkan prosedur
moveMeFlat :

void moveMeFlat(int i)
{
//prosedur ini untuk maju mundur kamera
x = x + i*(lx)*1;
z = z + i*(lz)*1;
glLoadIdentity();
gluLookAt(x, y, z, x + lx, y + ly, z + lz,
0.0f, 1.0f, 0.0f);
}

Secara sederhana, prosedur moveMeFlat digunakan untuk

mengatur kamera dan pengaturan tampilan ketika kamera digerakkan/
saat transformasi, baik transformasi rotasi, maupun translasi.

Seperti dapat dilihat terdapat variabel x dan z yang diubah

nilainya dalam prosedur moveMeFlat. Di mana variabel x dan z sudah
diinisialisasi sebelumnya dengan nilai :

x = 0.0f, y = 1.75f, z = 15.0f

yang merupakan posisi awal dari kamera.
Lalu, variabel x dan z diubah nilainya sesuai pada kode di atas
dengan memanggil variabel lain, yaitu lx dan lz yang sebelumnya
sudah diinisialisasi dengan nilai :

lx = 0.0f, ly = 0.0f, lz = -1.0f

dengan proses perubahan nilai pada variabel x maka posisi
kamera dapat berubah ke kanan dan ke kiri (sumbu x), dan perubahan
nilai pada variabel z memungkinkan kamera untuk berubah posisi
maju dan mundur (sumbu z).

Jika diamati dalam kode juga dipanggil glLoadIdentity yang

digunakan untuk menggantikan matriks saat ini dengan matriks
identitas.
 Setelah mengakses matriks identitas, memanggil gluLookAt
untuk menentukan tampilan dari hasil transformasi. gluLookAt
mempunyai 9 parameter, di antaranya :

a) GLdouble eyeX
b) GLdouble eyeY
c) GLdouble eyeZ
ketiga parameter di atas untuk menentukan posisi mata saat
memandang objek berdasarkan koordinat x, y, z.

d) GLdouble centerX
e) GLdouble centerY
f) GLdouble centerZ
ketiga parameter di atas digunakan untuk menentukan posisi
near plane berdasarkan koordinat x, y, z.

g) GLdouble upX
h) GLdouble upY
i) GLdouble upZ
Berikut gambar ilustrasi untuk memperjelas

3) Prosedur keyboard
Berikut bagian dari source code yang menunjukkan prosedur keyboard
:

void keyboard(unsigned char k, int x, int y)

{
// Fungsi ini untuk rotasi kamera
switch (k)
{
case 'a':
rotAngle += 10; // increase rotation
by 5 degrees
break;
 Prosedur keyboard merupakan fungsi callback. Di mana ketika
prosedur keyboard ini dipanggil dalam fungsi main, secara spesifiknya
dipanggil menjadi parameter glutKeyboardFunc(), maka secara

otomatis GLUT akan meletakkan pointer ke prosedur keyboard, lalu

GLUT akan menyimpan pointer – pointer ini, dan memanggilnya
ketika memenuhi sebuah kondisi dan mengeksekusi perintah sesuai
spesifikasinya.

Dalam hal ini prosedur keyboard digunakan untuk mengubah

sudut rotasi setiap pengguna menekan beberapa tombol, yaitu tombol :
a : memutar truk (mendatar) berlawanan arah jarum jam,

sejauh 10̊
d : memutar truk (mendatar) searah jarum jam, sejauh -10̊
w : merotasikan truk terhadap sumbu x, sejauh 10̊

s : merotasikan truk terhadap sumbu x, sejauh -10̊

q : exit

4) Prosedur Grid
Berikut bagian dari source code yang menunjukkan prosedur Grid :

void Grid() {
//prosedur untuk membuat grid di "lantai"
double i;
const float Z_MIN = -50, Z_MAX = 50;
const float X_MIN = -50, X_MAX = 50;
const float gap = 1.5;
glColor3f(0.0, 0.0, 0.0);
glBegin(GL_LINES);
for(i=Z_MIN;i<Z_MAX;i+=gap)
{
glVertex3f(i, 0, Z_MIN);
glVertex3f(i, 0, Z_MAX);
}
for(i=X_MIN;i<X_MAX;i+=gap)
{
glVertex3f(X_MIN, 0, i);
glVertex3f(X_MAX, 0, i);
}
glEnd();
}
 Prosedur Grid digunakan untuk membuat pola garis kotak –
kotak pada lantai. Pola garis kotak – kotak pada lantai akan digambar
dengan memanggil GL_LINES yang menjadi parameter glBegin.
glBegin merupakan fungsi untuk membatasi (awal) vertex dari sebuah
primitive atau sekumpulan primitive, dalam hal ini GL_LINES yang
digunakan untuk membuat garis.

Selanjutnya digunakan pula glVertex3f yang merupakan fungsi

untuk mengatur koordinat dari titik – titik pembentuk garis. Fungsi
glVertex3f memiliki 3 parameter yang akan menentukan koordinat
dari titik – titik pembentuk garis. Berikut parameternya :

glVertex3f(x, y, z), di mana

a. x : menentukan posisi absis dari titik,
b. y : menentukan posisi ordinat dari titik,
c. z : menentukan posisi koordinat z dari titik.
5) Prosedur Truk
Karena prosedur ini digunakan untuk membuat objek Truk, yang
mana objek Truk terdiri atas beberapa bagian, maka dalam codenya
dibagi menjadi beberapa bagian seturut bagian – bagian yang dimiliki
objek Truk itu sendiri. Namun, hanya akan dibahas secara sederhana
mengenai proses pembuatan objek Truk.

a. glPushMatrix()
Sebelum membahas mengenai glPushMatrix, perlu
diketahui bahwa dalam pembentukan objek Truk nanti akan
dibutuhkan beberapa proses transformasi, seperti translasi dan
rotasi, yang mana proses transformasi ini membutuhkan matriks –
matriks transformasi. OpenGL akan menyimpan setumpuk
matriks transformasi ini agar dapat dengan cepat diterapkan dan
dihapus transformasinya. Dalam hal ini, glPushMatrix akan
menyalin matriks paling atas (matriks transformasi yang berada di
bawah glPushMatrix) dan mendorongnya ke tumpukan matriks.
Yang nantinya matriks transformasi teratas akan diterapkan ke
semua fungsi di bawahnya. Untuk mempermudah pemahaman,
perhatikan gambar di bawah ini
 Ketika glPushMatrix() dipanggil, maka secara otomatis
akan tercipta matriks di atas, lalu dipanggil glTranslated(100,0,0)
maka matriks 1 akan ditranslasikan dengan faktor translasi
(100,0,0), lalu ketika dipanggil drawSphere(), maka sebuah
sphere akan digambar dengan translasi (100,0,0).

Dengan glPushMatrix() yang mendorong matriks, pengguna dapat

mengontrol transformasi apa yang diterapkan pada objek apa, serta
menerapkan transformasi ke objek tertentu dan dengan mudah
menghapus transformasinya tanpa mempengaruhi objek lain.

b. glPopMatrix()
sementara glPushMatrix menyalin matriks atas dan mendorongnya
ke tumpukan matriks, glPopMatrix memunculkan (pops) matriks
teratas dari tumpukan

c. glBegin()
glBegin merupakan fungsi untuk membatasi (awal) simpul
(vertex) dari sebuah primitive atau sekumpulan primitive, di
antaranya GL_QUADS, GL_LINES, dan primitive lainnya.

d. glEnd()
glEnd merupakan fungsi untuk membatasi (akhir) vertex dari
sebuah primitive atau sekumpulan primitive.

e. glTranslatef()
digunakan untuk melakukan translasi terhadap matriks saat ini
dengan matriks translasi. Faktor translasi dispesifikasikan dalam
parameternya, yaitu :

x : faktor translasi koordinat x

y : faktor translasi koordinat y

 z : faktor translasi koordinat z

f. glRotated()
digunakan untuk melakukan transformasi rotasi terhadap matriks
dengan sudut dan faktor rotasi yang menjadi parameternya, yaitu :
angle : sudut rotasi

x : vektor koordinat x, sebagai faktor rotasi

y : vektor koordinat y, sebagai faktor rotasi

z : vektor koordinat z, sebagai faktor rotasi

g. glColor3f(red, green blue)

GL menyimpan indeks warna yang bernilai tunggal dan warna
RGBA yang mempunyai 4 nilai. glColor mempunyai dua varian,
yaitu glColor3 dan glColor4. Varian glColor3 menspesifikasikan
nilai intensitas warna merah, hijau, dan biru yang baru dengan
nilai alpha 1.0 (intensitas penuh). Pada prinsipnya, openGL
mempunyai prinsip pengaturan warna yang sama dengan prinsip
RGB. Namun terdapat perbedaan di antara keduanya, yaitu kode
warna RGB pada pemrograman lain mempunyai nilai default(255,
255, 255). Sedangkan openGL mempunyai kode warna default(1,
1, 1). Jadi, openGL mempunyai kode warna dengan range antara
0 sampai 1. ‘f’ di akhir glColor3f menandakan bahwa fungsi
glColor akan mengambil nilai dalam floating point. Sedangkan ‘f’
di akhir setiap parameter input menandakan bahwa kode warna
akan dispesifikasikan dalam format floating point.
glColor3f mempunyai 3 parameter, di antaranya :
a. red : menentukan intensitas warna merah
b. green : menentukan intensitas warna hijau
c. blue : menentukan intensitas warna biru.
Secara sederhana, glColor3f digunakan untuk memberi warna pada
objek.

h. glVertex3f(x, y, z)
 merupakan fungsi untuk mengatur koordinat dari vertex (simpul).
Fungsi glVertex3f dipanggil di dalam pasangan glBegin dan
glEnd. Fungsi glVertex3f memiliki 3 parameter yang akan
menentukan koordinat dari titik – titik pembentuk garis. Berikut
parameternya : glVertex3f(x, y, z), di mana

a. x : menentukan posisi absis dari titik,

b. y : menentukan posisi ordinat dari titik,
c. z : menentukan posisi koordinat z dari titik.
i. glTexCoord2f()
digunakan untuk menspesifikasi koordinat tekstur.
Karena bagian code terlalu banyak, code untuk prosedur Truk dapat
dilihat pada source code awal. Penulis sudah menuliskan keterangan –
keterangan yang dibutuhkan di dalamnya.

6) Prosedur display
Berikut bagian dari source code yang menunjukkan prosedur display :
void display() {
// Kalau move dan angle tidak nol, gerakkan
kamera...
if (deltaMove) moveMeFlat(deltaMove);
glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotated(rotAngle, 0, 1, 0); // rotate by
rotAngle about y-axis
glRotated(rotAngle1, 1, 0, 0); // rotate
by rotAngle about x axis

// Gambar grid
Grid();

// Gambar objek
Truk();
glPopMatrix();
glFlush();
glutSwapBuffers();
}

Secara sederhana, prosedur display berperan sebagai handler

kejadian. Jadi ketika nanti prosedur dipanggil dalam fungsi main,
prosedur – prosedur yang didefinisikan di dalamnya dapat dieksekusi.
Pada prosedur display di atas, terdiri atas tiga bagian, yaitu :

a.Untuk transformasi kamera

 Terdapat fungsi if yang memanggil prosedur moveMeFlat,
di mana jika memenuhi kondisi maka kamera akan digerakkan.
Selanjutnya, buffer akan dibersihkan dengan memanggil glClear
yang merupakan operator bitwise OR yang mengidentifikasikan
bahwa buffers akan dibersihkan. Di mana pada glClear
menggunakan parameter konstan, yaitu GL_COLOR
BUFFER_BIT yang mengidentifikasikan bahwa buffers dapat
digunakan (enable) untuk penulisan warna dan
GL_DEPTH_BUFFER_BIT untuk membersihkan buffer
kedalaman (depth). Selanjutnya, dengan memanggil glPushMatrix
maka tercipta matriks 1, di mana matriks ini selanjutnya akan
dirotasikan dengan sudut rotasi yang ada dalam variabel rotAngle
terhadap sumbu y, lalu akan dirotasikan dengan sudut rotasi
sesuai yang dispesifikasikan dalam variabel rotAngle1 terhadap
sumbu x.

b.Memanggil prosedur Grid

Menghandle prosedur Grid, sehingga prosedur display
dipanggil dalam fungsi main, prosedur Grid dapat dieksekusi dan
menghasilkan output lantai dengan garis kotak – kotak.

c.Memanggil prosedur Truk

Menghandle prosedur Truk, sehingga prosedur display
dipanggil dalam fungsi main, prosedur Truk dapat dieksekusi dan
menghasilkan output Truk.

Lalu, supaya prosedur – prosedur yang dipanggil dalam

prosedur display segera dieksekusi, dapat menggunakan glFlush
untuk membatasi waktu eksekusi/ memaksa supaya program
segera dieksekusi.

7) Prosedur pressKey
 void pressKey(int key, int x, int y) {
// Fungsi ini akan dijalankan saat tombol
keyboard ditekan dan belum dilepas
// Selama tombol ditekan, variabel angle
dan move diubah => kamera bergerak
switch (key) {
case GLUT_KEY_UP : deltaMove =
1;break;
case GLUT_KEY_DOWN : deltaMove = -
1;break;
}
}
source code yang menunjukkan prosedur pressKey

Prosedur pressKey akan dieksekusi ketika tombol keyboard

ditekan dan belum dilepas. Yaitu, selama tombol ditekan, variabel
angle (sudut rotasi) dan move akan berubah, artinya kamera akan
bergerak.

8) Prosedur releaseKey
Berikut bagian dari source code yang menunjukkan prosedur
releaseKey :

void releaseKey(int key, int x, int y) {

// Fungsi ini akan dijalankan saat tekanan
tombol keyboard dilepas
// Saat tombol dilepas, variabel angle dan
move diset nol => kamera berhenti
switch (key) {
case GLUT_KEY_UP : if (deltaMove > 0)
deltaMove = 0;
break;
case GLUT_KEY_DOWN : if (deltaMove <
0) deltaMove = 0;
break;
}
}

Prosedur releaseKey akan dijalankan ketika tombol keyboard

sudah tidak ditekan (dilepas). Jadi saat tombol dilepas, variabel
angle dan move menjadi nol (0), artinya kamera berhenti
bergerak.

9) Prosedur lighting
Berikut bagian dari source code yang menunjukkan prosedur lighting :
// Variable untuk pencahayaan
const GLfloat light_ambient[] = { 0.5f, 0.5f,
0.5f, 0.0f };
const GLfloat light_diffuse[] = { 1.0f, 1.0f,
1.0f, 1.0f };
 const GLfloat light_specular[] = { 1.0f,
1.0f, 1.0f, 1.0f };
constGLfloatlight_position[]={0.0f, 20.0f,
10.0f, 1.0f };
const GLfloat mat_ambient[] = { 0.7f, 0.7f,
0.7f, 1.0f };
const GLfloat mat_diffuse[] = { 0.8f, 0.8f,
0.8f, 1.0f };
const GLfloat mat_specular[] = { 1.0f, 1.0f,
1.0f, 1.0f };
const GLfloat high_shininess[] = { 100.0f };

void lighting(){
// Fungsi mengaktifkan pencahayaan
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_AMBIENT,
light_ambient); glLightfv(GL_LIGHT0,
light_diffuse); glLightfv(GL_LIGHT0,
light_specular); GL_DIFFUSE,
glLightfv(GL_LIGHT0,
light_position); GL_SPECULAR,
glMaterialfv(GL_FRONT,
GL_POSITION,
mat_ambient); glMaterialfv(GL_FRONT,
mat_diffuse); glMaterialfv(GL_FRONT,
mat_specular); GL_AMBIENT,
glMaterialfv(GL_FRONT,
high_shininess); GL_DIFFUSE,
}
GL_SPECULAR,
GL_SHININESS,

Prosedur Lighting digunakan untuk mengatur pencahayaan.

Untuk dapat menerapkan pencahayaan pada suatu objek, perlu untuk
mengaktifkannya menggunakan glEnable, di mana ketika
GL_LIGHTING diaktifkan, objek tidak hanya akan diwarnai
berdasarkan warna apa yang dispesifikasikan dalam glColor, tetapi
perlu memberikan spesifikasi lebih seberapa bersinar objeknya nanti,
bagaimana objek terkait bercahaya di dalam kegelapan, bagaimana
objeknya memendarkan cahaya, dan spesifikasi lain. Untuk
mengaktifkannya dapat menggunakan perintah
glEnable(GL_LIGHTn) di mana “n” adalah 0 hingga 7.
 OpenGL memodelkan empat mekanisme ketika cahaya
mencapai mata, yaitu :

a. AMBIENT : cahaya yang berasal dari segala arah secara merata

dan tersebar ke segala arah secara merata oleh poligon di
pandangan. Ini tidak benar dari dunia nyata - tetapi ini adalah
perkiraan pertama yang baik untuk cahaya yang datang cukup
banyak secara seragam dari langit dan tiba ke permukaan dengan
memantulkan begitu banyak permukaan lain yang mungkin juga
seragam.
b. DIFFUSE : cahaya yang berasal dari sumber titik tertentu
(seperti Matahari) dan mengenai permukaan dengan intensitas
yang tergantung pada apakah mereka menghadap ke arah cahaya
atau jauh darinya. Namun, begitu cahaya terpancar dari
permukaan, cahaya akan memancar merata ke segala arah. Ini
adalah pencahayaan difus yang paling mendefinisikan bentuk
objek 3D.
c. SPEKULAR : seperti halnya pencahayaan difus, cahaya berasal
dari titik asal, tetapi dengan pencahayaan spekular, itu
dipantulkan lebih dalam cara cermin di mana sebagian besar
cahaya memantul ke arah tertentu yang didefinisikan oleh bentuk
permukaan. Pencahayaan spekular adalah apa yang menghasilkan
sorotan bersinar dan membantu kita membedakan antara
permukaan datar dan kusam seperti plester dan permukaan
bersinar seperti plastik dan logam yang dipoles.
d. EMISI : dalam hal ini, cahaya sebenarnya dipancarkan oleh
poligon - sama-sama ke segala arah.
Untuk glMaterial, biasanya mengatur warna Ambient dan Diffuse ke warna
alami objek dan untuk meletakkan warna Spekular ke putih. Warna emisi
umumnya berwarna hitam untuk objek yang tidak bersinar oleh cahaya mereka
sendiri.

10) Prosedur init

Berikut bagian dari source code yang menunjukkan prosedur init :

void init(void)
{
 glEnable (GL_DEPTH_TEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

Dapat diamati pada kode di atas bahwa depth test diaktifkan.

Ketika depth test diaktifkan, OpenGL menguji nilai kedalaman dari
suatu fragmen terhadap konten/ isi dari buffer kedalaman. OpenGL
melakukan pengujian kedalaman dan jika lulus uji, maka fragmen
akan dirender dan buffer kedalaman diperbarui dengan nilai
kedalaman yang baru. Jika tes gagal, fragmen akan dibuang.

Selanjutnya dipanggil glPolygonMode yang digunakan untuk

memilih mode rasterisasi polygon. glPolygonMode memiliki dua
parameter, yaitu :

a. Face
Menentukan polygon mana yang nantinya akan diterapkan
mode. Harus GL_FRONT_AND_BACK untuk polygon dengan
muka depan dan muka belakang.

b. Mode
Menentukan bagaimana polygon akan dirasterisasi. Nilai yang
diterima GL_POINT, GL_LINE, dan GL_FILL. Jika GL_FILL
maka interior polygon akan terisi.

11) Fungsi main

Berikut bagian dari source code yang menunjukkan prosedur main :
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH |
GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(750,550);
glutCreateWindow("Truk Doma Nasional");
glutSpecialFunc(pressKey);
glutSpecialUpFunc(releaseKey);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutIdleFunc(display); // Fungsi display-
nya dipanggil terusmenerus
glutReshapeFunc(Reshape);
lighting();
init();
glClearColor(1.0f,1.0f,1.0f,0.0f);
glutMainLoop();
 return(0);
}

Berikut rincian penjelasannya :

a. glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE |
GLUT_RGBA);
glutInitDisplayMode digunakan untuk menginisialisasi mode
display, mempunyai parameter mode untuk mode displaynya. Di
mana dalam kode di atas menggunakan tiga mode, yaitu :
GLUT_DEPTH : memilih jendela dengan buffer kedalaman
GLUT_DOUBLE : memilih jendela dengan buffer ganda
GLUT_RGBA : memilih jendela mode RGBA (red, green,
blue, alpha)
b. glutInitWindowPosition(100,100);
menginisialisasi posisi jendela
c. glutInitWindowSize(750,550);
menginisialisasi ukuran jendela
d. glutCreateWindow("Truk Doma Nasional");
membuat jendela top-level
e. glutSpecialFunc(pressKey);
mengatur callback keyboard khusus untuk jendela saat ini.
Callback keyboard khusus dipicu saat fungsi keyboard atau
tombol arah ditekan.
f. glutSpecialUpFunc(releaseKey);
mengatur callback keyboard khusus untuk jendela saat ini ketika
tombol keyboard dilepas (sudah tidak ditekan)
g. glutDisplayFunc(display);
mengatur callback prosedur display untuk jendela saat ini.
h. glutKeyboardFunc(keyboard);
mengatur callback prosedur keyboard untuk jendela saat ini.
i. glutIdleFunc(display);
prosedur display akan dipanggil terus menerus
j. glutReshapeFunc(Reshape);
 Fungsi dari glutReshapeFunc adalah untuk menyetel callback
(panggilan balik) dari reshape (bentukan ulang) untuk jendela saat ini.
Atau dapat disebut sebagai fungsi panggilan balik untuk bentuk baru dari
jendela.
Fungsi panggilan balik untuk reshape dipicu ketika sebuah jendela
dibentuk ulang (diubah). Fungsi panggilan balik untuk reshape juga dapat
dipicu segera sebelum sebuah panggilan balik untuk tampilan pertama
jendela setelah jendela dibuat atau setiap kali sebuah lapisan (overlay)
untuk jendela dibentuk. Parameter lebar dan tinggi dari panggilan balik
menentukan ukuran jendela baru dalam pixel. Sebelum panggilan balik,
jendela saat ini diatur menjadi jendela yang telah dibentuk ulang.

k. Memanggil prosedur Lighting dan init

l. glClearColor
menspesifikasikan nilai yang bersih untuk penyangga warna. Maksudnya,
membersihkan penyangga warna. Mempunyai empat parameter, yaitu red,
green, blue, alpha. Di mana masing – masing menspesifikasikan nilai
merah, hijau, biru, dan alfa ketika penyangga warna sudah dibersihkan.

m. glMainLoop
GLUT akan looping eventnya.

((MAAF SOURCE CODE TERLALU PANJANG, SAYA PISAHKAN DI DI FILE LAIN))

Hasil ScreenShoot :
1. Tampak Samping Kiri
2. Tampak Depan

3. Tampak Samping Kanan

4. Tampak Belakang
5. Tampak Atas

6. Tampak Bawah