KATA PENGANTAR

Segala puji bagi Allah SWT semata karena dengan rahmat dan hidayah-Nya
lah penulis dapat menyelesaikan Laporan Praktikum Grafika Komputer tepat pada
waktunya.
Terwujudnya laporan ini, tentunya tidak lepas dari bantuan-bantuan yang
telah penulis terima. Pada kesempatan ini, penulis menyampaikan terima kasih
kepada yang terhormat:
1. Ibu Febriana Santi W, S.kom, M.kom selaku dosen pembimbing
Praktikum Grafika Komputer.
2. Ibu Febriana Santi W, S.kom, M.kom selaku dosen mata kuliah Grafika
Komputer.
3. Ibu Febriana Santi W, S.kom, M.kom selaku Ketua Pelaksana Praktikum
Grafika Komputer Jurusan Teknik Informatika ITN Malang.
4. Instruktur Lab. Pengolahan Citra dan Multimedia Teknik Informatika
yang telah memberi petunjuk kepada penulis selama pelaksanaan
praktikum.
5. Rekan-rekan yang telah membantu dalam pelaksanaan dan penyelesaian
laporan ini.
Harapan penulis laporan praktikum ini bermanfaat bagi penulis sendiri
maupun pembaca.

Malang, Agustus 2018

Penulis

i
 DAFTAR ISI

KATA PENGANTAR................................................................................................i

DAFTAR ISI............................................................................................................ii

DAFTAR GAMBAR..............................................................................................iv

DAFTAR TABEL.....................................................................................................v

TUGAS GRAFIKA KOMPUTER PERTEMUAN : 1............................................7

1.1 Tujuan........................................................................................................7

1.2 Alat dan Bahan..........................................................................................7

1.3 Landasan Teori..........................................................................................7

1.4 Langkah-langkah Membuat Program........................................................8

1.5 Kesimpulan..............................................................................................17

TUGAS GRAFIKA KOMPUTER PERTEMUAN : 2..........................................18

2.1 Tujuan......................................................................................................18

2.2 Alat dan Bahan........................................................................................18

2.3 Landasan Teori........................................................................................18

2.4 Langkah-Langkah Tugas.........................................................................20

2.5 Kesimpulan..............................................................................................25

TUGAS GRAFIKA KOMPUTER PERTEMUAN : 3..........................................26

3.1 Tujuan......................................................................................................26

3.2 Alat dan Bahan........................................................................................26

3.3 Landasan Teori........................................................................................26

3.4 Langkah-Langkah Tugas.........................................................................27

3.5 Kesimpulan..............................................................................................31

TUGAS GRAFIKA KOMPUTER PERTEMUAN : 4..........................................33

1.1 Tujuan......................................................................................................33

ii
 4.2 Alat dan Bahan........................................................................................33

4.3 Landasan Teori........................................................................................33

1.2 Langkah Langkah Membaut Program.....................................................41

1.3 Kesimpulan..............................................................................................47

TUGAS GRAFIKA KOMPUTER PERTEMUAN : 5..........................................48

5.1 Tujuan......................................................................................................48

5.2 Alat dan Bahan........................................................................................48

5.3 Landasan Teori........................................................................................48

5.4 Langkah-Langkah Membuat Program.....................................................49

5.5 Kesimpulan..............................................................................................57

TUGAS GRAFIKA KOMPUTER PERTEMUAN : 6..........................................58

6.1 Tujuan......................................................................................................58

6.2 Alat dan Bahan........................................................................................58

6.3 Landasan Teori........................................................................................58

6.4 Langkah-Langkah Membuat Program.....................................................59

6.5 Kesimpulan..............................................................................................65

DAFTAR PUSTAKA.............................................................................................66

iii
 DAFTAR GAMBAR

Gambar 1.1 extract OpenGL.............................................................................8

Gambar 1.2 Microsoft Visual Studio.................................................................8

Gambar 1.3 glut32.lib.......................................................................................9

Gambar 1.4 glut32.dll.......................................................................................9

Gambar 1.5 File New Project...........................................................................9

Gambar 1.6 New Project.................................................................................10

Gambar 1.7 Consol Aplication........................................................................10

Gambar 1.8 Klik Empty Project......................................................................11

Gambar 1.9 Add New Item..............................................................................11

Gambar 1.10 Add New Item (2)......................................................................12

Gambar 1.11 Hasil Program Segiempat..........................................................13

Gambar 1.12 Hasil Program Segitiga.............................................................15

Gambar 1.13 Hasil Program Polygonal..........................................................17

Gambar 2.1 Pembentukan garis menggunakan Algoritma Bressenham.........23

Gambar 3.1 Tampilan Program Transformasi.................................................30

Gambar 4.1 Hasil Program Interaksi Keyboard..............................................44

Gambar 4.2 Hasil Program Interaksi Mouse..................................................47

Gambar 5.1 Hasil program objek 3D Wireframe............................................51

Gambar 5.2. Hasil Running Objek 3D............................................................55

Gambar 6.1 Hasil program objek 3D Solid....................................................64

iv
 DAFTAR TABEL

Tabel 1.1 Fungsi OpenGL...........................................................................13

Tabel 1.2 Fungsi OpenGL...........................................................................14

Tabel 1.3 Fungsi OpenGL...........................................................................16

Tabel 2.1 Algoritma Bressenham................................................................21

Tabel 2.2 Fungsi OpenGL...........................................................................23

Tabel 3.1 Fungsi program transformasi objek.............................................28

Tabel 4.1 Fungsi OpenGL...........................................................................43

Tabel 4.2 Fungsi OpenGL...........................................................................46

Tabel 5.1 Fungsi openGL............................................................................51

Tabel 5.2. Fungsi OpenGL..........................................................................55

Tabel 6.1 Fungsi openGL............................................................................64

v
 PRATIKUM GRAFIKA KOMPUTER PERTEMUAN : 1

NIM : 1418074
NAMA : Mohammad Attoila Atijani Sulistyo
BAB : PENGENALAN OPENGL & PRIMITIF OBJEK
1. Konfigurasi library OpenGL
MATERI : 2. Inisialisas OpenGL
3. konsep primitif objek di OpenGL
4. Pembuatan primitif objek di OpenGL
: 1. Tutorial Instal OpenGL di Visual Studio pada Laptop
masing masing
2. Tutorial Membuat Project Baru C++ OpenGL pada
TUGAS
Visual studio
3. Membuat Objek primitif, Segitiga, segi empat,
Polygonal dengan warna Pelangi

1.1 Tujuan
1. Praktikan mampu mengoperasikan OpenGL pada Microsoft Visual Studio
2. Praktikan dapat membuat sebuah object primitif menggunakan OpenGL
pada Microsoft Visual Studio
3. Praktikan dapat memberikan warna pada object primitif yang telah dibuat

1.2 Alat dan Bahan

1. Laptop
2. Microsoft Visual studio 2010
3. OpenGL 3.7.6
4. Modul Grafika Komputer

1.3 Landasan Teori

A. OpenGL
OpenGL adalah kumpulan standard API (Application
Programming Interface) yang menghubungkan software dengan hardware
grafis untuk menampilkan gambar 2D dan 3D. Intinya OpenGL itu adalah

6
 kumpulan library untuk mengakses hardware (GL= graphical library).
OpenGL mendefinisikan berbagai instruksi untuk menggambar objek,
image (umumnya 3D) dan melakukan berbagai operasi terhadap objek-
objek tersebut. OpenGL tidak mengandung source code, hanya spesifikasi
saja. Pembuat GPU (graphical processing unit) seperti NVIDIA, Intel,
Samsung dll yang akan membuat implementasi. Dengan cara ini
walaupun GPU diproduksi oleh berbagai produsen dengan berbagai
berbagai variasi tipe dan implementasi, semuanya dapat diperintah dengan
spesifikasi yang sama. Setiap produsen punya spesifikasi yang berbeda:
game ini hanya dapat dijalankan di NVIDIA saja, game yang itu hanya di
Intel saja dst. (andini, diyah. 2011)

B. Primitif Object
Obyek primitive, adalah sebuah obyek yang merupakan dasar dari
prmbentukan obyek lain yang lebih kompleks dari obyek primitive.
Dikatakan sebagai obyek primitif karea merupakan bentuk yang sangat
mendasar sebagai objek dalam pendeklarasian. (andini, diyah. 2011)

1.4 Langkah-langkah Membuat Program

1. Install OpenGL
a. Extract terlebih dahulu OpenGL dan ambil 3 file yang bernama
“glut.h”, “glut32.lib” dan “glut32.” seperti pada gambar 1.1.

Gambar 1.1 extract OpenGL

b. Copy glut.h ke $dir\Program Files\Microsof Visual Studio

9.0\VC\include.

7
 Gambar 1.2 Microsoft Visual Studio

c. Copy glut32.lib ke $dir\Program Files\Microsoft Visual Studio

9.0\VC\lib.

Gambar 1.3 glut32.lib

d. Copy glut32.dll ke $dir\Windows\System32.

Gambar 1.4 glut32.dll

2. Membuat project baru

a. Buka Microsoft Visual Studio 2008.
b. Klik File – New – Project

Gambar 1.5 File New Project

c. Pilih Win32 Console Application, lalu beri nama project dan lokasi
penyimpanan sesuai keinginan, seperti gambar 1.6, lalu klik ok untuk
melanjutkan

8
 Gambar 1.6 New Project

d. Klik Next untuk melanjutkan proses seperti gambar 1.7

Gambar 1.7 Consol Aplication

e. Pilih Empty project, lalu klik Finish.

9
 Gambar 1.8 Klik Empty Project

f. Pada Solution Explorer, klik kanan pada Source Files – Add – New
Item.

Gambar 1.9 Add New Item

g. Pilih C++ File (.cpp), beri nama sesuai keinginan, klik Add. Seperti
gambar 1.10

10
 Gambar 1.10 Add New Item (2)

3. Membuat objek primitif

a. Segiempat
Header file (.h)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <glut.h>
void mydisplay()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glColor3f (1, 0, 0);
glVertex2f(-0.5, -0.5);
glColor3f (1, 1, 0);
glVertex2f(-0.5, 0.5);
glColor3f (0, 1, 0);
glVertex2f(0.5, 0.5);
glColor3f (0, 0, 1);
glVertex2f(0.5, -0.5);
glEnd();
glFlush();
}

C++ File (.cpp)

#include "segiempat.h"
int main(int argc, char** argv){
glutCreateWindow("simple");
glutDisplayFunc(mydisplay);
glutMainLoop();}

11
 Tabel 1.1 Fungsi OpenGL
No Fungsi Pengertian Contoh Penggunaan
1 glClear Menghapus glClear
window dan (GL_COLOR_BUFFER_BIT)
memberikan
warna yang telah
didefinisikan
2 glColor3f Penentuan suatu glColor3f (1, 0, 0)
warna RGB.

3 glVertex2f Menggambar glVertex2f(-0.5, -0.5)

titik pada
koordinat x dan
y, dengan nilai
satuan berupa
float.
4 glEnd() Mengakhiri glEnd()
penggambaran
sebuah garis.
5 glFlush() Rendiring glFlush()

Hasil dari program

Gambar 1.11 Hasil Program Segiempat

b. Segitiga

12
Header file (.h)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <glut.h>
void mydisplay()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
glColor3f (1, 0, 0);
glVertex2f(-0.5, -0.5);
glColor3f (1, 1, 0);
glVertex2f(-0.5, 0.5);
glColor3f (0, 1, 0);
glVertex2f(0.5, 0.5);
glEnd();
glFlush();
}

C++ File (.cpp)

#include "segitiga.h"
int main(int argc, char** argv)
{
glutCreateWindow("simple");
glutDisplayFunc(mydisplay);
glutMainLoop();
}

Tabel 1.2 Fungsi OpenGL

No Fungsi Pengertian Contoh Penggunaan
1 glClear Menghapus GlClear
window dan (GL_COLOR_BUFFER_BIT)
memberikan
warna yang telah
didefinisikan
sebelumnya
dengan
menggunakan
glClearColor.
2 glColor3f Penentuan suatu glColor3f (1, 0, 0)
warna.

3 glVertex2f Menggambar glVertex2f(-0.5, -0.5)

titik pada

13
 koordinat x dan
y, dengan nilai
satuan berupa
float.
4 glEnd() Mengakhiri glEnd()
penggambaran
sebuah garis.
5 glFlush() Rendiring glFlush()

Hasil dari program

Gambar 1.12 Hasil Program Segitiga

c. Polygonal
Header file (.h)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <glut.h>
void mydisplay()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glColor3f(1, 0, 0);
glVertex2f(-0.5, -0.5);
glColor3f (0, 1, 1);
glVertex2f(-0.75, 0);
glColor3f (1, 1, 0);
glVertex2f(-0.5, 0.5);
glColor3f (0, 1, 0);
glVertex2f(0, 0.75);

14
 glColor3f (0, 0, 1);
glVertex2f(0.5, 0.5);
glColor3f (1, 0, 1);
glVertex2f(0.75, 0);
glColor3f (1, 1, 1);
glVertex2f(0.5, -0.5);
glColor3f (0, 0, 0);
glVertex2f(0, -0.75);
glEnd();
glFlush(); }

C++ File (.cpp)

#include "polygonal.h"
int main(int argc, char** argv)
{
glutCreateWindow("simple");
glutDisplayFunc(mydisplay);
glutMainLoop();
}

Tabel 1.3 Fungsi OpenGL

No Fungsi Pengertian Contoh Penggunaan
1 glClear Menghapus glClear
window dan (GL_COLOR_BUFFER_BIT)
memberikan
warna yang telah
didefinisikan
sebelumnya
dengan
menggunakan
glClearColor.
2 glColor3f Penentuan suatu glColor3f (1, 0, 0)
warna.

3 glVertex2f Menggambar glVertex2f(-0.5, -0.5)

titik pada
koordinat x dan
y, dengan nilai
satuan berupa
float.
4 glEnd() Mengakhiri glEnd()
penggambaran
sebuah garis.
5 glFlush() Rendiring glFlush()

15
 Hasil dari program

Gambar 1.13 Hasil Program Polygonal

1.5 Kesimpulan
1. Dalam pembuatan objek pada library openGL terlebih dahulu harus
mengkonfigurasi library openGL ke dalam Microsoft Visual Studio
2. Library OpenGL dapat digunakan untuk membuat sebuah objek primitif
pada Microsoft Visual Studio.
3. Untuk membuat sebuah objek primitive terlebih dahulu harus menentukan
titik-titiknya yang ahirnya diterapkan kedalam program pada library
openGL

Tanggal Asitensi Asisten Lab

Rendy Dimas Harianto

1518086

16
 PRATIKUM GRAFIKA KOMPUTER PERTEMUAN : 2

NIM : 1418074
NAMA : Mohammad Attoila Atijani Sulistyo
BAB III : ALGORITMA DDA & BRESSENHAM
1. Algoritma DDA (Digital Differential Analyzer)
MATERI : 2. Algoritma Bressenham
3. Pembuatan Garis menggunakan algoritma Bressenham
pada Microsoft Visual Studio 2010
: 1. Diketahui 2 buah titik A(15,16) dan B (28,13) buatlah
garis menggunakan algoritma Bressenham
TUGAS 2. Mencoba kembali coding Algoritma Bressenham dengan
titik A=(11,11) dan B=(18,17) dan menjelaskan fungsi
yang digunakan

2.1 Tujuan
1. Praktikkan mampu memahami konsep Algoritma Bresenham dan
algoritma DDA.
2. Praktikan mampu menerapkan algoritma DDA dalam membuat garis di
library openGl pada Microsoft Visual Studio 2010.
3. Praktikan mampu menerapkan algoritma Bressenham dalam membuat
garis di library openGl Microsoft Visual Studio 2010.

2.2 Alat dan Bahan

1. Laptop
2. Visual Studio 2010
3. OpenGL (glut-3.7.8-bin)
4. Modul Grafika Komputer 2017

2.3 Landasan Teori

A. Algoritma DDA (Digital Differential Analyzer)
DDA adalah algoritma pembentukan garis berdasarkan perhitungan
x dan y, menggunakan rumus y = m. x. Garis dibuat dengan menentukan

17
 dua endpoint yaitu titik awal dan titik akhir. Setiap koordinat titik yang
membentuk garis diperoleh dari perhitungan, kemudian dikonversikan
menjadi nilai integer. (Multimedia, Laboratorium. 2017).

Langkah – langkah pembentukan menurut algoritma DDA, yaitu :

1. Tentukan dua titik yang akan dihubungkan.

2. Tentukan salah satu titik sebagai titik awal (x 0,y0) dan titik akhir
(x1,y1).
3. Hitung dx = x1 – x0 dan dy = y1 – y0.
4. Tentukan step, yaitu jarak maksimum jumlah penambahan nilai x
maupun nilai y dengan cara :
a. Bila nilai |dy| > |dx| maka step = nilai |dy|
b. Bila tidak maka step = nilai |dx|
5. Hitung penambahan koordiant pixel yaitu x_increment = dx / step dan
y_increment = dy / step.
6. Koordinat selanjutnya (x+x_increment , y+y_increment)
7. Posisi pixel pada layer ditentukan dengan pembulatan nilai koordinasi
tersebut.
8. Ulangi step 6 dan 7 untuk menentukan posisi pixel selanjutnya,
sampai x = x1 dan y = y1.

B. Algoritma Bressenham
Prosedur untuk menggambar kembali garis dengan membulatkan
nilai x atau y kebilangan integer membutuhkan waktu, serta variable x,y
dan m merupakan bilangan real karena kemiringan merupakan nilai
pecahan. Bressenham mengembangkan algoritma klasik yang lebih
menarik, karena hanya menggunakan perhitungan matematika dengan
bilangan integer. Dengan demikian tidak perlu membulatkan nilai posisi
setiap pixel setiap waktu. Algoritma garis Bressenhem disebut juga
midpoint line algorithm adalah algoritma konversi penambahan nilai
integer yang juga dapat diadaptasi untuk menggambar sebuah lingkaran.
(Multimedia, Laboratorium. 2017).

Langkah – langkah untuk membentuk garis menurut algoritma ini

adalah :

18
 1. Tentukan dua titik yang akan dihubungkan dalam pembentukan
garis.
2. Tentukan salah satu titik disebelah kiri sebagai titik awal (x0,y0) dan
titik lainnya sebagai titik akhir (x1,y1).
3. Hitung dx, dy, 2dx, dan 2dy-2dx.
4. Hitung parameter p0 = 2dy – dx
5. Untuk setiap xk sepanjang jalur garis , dimulai dengan k = 0.
a. Bila pk < 0 maka titik selanjutnya (xk +1, yk) dan pk+1 = pk + 2dy
b. Bila tidak maka titik selanjutnya adalah (xk +1, yk + 1) dan pk+1 = pk
+ 2dy – 2dx.
6. Ulangi langkah nomor 5 untuk menentukan posisi pixel selanjutnya,
sampai x = x1 dan y = yk.

2.4 Langkah-Langkah Tugas

A. Menggambar garis melalui 2 buah titik yaitu (15,6) dan (28,13)

1. Menentukan dua titik yang akan dihubungkan

- Diketahui 2 buah titik A(15,6) dan B(28,13).
2. Menentukan titik awal dan titik akhir
- (15,6) = (x0,y0) titik awal
- (28,13) = (x1,y1) titik akhir
3. Menghitung dx, dy, 2dx, 2dy dan 2dy-2dx.
- Dx = 28 – 15 = 13
- Dy = 13-6 = 7
- 2dx = 2(13) = 26 , 2dy = 2(7) = 14
- 2dy – 2dx = 14-26 =>-12
4. Menghitung parameter pertama p0 = 2dy – dx
- P0 = 14-13 = 1
5. Menentukan koordinat dari kondisi yang telah ditentukan :
a. Bila pk < 0 maka titik selanjutnya (xk +1, yk) dan pk+1 = pk + 2dy
b. Bila tidak maka titik selanjutnya adalah (xk +1, yk + 1) dan pk+1 = pk +
2dy – 2dx.

Tabel 2.1 Algoritma Bressenham

K P X Y Koordinat Penentuan P
- 1 15 6 (15,6) P0 = 1
0 -11 16 7 (16,7) P1 = 1 + (-12) = -11
1 3 17 7 (17,7) P2 = -11 + 14 = 3
2 -9 18 8 (18,8) P3 = 3 + (-12) = -9
3 5 19 8 (19,8) P4 = -9 + 14 = 5
4 -7 20 9 (20,9) P5 = 5 + (-12) = -7
5 7 21 9 (21,9) P6 = -7 + 14 = 7
6 -5 22 10 (22,10) P7 = 7 + (-12) = -5

19
 7 9 23 10 (23,10) P8= -5 + 14 = 9
8 -3 24 11 (24,11) P9= 9 + (-12) = -3
9 11 25 11 (25,11) P10= -3 + 14 = 11
10 -1 26 12 (26,12) P11= 11 + (-12) = -1
11 13 27 13 (27,13) P12= -1 + 14 = 13
12 1 28 13 (28,13) P13= 13 + (-12) = 1

B. Menggambar garis menggunakan algoritma Bressenham pada Visual

Studio
1. Masukkan source code pada project Visual Studio.
Source Code Main.cpp :
#include "bresenham.h"

int main(int argc, char** argv)

glutInitWindowSize(400,400);

glutInitWindowPosition(0,0);

glutCreateWindow("bresenham");

display();

glutDisplayFunc(drawMyLine);glutMainLoop();

return 0;}

Source Code Bresenham.h :

#include <stdio.h>
#include <glut.h>
void display()
{
glClearColor(1.0, 1.0, 1.0, 0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,50.0,0.0,50.0);

}
void setPixel (GLint xCoordinate, GLint yCoordinate)
{
glBegin (GL_POINTS);
glVertex2i (xCoordinate, yCoordinate);
glEnd();
glFlush();
}
void lineBres (GLint x0, GLint y0, GLint xEnd, GLint yEnd)
{
GLint dx = (xEnd - x0);

20
GLint dy = (yEnd - y0);
GLint p = 2*dy-dx;
GLint twoDy = 2*dy;
GLint twoDyMinusDx = 2*(dy-dx);
GLint x,y;
if(x0 > xEnd){
x=xEnd;
y=yEnd;
xEnd=x;
}
else{
x=x0;
y=y0;
}
setPixel(x,y);
while(x<xEnd){
x++;
if(p<0)
p+=twoDy;
else{
y++;
p+=twoDyMinusDx;
}
setPixel(x,y);
}
}
void drawMyLine ()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 0.0, 0.0);
glColor3f(1,0,0);
glPointSize(4.0);
GLint x0 = 15;
GLint y0 = 6;
GLint xEnd = 28;
GLint yEnd = 13;
lineBres(x0,y0,xEnd,yEnd);
}

Tampilan Hasil Program

21
 Gambar 2.1 Pembentukan garis menggunakan Algoritma Bressenham

Tabel 2.2 Fungsi OpenGL

Fungsi OpenGL Penjelasan
Stdio.h Digunakan untuk menampilkan
perintah input dan output seperti
printf
Glut.h Digunakan untuk menampilkan
perintah perintah yang ada dalam
library glut
Void display() Membuat fungsi mydisplay
glCLearColor(1.0, 1.0, 1.0 ,1.0) Digunakan untuk menghapus
buffer yang ada di form windows
dan memberikan warna putih rgba
glMatrixMode(GL_PROJECTION) Mengatur Viewport
gluOrtho2D (0.0, 20.0, 0.0, 20.0) Mengatur koordinat maksimum
yang akan digunakan yaitu 0,20
dan 20,0
Void setpixel(GLint xCoordinate, Menetapkan variable yang
GLint uyCoordinate) digunakan adalah xCoordinat dan
yCoordinat
glBegin(GL_POINTS) Digunakan untuk memulai library
opengl dengan menggunakan
library GL_points (titik)
glVertex2i(xCoordinate, Membuat garis bertipe integer
yCoordinate) dengan variable xCoordinat dan
yCoordinat
glEnd(); Digunakan untuk menampilkan
perintah mengakhiri program
glFlush(); Digunakan untuk rendering
program

22
Void Linebres(x0,y0,xend,yend) Membuat fungsi linebres dengan
variable x0,y0,xend,yend
Glint Glint digunakan untuk membuat
variable bertipe integer
twoDy Variable yang digunakan untuk
menyimpan data dari 2 * dy
twoDyMinusDx Variable yang digunakan untuk
menyimpan data dari 2 * (dy - dx);
if (x0 > xEnd) Fungsi if digunakan untuk
melakukan perkondisian dimana
pada source code berikut yaitu jika
x0 lebih besar dibanding xend
maka prosedur yang dibawahnya
yang dijalankan
else { Fungsi else dijalankan jika fungsi
if tidak dijalankan
setPixel(x, y); Setpixel(x,y) digunakan untuk
meng inisialisasi variable x dan y
void drawMyLine(void) Membuat fungsi drawMyline
dengan menggunakan parameter
void yang akan di gunakan.
glClear(GL_COLOR_BUFFER_BI Digunakan untuk menghapus
T); buffer yang ada di form windows.
glColor3f(1.0, 0.0, 0.0); Digunakan untuk memberi warna
red
glPointSize(4.0); Memberi inisialisasi pada besar
glpoint adalah 4
lineBres(x0, y0, xEnd, yEnd); Memberikan parameter ke fungsi
linebres
glutInit(&argc, argv); Perintah yang digunakan untuk
memberikan inisialisasi ke project
glutInitDisplayMode(GLUT_SING Perintah yang digunakan untuk
LE | GLUT_RGB); menentukan mode display yang
akan digunakan
glutCreateWindow(); Digunakan untuk membuat sebuah
window glut
Display(); Memanggil fungsi display
glutDisplayFunc(drawaMyLine); Digunakan untuk memanggil
sebuah fungsi
glutMainLoop(); Digunakan untuk melakukan
perulangan terus menerus terhadap
rendering yang dilakukan pada
main
Return 0; Mengembalikan ke project

23
2.5 Kesimpulan
1. Algoritama Bressenhem digunakan sebagai pembuat garis yang
menggunakan perhitungan matematis
2. Untuk membuat garis dengan menggunakan algoritma Bressenham harus
menentukan 2 titik terlebih dahulu.
3. OpenGL bisa mengimplementasikan pembuatan garis dengan algoritma
Bresenham

Nilai Asisten Lab

Rendy Dimas Harianto

1518086

PRATIKUM GRAFIKA KOMPUTER PERTEMUAN : 3

NIM : 1418074
NAMA : Mohammad Attoila Atijani Sulistyo
BAB : Transformasi Objek
MATERI : 1. Konsep Transformasi Objek
2. Penerapan Transformasi objek pada OpenGL
: Membuat program yang menerapkan Translasi, Rotasi,
TUGAS
dan Skala

3.1 Tujuan
1. Praktikan mampu memahami transformasi objek pada OpenGL.

24
 2. Praktikan mampu melakukan transformasi objek menggunakan OpenGL.
3. Praktikan mampu melakukan implementasi transformasi objek pada
OpenGL.

3.2 Alat dan Bahan

1. Laptop
2. Visual Studio 2010
3. OpenGL (glut-3.7.6-bin)
4. Modul Praktikum Grafika Komputer 2017

3.3 Landasan Teori

A. Transformasi
Transformasi merupakan suatu metode untuk mengubah lokasi
suatu titik pembentuk objek, sehingga objek tersebut mengalami
perubahan. Perubahan objek dengan mengubah koordinat dan ukuran suatu
objek disebut dengan transformasi geometri. Dalam Transformasi dasar
yang akan dibahas meliputi translasi, skala, dan rotasi. (Multimedia.
Laboratorium.2017).

B. Translasi
Translasi berarti memindahkan objek sepanjang garis lurus dari
suatu lokasi koordinat tertentu kelokasi yang lain tanpa mengubah bentuk
objek. Bila suatu objek terbentuk dari beberapa titik maka bila melakukan
translasi akan dikenakan terhadap setiap titik pembentuk objek tersebut.
Untuk melakukan translasi dapat menggunakan rumus:
x’ = x + tx
y’ = y + ty
C. Skala
Skala digunakan untuk mengubah ukuran suatu objek, bila pada
translasi operasi yangdigunakan adalah penjumlahan sedangkan pada skala
operasi yang digunakan adalah perkalian. Untuk melakukan skala dapat
menggunakan rumus:
x’ = x * sx
y’ = y * sy
sx dan sy merupakan nilai dari scaling factor terhadap sumbu x dan sumbu
y.
D. Rotasi

25
 Rotasi merupakan pemutaran terhadap suatu objek, rotasi dapat dinyatakan
dalam bentukmatriks. Nilai matriks untuk melakukan rotasi adalah Rotasi
suatu titik terhadap pivot point (xp, yp) menggunakan bentuk trigonometri.

3.4 Langkah-Langkah Tugas

1. Membuat program tranformasi objek (translasi, rotasi dan skala)
menggunakan Visual Studio 2010
Source Code “Transformasi.h” :

#include <stdlib.h>
#include <glut.h>
void drawQuad1()
{
glBegin(GL_QUADS);
glVertex2f(-500., 100.);
glVertex2f(-500., 10.);
glVertex2f(-100., 10.);
glVertex2f(-100., 100.);
glEnd();
}
void renderScene1(void)
{
glClear(GL_COLOR_BUFFER_BIT);
drawQuad1();
glPushMatrix();
glTranslatef(10, 10, 0);
glColor3f(1, 0, 0);//red
drawQuad1();
glPopMatrix();
glPushMatrix();
glTranslatef(250, 400, 0);
glRotatef(90, 0, 0, 1);
glColor3f(0, 1, 1);//cyan
drawQuad1();
glPopMatrix();
glPushMatrix();
glTranslatef(-200, -350, 0);
glScalef(0.5, 0.5, 0);
glColor3f(1, 0, 1); //magenta
drawQuad1();
glPopMatrix();
glPushMatrix();
glTranslatef(-50, -180, 0);
glScalef(0.4, 0.4, 0);
glColor3f(1, 1, 1); //white
glPopMatrix();
glFlush();

26
}

Source Code “Main.cpp” :

#include "gabungan.h";
void main(int argc, char **argv){
glutInit(&argc, argv);
glutInitWindowPosition(100, 100);
glutInitWindowSize(480, 480);
glutCreateWindow("Implementasi Transformasi");
gluOrtho2D(-640., 640., -640., 640.);
glutDisplayFunc(renderScene1);
glutMainLoop();
}

Tabel 3.1 Fungsi program transformasi objek

No Fungsi Pengertian Contoh Penggunaan
1 gluOrtho2D Untuk merubah gluOrtho2D(-550.0,
ukuran kanvas 550.0, -550.0, 550.0);
2 glutInitWindo Untuk merubah glutInitWindowPosition(
wsPosition posisi kanvas 100, 100);
3 glutInitWindo Untuk merubah glutInitWindowSize(480
wsSize ukuran kanvas , 480);
4 glutCreateWin Untuk memberi nama glutCreateWindow("Tra
dows(“”) pada kanvas nformasi");

5 glutDisplayFu Untuk memanggil glutDisplayFunc(translas

nc(“”); fungsi yang telah i);
dibuat
6 GlVertex2f Mebuat garis 2d x,y Glvertex2f(3.4)
dengan tipe data float
7 glColor3f Untuk Penentuan glColor3f(0,0,1);
suatu warna
8 glClear Untuk menghapus glClear(GL_COLOR_B
window dan UFFER_BIT);
memberikan warna
yang telah kita
definisakn
sebelumnya dengan

27
 menggunakan
glClearColor
9 glBegin Untuk memmulai glBegin (GL_POINTS);
menggambar dalam
bentuk garis. Setiap
pasangan verteks
sebagai seg,em garis
independen
10 glTranslatef Untuk melakukan glTranslatef(-20,20,0);
translasi pada suatu
titik koordinat
11 glScalef Untuk melakukan glScalef(1,-1,0);
scale pada suatu titik
koordinat
12 glRotatef Untuk melakukan glRotatef(315,0,0,1)
rotasi pada suatu titik
koordinat
10 glEnd Untuk mengakhiri glEnd();
penggambaran
sebuah garis
11 glFlush Rendering glFlush();

Tampilan hasil program :

28
Gambar 3.1 Tampilan Program Transformasi

29
3.5 Kesimpulan
1. Transformasi object digunakan untuk melakukan perubahan suatu titik
terhadap suatu object sehingga object mengalami perubahan.
2. Transformasi objek terdapat 3 metode yaitu dengan translasi, skala, dan
rotasi.
3. Untuk melakukan trasformasi objek terlebih dahulu harus menentukan titik
akhir

Tanggal Asitensi Asisten Lab

Rendy Dimas Harianto

1518086

30
 PRATIKUM GRAFIKA KOMPUTER PERTEMUAN : 4

NIM : 1418074
NAMA : Mohammad Attoila Atijani Sulistyo
ANIMASI DAN PEMROGRAMAN INTERAKSI
BAB :
DENGAN PERANGKAT
1. Animasi objek pada OpenGL
MATERI :
2. Interaksi perangkat keras dengan OpenGL
:
TUGAS Membuat interaksi dengan keyboard

1.1 Tujuan
1. Praktikan mampu memahami animasi pada OpenGL.
2. Praktikan mampu melakukan implementasi animasi objek pada OpenGL.
3. Praktikan mampu memahami interaksi perangkat keras dengan OpenGL.
4. Praktikan mampu melakukan implementasi interaksi perangkat keras
dengan OpenGL.

4.2 Alat dan Bahan

1. Laptop
2. Visual studio 2010
3. OpenGL 3.7.6
4. Modul Grafika Komputer 2017

4.3 Landasan Teori

A. Konsep Animasi pada Glut
Dalam penggunaan GlutTimeFunc dimungkinkan untuk membuat
sebuah animasi yang dikontrol oleh waktu. Fungsi dari GlutPostRedisplay
adalah mengirimka perintah untuk mengaktifkan display secara berkala
(looping). Kemudian pada main program perlu menambahkan fungsi
untuk mengaktifkan timer function.

31
B. Konsep Input Keyboard pada Glut-Key
GlutKeyboardFunc adalah suatu fungsi callback untuk digunakan
sebagai masukan pada suatu jendela window. Konsepnya pada saat
seorang user atau pengguna memberikan input yaitu menekan pada tombol
keyboard, setiap tombol keyboard yang ditekan akan menghasilkan suatu
karakter ASCII yang akan menghasilkan suatu callback pada keyboard
yang telah didefinisikan berupa fungsi dengan 3 parameter.

Penggunaan input keyboard pada tombol-tombol biasa atau normal

key (a-x, 1-0), dapat dilakukan dengan menggunakan callback function
berupa GlutKeyboardFunc(myKeyboard) dengan dideklarasikan terlebih
dahulu suatu fungsi buatan untuk menampung semua perintah input yang
akan digunakan oleh user. Fungsi buatan tersebut seperti contoh di
bawah ini:

void myKeyboard(unsigned char key, int x, int y)

{
//masukkan perintah disini
}

Fungsi tersebut berisi suatu perintah yang akan digunakan dalam

pengoperasian program oleh user. Di dalam fungsi tersebut terdapat 3
parameter dan di dalamnya dideklarasikan suatu perintah yang nantinya akan
digunakan.

void timer(int value)

{
glutPostRedisplay();
glutTimerFunc(100, timer, 0);
}

void myKeyboard(unsigned char key, int x, int y)

{
if(key == 'a') glTranslatef(0,5,0); if(key == 'd')

glTranslatef(0,-5,0);
}

void renderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.,0.,0.);
Draw();
glFlush();

32
}
Sintaks tersebut adalah sintaks dasar yang digunakan, untuk bisa
menggunakan input keyboard maka harus diberikan callback function untuk
memanggilnya.

glutDisplayFunc(renderScene);
glutKeyboardFunc(myKeyboard);
glutTimerFunc(30,timer,0);

Sintaks tersebut harus disertakan pada fungsi main. Selain itu, pada
keyboard juga terdapat method lain yang bisa digunakan dalam proses input
ini, yaitu Key Press, Key Up, dan Key Buffering.
1. Key Press
Metode ini akan memberitahukan kita pada command line tombol apa
yang sedang kita tekan. Method ini dapat dinamakan KeyPressed dan pada
GLUT akan terdapat 3 parameter, satu untuk tombol yang saat itu ditekan,
dan dua untuk memberitahukan lokasi mouse ketika tombol ditekan.

void keyPressed(unsigned char key, int x, int y)

If(key == ‘a’) // saat tombol ‘a’ ditekan

// aksi yang diberikan saat tombol ‘a’ ditekan

Dari fungsi tersebut akan dipanggil pada fungsi main, namun callback
function-nya sedikit berbeda dari callback function yang sebelumnya.

glutKeyboardFunc(keyPressed); // memberitahukan pada GLUT

untuk menggunakan method "keyPressed" untuk tombol yang
ditekan

2. Key Up
Fungsi Key Up ini adalah fungsi register yang menyimpan nilai
masukan dampai ketika tombol keyboard dilepaskan. Hal ini bisa berguna
untuk pengaturan beberapa nilai ketika suatu tombol pertama kali ditekan,
dan tetap menjaga nilai tersebut sampai tombol tersebut dilepaskan.

33
 Method sama seperti method Key Press tadi yaitu memiliki 3 parameter
yang memiliki fungsi yang sama, hanya berbeda penamaannya yaitu
KeyUp.

void keyUp(unsigned char key, int x, int y)

{
if(key == ‘a’) // saat tombol ‘a’ ditekan
{
// aksi yang diberikan saat tombol ‘a’
ditekan
}
}

Dan fungsi tersebut akan dipanggil pada fungsi main, namun callback
function-nya sedikit berbeda dari callback function yang sebelumnya.

glutKeyboardFunc(keyUp); // memberitahukan pada GLUT untuk

menggunakan method "keyUp" untuk tombol yang dilepas

3. Key Buffering
Method ini memungkinkan untuk penanganan terhadap tombol yang
ditekan dalam jumlah banyak dalam proyek-proyek OpenGL. Seperti yang
diketahui tipe data char sama dengan byte dan dapat mengambil nilai
integer dari 0 sampai 255. Ini dikarenakan tipe data char memiliki ukuran
28 atau 256. Hal ini memungkinkan kita untuk menangani hingga 256
tombol berbeda pada keyboard, atau seluruh set karakter ASCII.
Pertama dimulai dengan pendeklarasian sebuah array dari nilai Boolean
yang akan menangani masing-masing method keyboard, true untuk tombol
yang ditekan, dan false saat tombol dilepaskan.

bool* keyStates = new bool[256]; // membuat array dari nilai

boolean dengan ukuran 256 (0-255)
Kemudian dilanjtukan dengan pendeklarasian masing-masing method.

void keyPressed(unsigned char key, int x, int y)

{
keyStates[key] = true;
}
void keyUp(unsigned char key, int x, int y)
{
keyStates[key] = false;
}
void keyOperations(void)
{
if(keyStates['a']) // saat tombol ‘a’ ditekan
{

34
 // aksi yang diberikan saat tombol ‘a’ ditekan
}
}
Sama seperti sebelumnya fungsi-fungsi tersebut akan dipanggil pada
fungsi main dengan callback function berikut:

void display (void)

{
keyOperations();
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
// menjadikan background menjadi warna merah
…
}

A. Konsep Input Keyboard Special Key

GlutSpecialFunc merupakan suatu fungsi callback pada OpenGL yang
digunakan untuk mengaktifkan tombol-tombol khusus pada keyboard
sehingga dapat digunakan untuk berinteraksi antara user dengan objek yang
ada di dalam display OpenGL. Pendeklarasiannya adalah:

void glutSpecialFunc (void (* func) (int key, int x, int y));

Callback Keyboard khusus dipicu ketika keyboard fungsi atau tombol

special yang dideklarasikan ditekan. Parameter callback kunci adalah
GLUT_KEY_tombol khusus. Parameter x dan y mengindikasikan koordinat
relatif jendela ketika tombol ditekan. Ketika jendela baru dibuat, tidak ada
callback khusus awalnya terdaftar dan stroke kunci khusus di jendela
diabaikan. Melewati NULL untuk GlutSpecialFunc menonaktifkan generasi
callback khusus. Selama callback khusus, GlutGetModifiers dapat dipanggil
untuk menentukan keadaan tombol pengubah ketika keystroke menghasilkan
callback terjadi. Nilai-nilai yang tersedia GLUT_KEY_* adalah:

GLUT_KEY_F1 F1 function key

GLUT_KEY_F2 F2 function key

GLUT_KEY_F3 F3 function key

GLUT_KEY_F4 F4 function key

GLUT_KEY_F5 F5 function key

35
GLUT_KEY_F6 F6 function key

GLUT_KEY_F7 F7 function key

GLUT_KEY_F8 F8 function key

GLUT_KEY_F9 F9 function key

GLUT_KEY_F10 F10 function key

GLUT_KEY_F11 F11 function key

GLUT_KEY_F12 F12 function key

GLUT_KEY_LEFT Left function key

GLUT_KEY_RIGHT Right function key

GLUT_KEY_UP Up function key

GLUT_KEY_DOWN Down function key

GLUT_KEY_PAGE_UP Page Up function key

GLUT_KEY_PAGE_DOWN PageDown function key

GLUT_KEY_HOME Home function key

GLUT_KEY_END End function key

GLUT_KEY_INSERT Insert function key

Tombol-tombol di atas dapat diaktifkan dengan membuat sebuah fungsi

callback yang akan dipanggil oleh GlutSpecialFunc ke dalam fungsi main
program, sehingga user dapat berinteraksi dengan objek yang ada dengan
menekan tombol-tombol special keyboard yang telah dideklarasikan ke dalam
fungsi callback tersebut. Contoh pembuatan fungsi callback untuk tombol
special keyboard:

void mySpecialKeyboard(int key, int x, int y)

{
switch(key)
{
case
GLUT_KEY_LEFT : c+=-4;
d+=0;
break;
case
GLUT_KEY_RIGHT : c+=4;
d+=0;

36
 break;
case
GLUT_KEY_UP : c+=0;
d+=4;
break;
case GLUT_KEY_DOWN : c+=0;
d+=-4;
break;
}
}

Selanjutnya fungsi tersebut akan dipanggil opeh GlutDIsplayFunc ke dalam

fungsi main, berikut scriptnya:

glutSpecialFunc(mySpecialKeyboard);

Selain fungsi callback yang mendeklarasikan tombol special keyboard,

untuk dapat berinteraksi fungis tersebut harus memiliki fungsi callback lain
yang akan dipanggil ke dalam fungsi GlutDisplayFunc di dalam fungsi main
program tersebut. Fungsi callback di dalam fungsi GlutDisplayFunc
merupakan fungsi yang mendeklarasikan objek yang akan berinteraksi
dengan tombol keyboard. Sedangkan fungsi GlutTimeFunc berfungsi agar
tombol keyboard dapat terus terdeteksi oleh Glut.

B. Konsep Mouse pada Glut

Dalam konsep mouse pada glut ada beberapa fungsi dasar dan inisialisasi
yang digunakan untuk melakukan interaksi mouse. Adapun penjelasannya
adalah sebagai berikut:
1. Fungsi dasar pembuatan interaksi dengan menggunakan MouseFunction
GLUTAPI void APIENTRY glutMouseFunc(void (GLUTCALLBACK
*func)(int button, int state, int x, int y));

Parameter func adalah fungsi yang akan ditangani dengen event mouse
click.

GLUTAPI void APIENTRY glutMotionFunc(void *func(int x, int

y));
Fungsi di atas adalah fungsi pelengkap dari fungsi interaksi mouse untuk
mendeteksi gerakan mouse.

2. Inisialisasi dalam penggnaan MouseFunction

void mouse(int button, int state, int x,int y)
{

37
 if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
drawDot(x,480-y);
if(button==GLUT_RIGHT_BUTTON && state==GLUT_DOWN)
drawDot2(x,480-y);
if(button==GLUT_MIDDLE_BUTTON && state==GLUT_DOWN)
drawDot3(x,480-y);
}
void motion(int x,int y)
{
}

Dalam penerapan interaksi mouse pada OpenGL / glut, fungsi

inisialisasinya adalah sebagai berikut:
a. GLUT_LEFT_BUTTON
Fungsi inisialisasi ini bertujuan untuk inisialisasi button mouse kiri.
Jadi apabila kita ingin mengaktifkan fungsi penggunaan dari button
mouse sebelah kiri maka bisa menggunakan fungsi inisialisasi ini.

b. GLUT_RIGHT_BUTTON

Fungsi inisialisasi ini bertujuan untuk inisialisasi button mouse

kanan. Jadi apabila kita ingin mengaktifkan fungsi penggunaan dari
button mouse sebelah kanan maka bisa menggunakan fungsi inisialisasi
ini.

c. GLUT_MIDDLE_BUTTON
Fungsi inisialisasi ini bertujuan untuk inisialisasi button mouse
tengah. Jadi apabila kita ingin mengaktifkan fungsi penggunaan dari
button mouse tengah maka bisa menggunakan fungsi inisialisasi ini.

d. GLUT_DOWN
Fungsi inisialisasi ini adalah untuk inisialisasi ketika tombol mouse
ditekan.

e. GLUT_UP
Fungsi inisialisasi ini adalah untuk inisialisasi ketika tombol mouse
dilepaskan.

Kemudian pada main program perlu menambahkan fungsi untuk

callback fungsi MouseFunction.

38
 glutMouseFunc(mouse); glutMotionFunc(motion);

3. Sistem koordinat interaksi mouse pada Glut

Sistem koordinat interaksi mouse pada glut adalah sebagai berikut.
Misalnya ditentukan inisialisasi awal adalah:

int w = 480, h=480; float x=0, y=0, z=0;

Maka:
a. Titik 0,0 berada pada pojok kiri atas, koordinatnya akan berubah
apabila terjadi pergeseran mouse.
b. Titik 480,0 berada pada pojok kanan atas.
c. Titik 0, 480 berada pada pojok kiri bawah.
d. Titik 480,480 berada pada pojok kanan bawah.

A.2Langkah Langkah Membaut Program

1. Membuat program interaksi:
a. Keyboard
Header file (.h)
#include <stdlib.h>
#include <glut.h>
int c, d; void triAngles()
{
glBegin(GL_TRIANGLES);
glVertex2i(280, 0);
glVertex2i(250, 60);
glVertex2i(220, 0);
glEnd();
}
void mySpecialKeyboard(int key, int x, int y)
{
switch (key)
{
case
GLUT_KEY_LEFT: c += -4;
d += 0;
break;
case
GLUT_KEY_RIGHT: c += 4;
d += 0;
break;
case
GLUT_KEY_UP: c += 0; d += 4;
break;
case
GLUT_KEY_DOWN: c += 0;

39
 d += -4;
break;
}
}
void timer(int value)
{
glutPostRedisplay();
glutTimerFunc(50, timer, 0);
}

void renderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glTranslatef(c, d, 0);
triAngles();
glPopMatrix();
glFlush();
}

C++ File (.cpp)

#include "interaksikeyboard.h"
void main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitWindowPosition(100, 100);
glutInitWindowSize(300, 300);
glutCreateWindow("uji keyfunc");
gluOrtho2D(-320., 320., -240., 240.);
glutTimerFunc(50, timer, 0);
glutDisplayFunc(renderScene);
glutSpecialFunc(mySpecialKeyboard);
glutMainLoop();
}

Tabel 4.1 Fungsi OpenGL

No Fungsi Pengertian Contoh Penggunaan

1 glBegin Memulai glBegin

menggambar
(GL_TRIANGLES) (GL_TRIANGLES)
dalam bentuk
segitiga.

2 glVertex2i Suatu fungsi untuk glVertex2i(280, 0)

menggambar titik

40
 pada koordinat x
dan y, dengan nilai
satuan berupa
integer.

3 glEnd Mengakhiri glEnd()

penggambaran
sebuah garis.

4 glClear Menghapus glClear

window dan
(GL_COLOR_
memberikan warna
yang telah BUFFER_BIT)
didefinisikan
sebelumnya.

5 glPushMatrix Menyimpan glPushMatrix()

koordinat matrix
yang ada.

6 glTranslate(x,y,z) Parameter pertama, glTranslatef

kedua, dan ketiga
(c, d, 0)
masing-masing
menunjukkan
translasi
berdasarkan sumbu
x,y, dan z.

7 glPopMatrix Memanggil suatu glPopMatrix()

fungsi yang telah
disimpan pada
glPushMatrix.

8 glFlush Rendiring glFlush()

Hasil dari program

41
 Gambar 4.1 Hasil Program Interaksi Keyboard

b. Mouse
Header file (.h)
#include <stdlib.h>
#include <glut.h>
#include <stdio.h>

void Triangles()
{
glBegin(GL_TRIANGLES);
glVertex2i(0, 0);
glVertex2i(100, -30);
glVertex2i(100, 30);
glEnd();
}

void mouseku(int button, int state, int x, int y)

{
if (button == GLUT_LEFT_BUTTON)
{
printf("tombol KIRI (%d,%d)\n", x, y);
}
else if (button == GLUT_MIDDLE_BUTTON)
{
printf("tombol TENGAH (%d,%d)\n", x, y);

42
 }
else
{
printf("tombol KANAN (%d,%d)\n", x, y);
}
if (state == GLUT_DOWN){
printf("tombol DITEKAN\n");
}
else{
printf("tombol DILEPAS\n");
}
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT); glRotatef(10, 0., 0.,
1.);
Triangles();
glFlush();
}
void Timer(int value)
{
glutPostRedisplay();
glutTimerFunc(30, Timer, 0);
}

C++ File (.cpp)

#include "interaksimouse.h"
void main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_SINGLE |
GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(300, 300);
glutCreateWindow("coba");
glutDisplayFunc(display);
gluOrtho2D(-320.0, 320.0, -320.0, 320.0);
glutTimerFunc(10, Timer, 0);
glutMouseFunc(mouseku);
glutMainLoop();

Tabel 4.2 Fungsi OpenGL

No Fungsi Pengertian Contoh Penggunaan

1 glBegin Memulai menggambar glBegin

43
 (GL_TRIAGLES) dalam bentuk segitiga. (GL_TRIANGLES)

2 glVertex2i Suatu fungsi untuk glVertex2i(0, 0)

menggambar titik
pada koordinat x dan
y, dengan nilai satuan
berupa integer.

3 GlEnd Mengakhiri glEnd()

penggambaran sebuah
garis.

4 glClear Menghapus window GlClear

dan memberikan
(GL_COLOR_
warna yang telah
didefinisikan BUFFER_BIT)
sebelumnya.

5 glFlush Rendiring glFlush()

Hasil Dari Program

Gambar 4.2 Hasil Program Interaksi Mouse

A.3Kesimpulan

44
1. Pada program Interaksi Keyboard dan Interaksi Mouse, program akan akan
memanggil fungsi-fungsi pada Key yang ada di GLUT OpenGL.
2. Letak Objek dapat berpindah ketika ditekan tombol yang sudah di
konfigurasikan pada prosedur yang sudah dibuat .
3. Library OpenGL dapat menerapkan interaksi keyboard

Tanggal Asitensi Asisten Lab

Rendy Dimas Harianto

1518086

45
 PRATIKUM GRAFIKA KOMPUTER PERTEMUAN : 5

NIM : 1418074
NAMA : Mohammad Attoila Atijani Sulistyo
BAB : OBJEK 3D WireFrame
1. Pembuatan Objek 3D wireframe
MATERI :
2. Transformasi Objek 3D wireframe
: 1. Membuat Objek 3D wireframe diletakkan di pojok
TUGAS kanan atas
2. Membuat objek kubus menggunakan glVertex

5.1 Tujuan
1. Praktikan mampu memahami konsep Objek 3D wireframe pada openGL
2. Praktikan mampu membuat objek 3D wirefirme pada openGL
3. Praktikan mampu memahami interaksi perangkat keras dengan openGL
4. Praktikan mampu melakukan implementasi transformasi pada objek 3D
dengan OpenGL

5.2 Alat dan Bahan

1. Laptop
2. Microsoft Visual studio 2010
3. OpenGL 3.7.6
4. Modul Grafika Komputer 2017

5.3 Landasan Teori

1. Primitif Object 3D
Secara konseptual dalam grafika komputer objek 3 dimensi
dibuat dari rangkaian poligon. Poligon adalah sejumlah dari segmen garis
yang dihubungkan antara ujung garis satu dengan yang lainnya
membentuk suatu bidang tertutup. Objek 3 dimensi memiliki tiga ukuran
yaitu panjang, lebar dan kedalaman, dimana dalam geometri

46
 disimbolkan X, Y dan Z. Menurut fungsinya objek 3 dimensi
mempunyai dua variable bebas (X dan Y) dan satu variable tidak bebas
(Z, karena nilai Z tergantung pada nilai X dan Y). Objek 3 dimensi
diantaranya sebagai berikut (Multimedia, L. (2017). Modul Grafkom. Tim
Praktikum Grafika Komputer.) :

A. Kubus
Kubus adalah balok dengan bidang-bidang sisi yang bujur sangkar.
Batas-batas luar kubus membentuk poligon enam sisi (heksagonal).

B. Balok
Balok adalah poligon tiga sisi (heksagonal) beraturan dengan
bidang sisi terdiri dari dua buah persegi panjang dan dua buah bujur
sangkar.

C. Bola
Bentuk bola diperoleh dengan memutar busur ½ lingkaran melalui
sumbu yang melalui titik pusatnya.

5.4 Langkah-Langkah Membuat Program

1. Membuat objek 3D wireframe yang terdapat pada library openGL
Source Code cube.h :
#include<stdlib.h>
#include<glut.h>
float w=480,h=480;
float sudut = 0, sx = 0, sy = 0, sz = 0;
void cube(){
glColor3d(1, 0, 1);
glutWireCube(20);
}
void display(){
glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(-5, -5, -40);
glRotatef(sudut, sx, sy, sz);
cube();
glutSwapBuffers();
}
void init(){
glClearColor(1.0, 1.0, 1.0, 1.0);
glEnable(GL_DEPTH_TEST);

47
 glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45., (GLdouble)w / (GLdouble)h,1.,
300.);
glMatrixMode(GL_MODELVIEW);
}
void myKeyboard(unsigned char key, int x, int y){
if (key == 'x'){
sx = 1;
sy = 0;
sz = 0;
sudut += 10;
}
else if (key == 'y'){
sx = 0;
sy = 1;
sz = 0;
sudut += 10;
}
else if (key == 'z'){
sx = 0;
sy = 0;
sz = 90;
sudut += 10;
}
} void update(int value){
glutPostRedisplay();
glutTimerFunc(50, update, 0);
}

Source Code main.cpp :

#include "cube.h"
void main(int argc, char **argv){ glutInit(&argc,
argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH |
GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(w, h);
glutCreateWindow("Objek 3D");
glutDisplayFunc(display);
init();
glutTimerFunc(50, update, 0);
glutKeyboardFunc(myKeyboard);
glutMainLoop();
}

48
Tampilan hasil program :

Gambar 5.1 Hasil program objek 3D Wireframe

Tabel 5.1 Fungsi openGL

No Fungsi Pengertian Contoh Penggunaan
1 GlColor3d Memberikan glColor3d(1, 0, 1);
warna dengan
satuan desimal
glutWireCube Memanggil glutWireCube(20);
library wirecube
dengan
menentukan
ukuran panjang
sisi
2 GlClear Untuk glClear(GL_COLOR
menghapus _BUFFER_BIT);
window dan
memberikan
warna yang telah
kita definisakn
sebelumnya
dengan
menggunakan
glClearColor
3 glLoadIdentity Mereset project glLoadIdentity();
matriks yang
dibuat
4 glutSwapBuffers Menukar bagian
belakang buffer

49
 menjadi buffer
layar
5 glEnable() Untuk glEnable(GL_DEPT
menyalakan H_TEST);
fungs
6 glMatrixMode() Fungsi mode glMatrixMode(GL_
; proyeksi PROJECTION);
7 GlColor3d Untuk penentuan glColor3d(0,0,1);
suatu warna
8 glutPostRedispla mengirimkan glutPostRedisplay();
y perintah untuk
mengaktifkan
display secara
berkala (looping).
9 glTranslatef Membuat glTranslatef(2.0f,
perpindahan -2.0f, -40.0f);
tempat sebuah
objek
10. glRotatef Membuat sebuah glRotatef(sudut, sx,
perputaran objek sy, sz);
11. glEnable(GL_D Menampilkan glEnable(GL_DEPT
EPTH_TEST) objek yang H_TEST);
menutupi (objek
bagian depan)
12. gluPerspective Untuk mengatur gluPerspective(15.0f,
jarak objek itu aspect, 0.1f, 100.0f);
terlihat

2. Membuat Objek 3D kubus menggunakan glVertex

Source Code kubus.h :

#include <windows.h>
#include <glut.h>
char title[] = "KUBUS";
void initGL() {
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
}
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(2.0f, -2.0f, -10.0f);

glBegin(GL_QUADS);
// Top face (y = 1.0f)
// Define vertices in counter-clockwise (CCW)

50
order with normal pointing out
glColor3f(1.0f, 0.0f, 0.0f); // Green
glVertex3f( 1.f, 1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);

// Bottom face (y = -1.0f)

glColor3f(1.0f, 0.f, 1.0f); // Orange
glVertex3f( 1.0f, -1.0f, 1.0f);
glVertex3f(-1.0f, -1.0f, 1.0f);
glVertex3f(-1.0f, -1.0f, -1.0f);
glVertex3f( 1.0f, -1.0f, -1.0f);

// Front face (z = 1.0f)

glColor3f(1.0f, 1.0f, 0.0f); // Red
glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, -1.0f, 1.0f);
glVertex3f( 1.0f, -1.0f, 1.0f);

// Back face (z = -1.0f)

glColor3f(1.0f, 1.0f, 0.0f); // Yellow
glVertex3f( 1.0f, -1.0f, -1.0f);
glVertex3f(-1.0f, -1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f( 1.0f, 1.0f, -1.0f);

// Left face (x = -1.0f)

glColor3f(0.0f, 1.0f, 1.0f); // Blue
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f(-1.0f, -1.0f, -1.0f);
glVertex3f(-1.0f, -1.0f, 1.0f);

// Right face (x = 1.0f)

glColor3f(1.0f, 0.0f, 1.0f); // Magenta
glVertex3f(1.0f, 1.0f, -1.0f);
glVertex3f(1.0f, 1.0f, 1.0f);
glVertex3f(1.0f, -1.0f, 1.0f);
glVertex3f(1.0f, -1.0f, -1.0f);
glEnd(); // End of drawing color-cube

glutSwapBuffers();
}
void reshape(GLsizei width, GLsizei height) {
if (height == 0) height = 1;
GLfloat aspect = (GLfloat)width / (GLfloat)height;

glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);

51
 glLoadIdentity();
gluPerspective(45.0f, aspect, 0.1f, 100.0f);
}

Source Code main.cpp :

#include "KUBUS.h"
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE);
glutInitWindowSize(640, 480);
glutInitWindowPosition(50, 50);
glutCreateWindow(title);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
initGL();
glutMainLoop();
return 0;
}

52
Tampilan Hasil Running Program

Gambar 5.2. Hasil Running Objek 3D

Tabel 5.2. Fungsi OpenGL

No Fungsi Pengertian Contoh
Penggunaan
1 GlVertex3f Mebuat garis 3d Glvertex3f(2.0f,0.0
x,y,z dengan tipe f,-2.0f)
data float
2 GlClear Untuk menghapus glClear(GL_COL
window dan OR_BUFFER_BIT
memberikan warna );
yang telah kita
definisakn
sebelumnya dengan
menggunakan
glClearColor
3 GlBegin Untuk memmulai glBegin(GL_TRIA
menggambar dalam NGLES);
bentuk garis. Setiap
pasangan verteks
sebagai seg,em
garis independen
4 GlColor3f Untuk penentuan glColor3f(0,0,1);
suatu warna
5 GlEnd Untuk mengakhiri glEnd();
penggambaran
sebuah garis
6 GlFlush Rendiring glFlush();

53
7 Glint Untuk menentukan GLint x3 = 50;
tipe data integer
8 glPointSize mengatur besar glPointSize(10);
titik yang akan
digambar
9 glPushMatrix Menyimpan glPushMatrix();
koordinat Matrik
yang ada
10 glPopMatrix Berguna untuk glPopMatrix();
memanggil suatu
fungsi yang telah
disimpan pada
glPushMatrix
11 glutPostRedisplay mengirimkan glutPostRedisplay(
perintah untuk );
mengaktifkan
display secara
berkala (looping).
12. glTranslatef Membuat glTranslatef(2.0f,
perpindahan tempat -2.0f, -40.0f);
sebuah objek
13. glRotatef Membuat sebuah glRotatef(sudut,
perputaran objek sx, sy, sz);
14. glEnable(GL_DEP Menampilkan glEnable(GL_DEP
TH_TEST) objek yang TH_TEST);
menutupi (objek
bagian depan)
15. glViewport Untuk mengatur glViewport(0, 0,
pandangan atau width, height);
viewport
16. gluPerspective Untuk mengatur gluPerspective(15.
jarak objek itu 0f, aspect, 0.1f,
terlihat 100.0f);

54
5.5 Kesimpulan
1. Untuk membuat membuat objek tampak seperti 3D dengan menggunakan
OpenGL, terlebih dahulu harus membuat dan menentukan titik-titik
koordinat pada setiap sisi-sinya sehingga akan membentuk suatu objek.
2. Objek yang sudah terbentuk, maka harus diatur terlebih dahulu untuk
sudut perspektifnya.
3. Dengan menggunkan library glutWire() dapat membentuk semuah bangun
objek 3D

Nilai Asisten Lab

Rendy Dimas Harianto

1518086

55
 PRATIKUM GRAFIKA KOMPUTER PERTEMUAN : 6

NIM : 1418074
NAMA : Mohammad Attoila Atijani Sulistyo
BAB : Object Solid Dan Lighting
1. Pembuatan Object 3D Solid
MATERI : 2. Transformasi Object 3D Solid
3. Lighting Object 3D Solid
: Membuat Objek 3D Solid (Bumi, Bulan, Matahari, dan
TUGAS
ditambahkan 2 object planet)

6.1 Tujuan
1. Mampu memahami konsep Objek 3D solid pada openGL
2. Mampu membuat objek 3d solid pada openGL
3. Mampu melakukan implemntasi transformasi pada objek 3d dengan
OpenGL
4. Mampu memahami konsep lighting pada openGL
5. Mampu melakukan implementasi lighting objek 3d dengan opnGL

6.2 Alat dan Bahan

1. Laptop
2. Visual studio 2010
3. OpenGL 3.7.6
4. Modul Grafika Komputer 2017

6.3 Landasan Teori

1. Cahaya Ambient, Diffuse, dan Specular
Pencahayaan ambient adalah cahaya yang sudah berserakan begitu
banyak disebabkan oleh lingkungan dan arahnya tidak mungkin ditentukan
atau tampaknya datang dari segala penjuru. Backlighting pada sebuah
ruangan memiliki komponen ambient besar, karena sebagian besar cahaya
yang mencapai mata yang memantul dari banyak permukaan. Sebuah

56
 lampu sorot kecil di luar rumah memiliki komponen ambient, sebagian
besar cahaya dalam arah yang sama, dan karena diluar, sangat sedikit
cahaya mencapai mata setelah memantul dari benda-benda lain. Ketika
cahaya ambient menyerang permukaan, maka akan tersebar merata di
segala penjuru.
Komponen cahaya diffuse adalah komponen yang berasal dari satu
arah, jadi akan terang kalau hal tersebut terjadi tepat diatas sebuah
permukaan dibandingkan jika hampir tidak terjadi di atas permukaan.
Setelah mengenai permukaan, akan tersebar merata di segala penjuru,
sehingga tampak sama-sama terang, tak peduli di mana mata berada.
Setiap cahaya yang datang dari posisi atau arah tertentu mungkin memiliki
komponen diffuse.

Cahaya specular datang dari arah tertentu, dan cenderung terpental

pada permukaan dalam arah yang diinginkan. sinar laser berkualitas tinggi
memantul pada cermin dan menghasilkan hampir 100 persen refleksi
specular. Logam atau plastik mengkilap memiliki komponen specular
tinggi, dan kapur atau karpet telah hampir tidak ada. Specularity dapat
juga dianggap sebagai shininess. (Multimedia, Lab. (2017).

6.4 Langkah-Langkah Membuat Program

1. Membuat objek 3D Solid yang terdapat pada library openGL
Source Code tatasurya.h :
#include <stdlib.h>
#include <glut.h>
#include <math.h>
int shapeindex;
GLdouble cx, cy, cz; // Posisi kamera
GLdouble ry, rx; // Rotasi kamera terhadap sumbu y dan x
GLfloat bumi_y, bulan_y,mars_y,pluto_y;
void init(void) {
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1, 1, -1, 1, 1.8, 20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);

57
glEnable(GL_LIGHT0); // Aktifkan 3 sumber cahaya
bumi_y = 1;
bulan_y = 1;
mars_y = 1;
pluto_y = 1;
}
void display(void) {
GLfloat light_position[] = { -1.0, 0.0, 0.0, 1.0 };
GLfloat light_ambient[] = { 5.0, 5.0, 0.0, 0.0 };
GLfloat light_diffuse[] = { 0.5, 0.5, 0.5, 0.0 };
GLfloat light_specular[] = { 0.5, 0.5, 0.5, 0.0 };
GLfloat matahari_ambient[] = { 1.0, 1.0, 0.0, 0.0 };
GLfloat matahari_diffuse[] = { 0.0, 0.0, 0.0, 0.0 };
GLfloat matahari_specular[] = { 0.0, 0.0, 0.0, 0.0 };
GLfloat matahari_shininess[] = { 15.0 };
GLfloat bumi_ambient[] = { 0.0, 0.0, 2.0, 0.0 };
GLfloat bumi_diffuse[] = { 0.0, 0.0, 1.0, 0.0 };
GLfloat bumi_specular[] = { 0.0, 0.0, 0.3, 0.0 };
GLfloat bumi_shininess[] = { 15.0 };
GLfloat mars_ambient[] = { 1.0, 1.0, 3.0, 0.0 };
GLfloat mars_diffuse[] = { 0.0, 0.0, 2.0, 0.0 };
GLfloat mars_specular[] = { 0.0, 0.0, 0.4, 0.0 };
GLfloat mars_shininess[] = { 20.0 };
GLfloat pluto_ambient[] = { 1.0, -1.0, 3.0, 0.0 };
GLfloat pluto_diffuse[] = { 0.0, 0.0, 2.0, 0.0 };
GLfloat pluto_specular[] = { 0.0, 0.0, 0.4, 0.0 };
GLfloat pluto_shininess[] = { 20.0 };
GLfloat bulan_ambient[] = { 0.0, 0.0, 0.2, 0.0 };
GLfloat bulan_diffuse[] = { 1.0, 1.0, 1.0, 0.0 };
GLfloat bulan_specular[] = { 0.2, 0.2, 0.2, 0.0 };
GLfloat bulan_shininess[] = { 1.0 };
// Bersihkan layar
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(cx, cy, cz, 0, 0, 0, 0, 1, 0);
glRotatef(ry, 0.0, 1.0, 0.0);
glPushMatrix();
// gambar matahari
glMaterialfv(GL_FRONT, GL_AMBIENT, matahari_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, matahari_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, matahari_specular);
glMaterialfv(GL_FRONT, GL_SHININESS,
matahari_shininess);
glPushMatrix();
glutSolidSphere(0.4, 50, 50);
glPopMatrix();
//gambar bumi
glMaterialfv(GL_FRONT, GL_AMBIENT, bumi_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bumi_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, bumi_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, bumi_shininess);

58
glPushMatrix();
glRotatef(bumi_y, 0.0, 1.0, 0.0);
glTranslatef(2.3, 0.0, 0.0);
glutSolidSphere(0.2, 50, 50);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glPopMatrix();
//gambar mars
glMaterialfv(GL_FRONT, GL_AMBIENT, mars_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mars_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mars_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mars_shininess);
glPushMatrix();
glRotatef(mars_y, 0.0, 2.0, 0.0);
glTranslatef(3.5, 0.0, 0.0);
glutSolidSphere(0.2, 50, 50);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glPopMatrix();
//gambar pluto
glMaterialfv(GL_FRONT, GL_AMBIENT, pluto_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, pluto_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, pluto_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, pluto_shininess);
glPushMatrix();
glRotatef(pluto_y, 0.0, 4.0, 0.0);
glTranslatef(5.5, 0.0, 0.0);
glutSolidSphere(0.2, 50, 50);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glPopMatrix();
//gambar bulan
glMaterialfv(GL_FRONT, GL_AMBIENT, bulan_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bulan_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, bulan_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, bulan_shininess);
glRotatef(bumi_y, 0.0, 1.0, 0.0);
glTranslatef(2.3, 0.0, 0.0);
glRotatef(bulan_y, 0.0, 0.1, 0.0);
glTranslatef(0.5, 0.0, 0.0);
glutSolidSphere(0.05, 50, 50);
glPopMatrix();
glutSwapBuffers();
}
void animate(void) {

59
bumi_y += 1;
bulan_y += 1;
mars_y += 0.5;
pluto_y += 0.3;
glutPostRedisplay();
}
// Handle special key-press
void specialkey(int key, int x, int y) {
switch (key) {
case GLUT_KEY_UP:
rx += 1;
break;
case GLUT_KEY_DOWN:
rx -= 1;
break;
case GLUT_KEY_RIGHT:
ry += 1;
break;
case GLUT_KEY_LEFT:
ry -= 1;
break;
default:
break;
}
// Gambar kembali window
glutPostRedisplay();
}
void keyboard(unsigned char key, int x, int y) {
switch (key) {
case 'f': // Kamera lihat dari depan
case 'F':
cx = 0; cy = 0; cz = 5;
break;
case 'n': // Kamera lihat dari samping kanan
case 'N':
cx = 5; cy = 0; cz = 0;
break;
case 'l': // Kamera lihat dari depan-atas-kanan
case 'L':
cx = 5; cy = 3; cz = 2;
break;
default:
break;
}
// Gambar kembali window
glutPostRedisplay();
}

60
Source Code main.cpp :

#include "tatasurya.h"
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB |
GLUT_DEPTH);
glutInitWindowSize(600, 600);
glutInitWindowPosition(100, 100);
glutCreateWindow("Kehidupan");
init();
shapeindex = 1;
cx = 0; cy = 6; cz = 6;
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutSpecialFunc(specialkey);
glutIdleFunc(animate);
glutMainLoop();
return 0;
}

Tampilan hasil program :

61
 Gambar 6.1 Hasil program objek 3D Solid

Tabel 6.1 Fungsi openGL

No Fungsi Pengertian Contoh Penggunaan
1 GlColor3d Memberikan glColor3d(1, 0, 1);
warna dengan
satuan decimal
glShademodel glutWireCube(20);
2 GlClear Untuk menghapus glClear(GL_COLO
window dan R_BUFFER_BIT);
memberikan
warna yang telah
kita definisakn
sebelumnya
dengan
menggunakan
glClearColor
3 glLoadIdentity Mereset project glLoadIdentity();
matriks yang
dibuat
4 glutSwapBuffers Menukar bagian
belakang buffer
menjadi buffer
layar
5 glEnable() Untuk glEnable(GL_DEPT
menyalakan fungs H_TEST);
6 glMatrixMode(); Fungsi mode glMatrixMode(GL_
proyeksi PROJECTION);
7 GlColor3d Untuk penentuan glColor3d(0,0,1);
suatu warna
8 glutPostRedisplay mengirimkan glutPostRedisplay();
perintah untuk
mengaktifkan
display secara
berkala (looping).
9 glTranslatef Membuat glTranslatef(2.0f,
perpindahan -2.0f, -40.0f);
tempat sebuah
objek

62
 10. glRotatef Membuat sebuah glRotatef(sudut, sx,
perputaran objek sy, sz);
11. glEnable(GL_DEP Menampilkan glEnable(GL_DEPT
TH_TEST) objek yang H_TEST);
menutupi (objek
bagian depan)
12. gluPerspective Untuk mengatur gluPerspective(15.0f,
jarak objek itu aspect, 0.1f, 100.0f);
terlihat

6.5 Kesimpulan
1. Pembuatan ruang atau solid terhadap suatu object 3D yang sudah dibuat.
2. Objek yang sudah terbentuk, maka harus dia atur terlebih dahulu untuk
sudut perspektifnya.
3. Object yang sudah terbentuk maka akan dibuat menjadi object yang
mempunyai sebuah ruang atau disebut Solid.

Nilai Asisten Lab

Rendy Dimas Harianto

1518086

63
 DAFTAR PUSTAKA

andini, diyah. 2011. OpenGL. Jakarta : Gandum Mas.

Tim Praktikum Grafika Komputer. 2016. Modul Grafkom. Laboratorium

Multimedia dan Pengolahan Citra. Institut Teknologi Nasional Malang.

Pengantar Pemrograman OpenGL. (2014, 05). Diambil kembali dari Pengantar

Pemrograman OpenGL: http://faqihshofyan.co.id/2014/05/pengantar-
pemrograman-opengl-di.html Diakses 6 April 2017 pukul 20:04.

Ms, Maulana Candra. 2012. Transformasi Objek dalam Grafika Komputer.

http://anandaboengsoe.co.id/2012/12/transformasi-objek-dalam-grafika_17.html
Diakses tanggal 7 April 2017 pukul 22:09

64