Page 1

Laporan Praktikum
Komputer Grafik



NAMA PRAKTIKAN
NOMOR
MAHASISWA
TANGGAL
KUMPUL
TANDA TANGAN
PRAKTIKAN
FANI ADIANI 1214370424


NAMA PENILAI
TANGGAL
KOREKSI
NILAI
TANDA TANGAN
DOSEN
INDRI SULISTIANINGSIH,
S.KOM



Jurusan Teknik Informatika
Fakultas Teknik
Universitas Pembangunan Panca Budi Medan
2014

KELAS
SK 4B SORE


Page 2


DAFTAR ISI
DAFTAR ISI ..................................................................................................................... 2
KATA PENGANTAR ....................................................................................................... 3
BAB I PENDAHULUAN ................................................................................................. 4
1.1 Umum ............................................................................................................... 4
1.2 Latar Belakang .................................................................................................. 5
1.3 Tujuan Praktikum .............................................................................................. 6
BAB II LANDASAN TEORI ............................................................................................ 7
BAB III PRAKTIKUM ...................................................................................................... 9
3.1 Latihan Fungsi Primitif Drawing ....................................................................... 9
a) Garis ......................................................................................................... 9
b) Segitia Sama Kaki ................................................................................... 11
3.2 Latihan Fungsi Dua Dimensi (2D) .................................................................... 13
a) Bunga Pot ................................................................................................ 13
b) Monas ...................................................................................................... 18
c) Segi Empat ............................................................................................... 25
3.3 Latihan Fungsi Tiga Dimensi (3D) .................................................................... 27
a) Point to Vector ......................................................................................... 27
b) The Cube World ...................................................................................... 36
BAB IV ANALISA.............................................................................................................. 44
BAB V PENUTUP .............................................................................................................. 45
5.1 Kesimpulan ........................................................................................................ 45
5.2 Saran .................................................................................................................. 45
5.3 Hasil Aplikasi .................................................................................................... 46
DAFTAR PUSTAKA .......................................................................................................... 48






Page 3


KATA PENGANTAR

Puji dan Syukur penulis panjatkan kepada Allah SWT yang mana karena rahmat dan
hidayahNya penulis dapat menyelesaikan laporan praktikum sesuai dengan waktu yang telah
ditetapkan sebagai syarat tugas akhir praktikum pada mata kuliah Komputer Grafik dengan
judul Laporan Praktikum Komputer Aplikasi Menggunakan OpenGL.
Rasa dan ucapan terima kasih penulis sampaikan kepada pihak yang telah membantu
dalam penyusunan laporan ini, pihak yang penulis ucapkan terima kasih adalah :
1. Ibu Indri Sulistianingsih S.Kom selaku dosen pembimbing mata kuliah
komputer grafik.
2. Semua pihak yang ikut dalam penyusunan laporan praktikum ini.

Demikian laporan praktikum ini dibuat, semoga Allah SWT memberikan balasan yang
berlipat ganda kepada semuanya. Demi perbaikan selanjutnya, saran dan kritik yang
membangun akan penulis terima dengan senang hati. Akhirnya, hanya kepada Allah SWT
penulis serahkan segalanya mudah-mudahan dapat bermanfaat khususnya bagi penulis
umumnya bagi kita semua.




Medan, 9 Juni 2014

Penulis





Page 4


BAB I
PENDAHULUAN

1.1 Umum
Grafik Komputer adalah suatu bidang ilmu yang mempelajari bagaimana membangun
grafik (gambar), memanipulasi gambar (visual) secara digital baik 2 dimensi maupun 3
dimensi sehingga kelihatan nyata menggunakan komputer. Grafika komputer meliputi
gambar dan pencitraan lain yang dihasilkan komputer berbentuk garis, lengkungan, kurva dan
lain sebagainya.
OpenGL (Open Graphics Library) adalah standar API yang dapat digunakan untuk
membuat aplikasi grafik, baik dua dimensi (2D) maupun tiga dimensi (3D). OpenGL ini
bersifat cross-platform, artinya dapat dijalankan pada berbagai platform sistem operasi yang
ada saat ini.
OpenGL menyediakan set perintah untuk menggambar dan semua penggambaran
yang lebih tinggi tingkatnya harus dilakukan dengan mengambil fungsi dasar dari perintah
ini. Maka dari itu dapat dibuat library itu sendiri di atas program OpenGL yang
mempermudah pemrograman lebih lanjut. Fungsi asli dari OpenGL sendiri selalu diawali
dengan gl yang terdapat pada library opengl32.dll dan file header gl.h. Sedangkan beberapa
library yang telah ditulis untuk menyediakan fungsi-fungsi tambahan pada OpenGL adalah :
1. OpenGL Utility Library (GLU) yang didalamnya terdapat sejumlah rutin yang
menggunakan level bawah dari perintah OpenGL. Rutin-rutin ini mempunyai awalan
glu. Library ini digunakan sebagai bagian dari implementasi OpenGL.
2. OpenGL Extension untuk X-Windows yang menyediakan fungsi untuk
menciptakan OpenGL context dan mengasosiasikannya dengan mesin yang
menggunakan XWindows. Rutin-rutin ini mempunyai awalan glx.
3. Auxiliary atau aux library terdapat pada library glaux.lib dan file header glaux.h.
Perintah yang akan digunakan selalu menggunakan awalan aux .
4. OpenGL Utility Toolkit (GLUT) adalah toolkit untuk sistem windows yang ditulis
oleh Mark Kilgard untuk menyembunyikan perintah API sistem windows yang
kompleks.


Page 5


Yang digunakan kali ini adalah GLUT (OpenGL Utility Toolkit), GLUT dipilih
karena di dalamnya terdapat banyak fungsi yang dapat dipakai untuk pembuatan application
window. Disamping itu, windowing pada GLUT juga bersifat independen terhadap sistem
operasi, sehingga tidak perlu repot-repot untuk mengubah kode program jika diterapkan pada
sistem operasi yang berbeda.

1.2 Latar Belakang
Digital Image Processing, Komputer Grafik, Analisis dan Computer telah
dikembangkan dan diaplikasikan dengan mengesankan selama beberapa dekade. Dimana
perkembangan aplikasi-aplikasi yang menggunakan disiplin ilmu telah memimpin teknologi
di beberapa bidang seperti komunikasi digital dan internet, penyiaran (broadcasting), alat
kedokteran, sistem multimedia, biologi, ilmu pengetahuan material, robot dan manufaktur,
sistem intelligent sensing, remote sensing, seni grafik dan proses print. Pertumbuhan yang
pesat ini direfleksikan dengan diterbitkannya paper di jurnal ilmiah internasional setiap
tahunnya dan diluncurkannya buku-buku tentang Pemrosesan Image Digital dan Komputer
Grafik.
Grafik komputer dua dimensi (2D) adalah pembuatan objek gambar dengan
menggunakan dua titik sebagai acuannya, yaitu sumbu x dan y. Karakteristik pada grafik
komputer 2D adalah terlihat dari tampilan objeknya yang datar, tidak beruang, berupa
struktur garis dan tampilan frame layarnya terbatas. Dalam grafika komputer, objek 2D
memiliki keunggulan di antaranya adalah kemudahan dalam membuat gambar dan tidak
memerlukan waktu banyak untuk meresource.
Selain itu, objek 2D juga memiliki kelemahan, yaitu gambar terlihat biasa saja, belum
mendukung bentuk-bentuk 3D atau fenomena yang bersifat tiga dimensi, seperti
pencahayaan, bayangan, pantulan, refraksi, dan sebagainya. Macam-macam objek 2D di
antaranya, line, circle, arc, polygon, text, section, rectangle, ellips, donut, star, dan helix.
Riset-riset mengenai cara mempermudah memvisualisasikan ide atau data secara lebih
cepat dan akurat telah banyak dilakukan, khususnya teknologi visualisasi tiga dimensi (3D)
telah mengalami perkembangan yang sangat pesat, misalnya dengan diciptakan teknologi
motion capture, menggerakan objek 3D menjadi lebih mudah, facial capture membuat
animasi ekspresi wajah menjadi lebih mudah dan akurat, scanner 3D membuat proses


Page 6


pemodelan objek tiga dimensi (3D) menjadi lebih cepat dan akurat, software-software
authoring tiga dimensi yang lengkap dengan objek-objek 3D mempercepat desain suatu
model objek tiga dimensi.
Namun pada umumnya software-software authoring tiga dimensi tersebut tidak
mendukung representasi visual tiga dimensi (3D), maka perlu proses render yang cukup
memakan waktu sebelum hasil akhirnya bisa dilihat.
Ada 3 file penting dalam OpenGL yang akan digunakan dalam sistem operasi
MSWindows, yaitu glut.h, glut32.lib dan glut32.dll. Dimana masing-masing file OpenGL
tersebut akan diinstal kedalam Windows, adapun cara penginstalannya sebagai berikut:
Letakkan glut.h di direktori include pada Visual C (vc98/include/GL)
Letakkan glut32.lib di direktori lib pada Visual C (vc98/lib)
Letakkan glut32.dll di direktori windows/system
OpenGL tersebut harus sudah terinstal kedalam komputer apabila di dalam komputer
tidak terdapat OpenGL maka hasil gambar tidak akan dapat terlihat meskipun listing program
yang telah dibuat didalam C++ telah sukses (jalan). Oleh karena itu OpenGL tersebut harus
sudah terinstal agar hasil gambar tersebut dapat terlihat.


1.3 Tujuan Praktikum
1. Membuat objek primitive drawing
2. Mengembangkan beberapa objek dasar menjadi objek 2D hingga 3D
3. Membuat objek dua dimensi (2D)
4. Membuat objek tiga dimensi (3D)









Page 7


BAB II
LANDASAN TEORI

2.1 Landasan Teori
Grafika Komputer adalah suatu bidang ilmu yang mempelajari bagaimana
membangun grafik(gambar), memanipulasi gambar (visual) secara digital baik 2 dimensi
maupun 3 dimensi yang keliatan nyata menggunakan komputer. Grafika komputer meliputi
gambar dan pencitraan lain yang dihasilkan komputer berbentuk garis, lengkungan, kurva,
dan lain sebagainya.
Bagian dari grafika komputer meliputi:
Geometri: mempelajari cara menggambar permukaan bidang
Animasi: mempelajari cara menggambarkan dan memanipulasi gerakan
Rendering: mempelajari algoritma untuk menampilkan efek cahaya
Citra (Imaging): mempelajari cara pengambilan dan penyuntingan gambar

Salah satu bidang grafika komputer yang sangat terkenal adalah design grafis.
Beberapa penerapan grafika komputer sebagai berikut:
1) Entertainment
Misalnya dalam pembuatan animasi pada film Terminator 2 dan Titanic
merupakan contoh film non animasi yang memanfaatkan efek-efek dari grafika
komputer yang sangat canggih.
2) Visualisasi Proses
Misalnya menggambarkan layout kinerja proses public atau proses-proses yang
dalam modul saja.
3) Visualisasi Hasil Penelitian
Visualisasi hasil penelitian ini seperti menggambar perfomers grafik perubahan
bahkan grafik model hasil implementasi program.
4) Image Prosesi
Image Prosesi digunakan sebagai algoritma identifikasi seperti yang dilakukan
pada kepolisian untuk menggambar wajah seseorang dan identifikasi seseorang.
5) GIS ( Geografic Information Sytem).



Page 8


Adapun macam-macam gambar komputer yang mana disetiap jenisnya memiliki
sturktur yang berbeda sehingga disetiap gambar memiliki penggunaan atau pemanfaatan pada
grafika komputer yang berbeda, yakni:
a. Raster Image
Raster Image adalah gambar yang strukturnya berupa matrik, dimana setiap titik (x,y)
mempunyai nilai berupa warna sesuai dengan model warna yang digunakan seperti
RGB/CYMK. File dengan ekstensi (.BMP), (.Gif), (.Tiff), (.JPG), (.PNG) itu
merupakan contoh dari RASTER IMAGE. Model gambar semacam ini digunakan
emage processing.
b. Vektor Image
Vektor image adalah gambar yang strukturnya berupa vector gambar yang dibuat
menggunakan AutoCad / maya atau gambar-gambar pada GIS merupakan contoh dari
Vektor Image. Model gambar semacam ini digunakan dalam grafika komputer dan
GIS.
















Page 9


BAB III
PRAKTIKUM

3.1 Latihan Fungsi dari Primitive drawing
Beberapa objek yang dihasilkan dari fungsi primitive drawing, sebagai berikut:
a) Garis

List Programnya:
#include <GL/glut.h>
void userdraw()
{
static int tick=0;
void drawline(int x1,int x2, int y1,int y2);
glBegin(GL_LINES);
glVertex2i(100,100);
glVertex2i(200,150);
glEnd();

Page
10


}
void display(void)
{
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);//Inisialisasi Toolkit
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
glutCreateWindow("GARIS");
glClearColor(0.0,0.0,0.0,0.0);
gluOrtho2D(0.,640.,-240.,240.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}


Page
11


b) Segitiga Sama Kaki







List programnya:
#include <GL/glut.h>
void display(void)
{
/* bersihkan layar dari titik pixel yang masih ada */
glClear (GL_COLOR_BUFFER_BIT);
/* gambar poligon (rectangle) dengan titik sudut *
* (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0) */
glColor3f (1.0, 1.0, 0.0);

/////////pembentuk segitiga sama kaki/////
glBegin(GL_LINE_LOOP);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (0.3, 0.8, 0.0);
glVertex3f (0.6, 0.0, 0.0);

Page
12


glEnd();
/////////pembentuk segitiga sama kaki///////

glFlush (); }
void kunci(unsigned char key, int x, int y) {
switch (key) {
case 27 : case 'q': exit(0); break; } glutPostRedisplay(); }
int main(int argc, char *argv[]) {
glutInitWindowSize(200,200);
glutInitWindowPosition(100,100);
glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
glutCreateWindow("Fani Adiani");
glutDisplayFunc(display);
glutKeyboardFunc(kunci);
glutMainLoop();
return 0;
}







Page
13


3.2 Latihan Fungsi dari Dua Dimensi (2D)
Grafik Dua Dimensi adalah merupakan sekumpulan titik-titik dua dimensi yang
dihubungkan dengan garis lurus baik berupa Polyline, polygon atau kurva.
Berikut beberapa objek dua dimensi (2D), yakni:
a). Bunga Pot







List programnya:
#include <GL/glut.h>
#include <math.h>

typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;

Page
14


}color_t;
void setColor (color_t col)
{
glColor3f(col.r, col.g, col.b);
}
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_POLYGON);
for (i=0; i<n; i++)
{
glVertex2i(pnt[i].x,pnt[i].y);
}
glEnd();
}
void fillPolygon (point2D_t pnt[], int n, color_t color)
{
int i;
setColor(color);
glBegin(GL_POLYGON);
for (i=0; i<n; i++)
{
glVertex2f(pnt[i].x, pnt[i].y);

Page
15


}
glEnd();
}
void userdraw()
{
point2D_t
batang[4]={{-5,-190},{-5,0},{5,0},{5,-190}};
color_t biru ={1,1,1};
fillPolygon(batang,4, biru);
drawPolygon(batang,4);

point2D_t
pot[4]={{-60,-190},{60,-190},{30,-240},{-30,-240}};
color_t hitam ={0,0,0};
fillPolygon(pot,4, hitam);
drawPolygon(pot,4);

point2D_t
pot2[6]={{-80,-160},{-50,-160},{-50,-190},{-60,-190},{-60,-170},{-80,-170}};
color_t hitam3 ={0,0,0};
fillPolygon(pot2,4, hitam3);
drawPolygon(pot2,4);


Page
16


point2D_t
pot3[6]={{80,-160},{50,-160},{50,-190},{60,-190},{60,-170},{80,-170}};
color_t hitam2 ={0,0,0};
fillPolygon(pot3,4, hitam2);
drawPolygon(pot3,4);

static int tick=0;
point2D_t shape[360];
double srad,r;
for(int s=0; s<360; s++)
{
srad =(s+tick)*3.14/360;
r=80*sin(200*srad);
shape [s].x = (float)(r*cos(100*srad));
shape [s].y = (float)(r*sin(100*srad));
color_t merah ={1,0,0};
fillPolygon(shape,1, merah);
}
drawPolygon(shape, 360);
}
void display(void)
{
//clear screen

Page
17


glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
//posisi layar
glutInitWindowPosition(150,150);
//ukuran layar
glutInitWindowSize(640,480);
//title windows
glutCreateWindow("Bunga Raflesia");
//warna back layar
glClearColor(0.0,1.0,0.1,0.0);
gluOrtho2D(-300.,400.,-300.,300.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}


Page
18


b). Monas








List programnya:
#include <GL/glut.h>
typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;
}color_t;
void setColor(color_t col)
{
glColor3f(col.r, col.g, col.b);
}

Page
19


void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i<n; i++)
{
glVertex2i(pnt[i].x,pnt[i].y);
}
glEnd();
}
void fillpolygon(point2D_t pnt[],int n,color_t color)
{
int i;
setColor(color);
glBegin(GL_POLYGON);
for (i=0; i<n; ++i)
{ glVertex2f(pnt[i].x, pnt[i].y);
}
glEnd();
}
void userdraw(void)
{
point2D_t

Page
20


petakdasar[4]={{0,0},{0,80},{350,80},{350,0}};
color_t hijau ={0,1,0};
fillpolygon(petakdasar, 4, hijau);
drawPolygon(petakdasar,4);
point2D_t
tangga[4]={{10,10},{50,50},{310,50},{340,10}};
color_t merah ={1,0,0};
fillpolygon(tangga, 4, merah);
drawPolygon(tangga,4);
point2D_t
petaktengah1[4]={{110,50},{100,70},{260,70},{250,50}};
color_t kuning ={1,1,0};
fillpolygon(petaktengah1, 4, kuning);
drawPolygon(petaktengah1,4);
point2D_t
petaktengah2[4]={{100,70},{80,90},{280,90},{260,70}};
color_t kuning2 ={1,1,0};
fillpolygon(petaktengah2, 4, kuning2);
drawPolygon(petaktengah2,4);
point2D_t
petaktengah3[4]={{80,90},{70,110},{290,110},{280,90}};
color_t kuning3 ={1,1,0};
fillpolygon(petaktengah3, 4, kuning3);

Page
21


drawPolygon(petaktengah3,4);
point2D_t
batang2[4]={{160,510},{160,530},{200,530},{200,510}};
color_t hitam4 ={0,0,0};
fillpolygon(batang2, 4, hitam4);
drawPolygon(batang2,4);
point2D_t
batang[4]={{150,120},{170,520},{190,520},{210,120}};
color_t putih2 ={1,1,1};
fillpolygon(batang, 4, putih2);
drawPolygon(batang,4);
point2D_t
petaktengah4[4]={{70,110},{70,120},{290,120},{290,110}};
color_t hitam3 ={0,0,0};
fillpolygon(petaktengah4, 4, hitam3);
drawPolygon(petaktengah4,4);
point2D_t
segitiga[3]={{170,530},{180,580},{190,530}};
color_t kuning4 ={1,1,0};
fillpolygon(segitiga, 3, kuning4);
drawPolygon(segitiga,3);



Page
22


point2D_t
bayangbatang[4]={{160,530},{160,535},{200,535},{200,530}};
color_t putih3 ={1,1,1};
fillpolygon(bayangbatang, 4, putih3);
drawPolygon(bayangbatang,4);
point2D_t
bayangbatang2[4]={{200,510},{200,535},{203,535},{203,510}};
color_t putih4 ={1,1,1};
fillpolygon(bayangbatang2, 4, putih4);
drawPolygon(bayangbatang2,4);
point2D_t
tanggatgh1[4]={{140,10},{140,50},{150,50},{150,10}};
color_t hitam ={0,0,0};
fillpolygon(tanggatgh1, 4, hitam);
drawPolygon(tanggatgh1,4);
point2D_t
tanggatgh2[4]={{210,10},{210,50},{220,50},{220,10}};
color_t hitam2 ={0,0,0};
fillpolygon(tanggatgh2, 4, hitam2);
drawPolygon(tanggatgh2,4);
point2D_t
tangga2[4]={{10,10},{50,50},{310,50},{340,10}};
drawPolygon(tangga2,4);

Page
23


point2D_t
petaktengah11[4]={{110,50},{100,70},{260,70},{250,50}};
drawPolygon(petaktengah11,4);
point2D_t
petaktengah22[4]={{100,70},{80,90},{280,90},{260,70}};
drawPolygon(petaktengah22,4);
point2D_t
petaktengah33[4]={{80,90},{70,110},{290,110},{280,90}};
drawPolygon(petaktengah33,4);
point2D_t
batang3[4]={{150,120},{170,520},{190,520},{210,120}};
drawPolygon(batang3,4);
point2D_t
anaktangga[4]={{150,40},{150,45},{210,45},{210,40}};
drawPolygon(anaktangga,4);
point2D_t
anaktangga2[4]={{150,30},{150,35},{210,35},{210,30}};
drawPolygon(anaktangga2,4);
point2D_t
anaktangga3[4]={{150,20},{150,25},{210,25},{210,20}};
drawPolygon(anaktangga3,4);
point2D_t
anaktangga4[4]={{150,10},{150,15},{210,15},{210,10}};

Page
24


drawPolygon(anaktangga4,4);
}
void display(void)
{
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);//Inisialisasi Toolkit
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(500,640);
glutCreateWindow("MONUMEN NASIONAL JAKARTA");
glClearColor(0.0,0.0,1.0,0.0);
gluOrtho2D(0.,350.,-5.,600.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Page
25


c). Persegi Empat








List programnya:
#include <stdio.h> //Mengakses file library stdio.h
#include <stdlib.h> //Mengakses file library stdlib.h
#include <string.h> //Mengakses file library string.h
#include <stdarg.h> //Mengakses file library stdarg.h
#include <GL/glut.h> //Mengakses file library glut.h
void mydisplay(){
glClear(GL_COLOR_BUFFER_BIT); //Menghapus layar
glBegin(GL_POLYGON); //Memanggil fungsi openGL Geometric Primitive
glColor3f(1,0,0); //Untuk memberi warna biru
glVertex2f(-0.5, -0.5); //Vertex 2 dimensi
glVertex2f(-0.5, 0.5);
glVertex2f(0.5, 0.5);
glVertex2f(0.5, -0.5);

Page
26


glEnd();
glFlush();
}
void reshape( int w, int h ) // fungsi reshape
{
if (w >= h)
glViewport(0, 0, (GLsizei)h, (GLsizei)h) ;
else
glViewport(0, 0, (GLsizei)w, (GLsizei)w) ;
}

int main(int argc, char** argv)
{
printf("Hello World this is 2D Rectangle"); //Output berupa text
glutCreateWindow("Fani Adiani"); //Memberi nama untuk file yang akan di run
glutDisplayFunc(mydisplay);
glutReshapeFunc(reshape); //Memanggil fungsi reshape
glutMainLoop();
}





Page
27


3.3 Latihan Fungsi dari Tiga Dimensi (3D)
Grafik Komputer 3D merupakan perkembangan dari grafik 2D. Istilah atau Pengertian
Grafik 3D adalah sebuah gambar,garis,lengkungan,dan sebagainya yang memiliki titik-titik
yang menghubungkan menjadi sebuah bentuk 3D.
Berikut beberapa objek dari grafik tiga dimensi (3D), yakni:
a. Point to Vektor

Dapat dilihat pada gambar di bawah bahwa objek kubus tersebut bergerak:







List Programnya:
#include <GL/glut.h>
#include <math.h>
struct point {
float x,y,z;
};
struct vektor {
float v[4];
};

Page
28


struct matriks {
float m[4][4];
};
struct face {
int jumtitikons;
int indextitik[40];
};
struct objek {
int jumtitik;
point titik[40];
int jumsisi;
face sisi[30];
};
matriks mat;
float theta=0.5;
vektor point2vektor(objek balok, int i) {
vektor vec;
vec.v[0] = balok.titik[i].x;
vec.v[1] = balok.titik[i].y;
vec.v[2] = balok.titik[i].z;
vec.v[3] = 1;
return vec;
}

Page
29


point vektor2point(vektor vec) {
point pnt;
pnt.x = vec.v[0];
pnt.y = vec.v[1];
pnt.z = vec.v[2];
return pnt;
}
matriks identitas(void) {
int i,j;
matriks mat;
for (i=0;i<4;i++) {
for (j=0;j<4;j++) {
if (i==j)
mat.m[i][j] = 1;
else
mat.m[i][j] = 0;
}
}
return mat;
}
matriks translasi(float dx, float dy, float dz) {
matriks trans = identitas();
trans.m[0][3] = dx;

Page
30


trans.m[1][3] = dx;
trans.m[2][3] = dx;
return trans;
}
matriks rotasiX(float theta) {
matriks rotate = identitas();
float cs = cos(theta);
float sn = sin(theta);
rotate.m[1][1] = cs;
rotate.m[1][2] = -sn;
rotate.m[2][1] = sn;
rotate.m[2][2] = cs;
return rotate;
}
matriks rotasiY(float theta) {
matriks rotate = identitas();
float cs = cos(theta);
float sn = sin(theta);
rotate.m[0][0] = cs;
rotate.m[0][2] = sn;
rotate.m[2][0] = -sn;
rotate.m[2][2] = cs;
return rotate;

Page
31


}
matriks rotasiZ(float theta) {
matriks rotate = identitas();
float cs = cos(theta);
float sn = sin(theta);
rotate.m[0][0] = cs;
rotate.m[0][1] = -sn;
rotate.m[1][0] = sn;
rotate.m[1][2] = cs;
return rotate;
}
vektor kali (matriks mat, vektor b) {
int i,j;
vektor c;
for (i=0;i<4;i++) {
c.v[i] = 0;
for (j=0;j<4;j++) {
c.v[i]+= mat.m[i][j] * b.v[j];
}
}
return c;
}
matriks kalim (matriks a, matriks b) {

Page
32


int i,j,k;
matriks c;
for (i=0;i<4;i++) {
for (j=0;j<4;j++) {
c.m[i][j] = 0;
for (k=0;k<4;k++) {
c.m[i][j]+=a.m[i][k] * b.m[k][j];
}
}
}
return c;
}
matriks titling = kalim(rotasiX(theta),rotasiY(-theta));
vektor cross (vektor a, vektor b) {
vektor c;
c.v[0] = a.v[1]*b.v[2]-a.v[2]*b.v[1];
c.v[1] = a.v[2]*b.v[0]-a.v[0]*b.v[2];
c.v[2] = a.v[0]*b.v[1]-a.v[1]*b.v[0];
c.v[3] = 1;
return c;
}
void DrawPolygon(objek obj)
{

Page
33


int i,j;
float r,g,b;
for(i=0;i<obj.jumsisi;i++)
{
r=1.0f; g=0.0f; b=0.0f;
glBegin(GL_LINE_LOOP);
if (i==0) { r=1.0f; g=0.0f; b=0.0f; }
if (i==1) { r=0.0f; g=1.0f; b=0.0f; }
if (i==2) { r=0.0f; g=0.0f; b=1.0f; }
if (i==3) { r=1.0f; g=1.0f; b=0.0f; }
if (i==4) { r=1.0f; g=0.0f; b=1.0f; }
if (i==5) { r=0.0f; g=1.0f; b=1.0f; }
if (i==6) { r=0.5f; g=0.0f; b=1.0f; }
if (i==7) { r=0.5f; g=0.5f; b=0.5f; }
glColor3f(r,g,b);
for(j=0;j<obj.sisi[i].jumtitikons;j++)
{
glVertex3f(obj.titik[obj.sisi[i].indextitik[j]].x,
obj.titik[obj.sisi[i].indextitik[j]].y,
obj.titik[obj.sisi[i].indextitik[j]].z);
}
glEnd();
}

Page
34


}
void gambarbalok() {
int i;
vektor hasil,HslKali;
point HslTitik;
mat = titling;
objek balok =
{8,{{10,15,30},{30,15,30},{30,15,10},{10,15,10},{10,30,30},{30,30,30},{30,30,10},{10,30
,10
}},
6,{{4,{0,1,5,4}},{4,{3,2,6,7}},{4,{0,3,7,4}},{4,{1,2,6,5}},{4,{0,1,2,3}},{4,{4,5,6,7}}}};
for (i=0;i<8;i++) {
hasil = point2vektor(balok,i);
HslKali = kali(mat,hasil);
HslTitik = vektor2point(HslKali);
balok.titik[i] = HslTitik;
}
DrawPolygon(balok);
}
void UserDraw() {
glClearColor(1.0f,1.0f,1.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glRotatef(0.1f,0.0f,1.0f,0.0f);

Page
35


gambarbalok();
glutSwapBuffers();
}
void main(int argc,char **argv) {
glutInit(&argc,argv);
glutInitWindowPosition(20,20);
glutInitWindowSize(640,640);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutCreateWindow("Point To Vektor");
glOrtho(-100.0f,100.0f,-100.0f,100.0f,-100.0f,100.0f);
glutIdleFunc(UserDraw);
glutDisplayFunc(UserDraw);
glutMainLoop();
}










Page
36


b. The Cube World







List Programnya:
#include <windows.h>
#include <gl\gl.h>
#include <gl\glut.h>
#include <gl\glu.h> /* GLU extention library */
void init(void);
void display(void);
void keyboard(unsigned char, int, int);
void resize(int, int);
void drawcube(int, int, int);
int is_depth; /* depth testing flag */
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

Page
37


glutInitWindowSize(600, 600);
glutInitWindowPosition(40, 40);
glutCreateWindow("The Cube World");
init();
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
/* this time we're going to keep the aspect ratio
constant by trapping the window resizes */
glutReshapeFunc(resize);
glutMainLoop();
return 0;
}
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
is_depth = 1;
glMatrixMode(GL_MODELVIEW);
}
void display(void)
{
if (is_depth)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Page
38


else
glClear(GL_COLOR_BUFFER_BIT);
/* draw the floor */
glBegin(GL_QUADS);
glColor3f(0.2f, 0.2f, 0.2f);
glVertex3f(-100.0, 0.0, -100.0);
glColor3f(0.4f, 0.4f, 0.4f);
glVertex3f(-100.0, 0.0, 100.0);
glColor3f(0.6f, 0.6f, 0.6f);
glVertex3f(100.0, 0.0, 100.0);
glColor3f(0.8f, 0.8f, 0.8f);
glVertex3f(100.0, 0.0, -100.0);
glEnd();
/* draw 12 cubes with different colors */
drawcube(75, 57, 2);
drawcube(-65, -12, 3);
drawcube(50, -50, 1);
drawcube(-56, 17, 2);
drawcube(67, 12, 3);
drawcube(-87, 32, 1);
drawcube(-26, 75, 2);
drawcube(57, 82, 3);
drawcube(-3, 12, 1);

Page
39


drawcube(46, 35, 2);
drawcube(37, -2, 3);
glutSwapBuffers();
}
void keyboard(unsigned char key, int x, int y)
{
/* This time the controls are:
"a": move left
"d": move right
"w": move forward
"s": move back
"t": toggle depth-testing
*/
switch (key)
{
case 'a':
case 'A':
glTranslatef(5.0, 0.0, 0.0);
break;
case 'd':
case 'D':
glTranslatef(-5.0, 0.0, 0.0);
break;

Page
40


case 'w':
case 'W':
glTranslatef(0.0, 0.0, 5.0);
break;
case 's':
case 'S':
glTranslatef(0.0, 0.0, -5.0);
break;
case 't':
case 'T':
if (is_depth)
{
is_depth = 0;
glDisable(GL_DEPTH_TEST);
}
else
{
is_depth = 1;
glEnable(GL_DEPTH_TEST);
}
}
display();
}

Page
41


void resize(int width, int height)
{
if (height == 0) height = 1;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* note we divide our width by our height to get the aspect ratio */
gluPerspective(45.0, width / height, 1.0, 400.0);
/* set initial position */
glTranslatef(0.0, -5.0, -150.0);
glMatrixMode(GL_MODELVIEW);
}
void drawcube(int x_offset, int z_offset, int color)
{
/* this function draws a cube centerd at (x_offset, z_offset)
x and z _big are the back and rightmost points, x and z _small are
the front and leftmost points */
float x_big = (float)x_offset + 5;
float z_big = (float)z_offset + 5;
float x_small = (float)x_offset - 5;
float z_small = (float)z_offset - 5;
switch(color)
{
case 1:

Page
42


glColor3f(1.0,1.0,0.0);
break;
case 2:
glColor3f(0.0,1.0,0.0);
break;
case 3:
glColor3f(0.0,1.0,0.0);
break;
}
glBegin(GL_QUADS);
glVertex3f(x_small,10.0,z_big); /* front */
glVertex3f(x_small,0.0,z_big);
glVertex3f(x_big,0.0,z_big);
glVertex3f(x_big,10.0,z_big);
glVertex3f(x_big,10.0,z_small); /* back */
glVertex3f(x_big,0.0,z_small);
glVertex3f(x_small,0.0,z_small);
glVertex3f(x_small,10.0,z_small);
glVertex3f(x_big,10.0,z_big); /* right */
glVertex3f(x_big,0.0,z_big);
glVertex3f(x_big,0.0,z_small);
glVertex3f(x_big,10.0,z_small);
glVertex3f(x_small,10.0,z_small); /* left */

Page
43


glVertex3f(x_small,0.0,z_small);
glVertex3f(x_small,0.0,z_big);
glVertex3f(x_small,10.0,z_big);
glVertex3f(x_small,10.0,z_big); /* top */
glVertex3f(x_big,10.0,z_big);
glVertex3f(x_big,10.0,z_small);
glVertex3f(x_small,10.0,z_small);
glVertex3f(x_small,0.0,z_small); /* bottom */
glVertex3f(x_big,0.0,z_small);
glVertex3f(x_big,0.0,z_big);
glVertex3f(x_small,0.0,z_big);
glEnd();
}















Page
44


BAB IV
ANALISA

Dari objek-objek atau gambar di atas yang telah dibuat, dapat dilihat
perkembangannya tahap demi tahap dari hasil objek yang tahap pertama memakai fungsi
primitive drawing hanya berupa garis-garis yang membentuk gambar sangat sederhana.
Pada tahap kedua yaitu objek yang memakai fungsi dua dimensi (2D) dapat dilihat
perkembangannya dimana kumpulan titik, garis, gambar yang memakai titik kordinat sumbu
x,y dapat membentuk suatu objek yang indah seperti meja, kursi, bunga, rumah minimalis.
Pada tahap akhir yaitu objek yang memakai fungsi tiga dimensi (3D) dapat dilihat
perkembangannya dimana objek primitive drawing dan dua dimensi (2D) yang hanya
memakai 2 titik kordinat yaitu x dan y digunakan juga namun pada objek tiga dimensi (3D)
ini pemakaian fungsinya memakai 3 titik kordinat yaitu sumbu x,y dan z sehingga objek
memiliki ruang dan gambar tampak lebih hidup, bahkan objek dapat bergerak seperti
berputar, berpindah tempat, ataupun keduanya dapat juga terjadi pada waktu yang bersamaan
saat program dijalankan.

















Page
45


BAB V
PENUTUP


5.1 Kesimpulan
Dalam pembuatan gambar-gambar diatas dengan menggunakan bahasa pemograman
Visual C++, selain menggunakan keahlian dalam menguasai bahasa pemograman Visual
C++, membutuhkan ketelitian dan kesabaran dalam pembuatan program-program gambar
diatas agar program tersebut tidak terdapat kesalahan (error) sehingga program tersebut dapat
di jalankan (Execute) dan gambar tersebut dapat di tampilkan hasilnya.

5.2 Saran
Adapun saran yang dapat penulis sampaikan ialah agar pembelajaran komputer grafik
dalam pembuatan gambar 2D dan 3D menggunakan bahasa pemograman Visual C++ ini
dapat di implementasikan menjadi Tugas Akhir nantinya.












Page
46


5.3 Hasil Aplikasi
Primitif Drawing








Dua Dimensi (2D)













Page
47


Tiga Dimensi (3D)









































Page
48


DAFTAR PUSTAKA

o http://informasi-inofatif.blogspot.com/2012/05/praktikum-grafika-komputer.html
o http://ejournal.unsrat.ac.id/index.php/elekdankom/article/download/595/467
o http://daraluvheechul.blogspot.com/2010/02/grafik-2d-3d.html