Anda di halaman 1dari 52

Laboratorium Multimedia 1

Laboratorium Multimedia

Praktikum
Komputer Grafik

NAMA PRAKTIKAN
NOMOR
MAHASISWA
TANGGAL
KUMPUL
TANDA TANGAN
PRAKTIKAN
ARIF RAHMAN
HIDAYATULLAH
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

Laboratorium Multimedia 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) Persegi ..................................................................................................... 11
3.2 Latihan Fungsi Dua Dimensi (2D) .................................................................... 13
a) Masjid ...................................................................................................... 13
b) Monas ...................................................................................................... 22
c) Heptagram ............................................................................................... 29
3.3 Latihan Fungsi Tiga Dimensi (3D) .................................................................... 32
a) Point to Vector ......................................................................................... 31
b) The Cube World ...................................................................................... 40
BAB IV ANALISA.............................................................................................................. 48
BAB V PENUTUP .............................................................................................................. 49
5.1 Kesimpulan ........................................................................................................ 49
5.2 Saran .................................................................................................................. 49
5.3 Hasil Aplikasi .................................................................................................... 49
DAFTAR PUSTAKA ......................................................................................................... 52





Laboratorium Multimedia 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




Laboratorium Multimedia 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.

Laboratorium Multimedia 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

Laboratorium Multimedia 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)








Laboratorium Multimedia 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).


Laboratorium Multimedia 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.















Laboratorium Multimedia 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();

Laboratorium Multimedia 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;
}


Laboratorium Multimedia 11

b) Persegi

List programnya:
#include <GL/glut.h>
void userdraw()
{
static int tick=0;
void drawDot(int x, int y);
glBegin(GL_LINES);
glVertex2i(50,50);
glVertex2i(150,50);
glVertex2i(150,50);
glVertex2i(150,150);
glVertex2i(50,50);
glVertex2i(50,150);
glVertex2i(50,150);
glVertex2i(150,150);

Laboratorium Multimedia 12

glEnd();
}
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("PERSEGI");
glClearColor(0.0,0.0,0.0,0.0);
gluOrtho2D(0.,640.,-240.,240.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Laboratorium Multimedia 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). Masjid









List programnya:
#include <GL/glut.h>
typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;

Laboratorium Multimedia 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_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);

Laboratorium Multimedia 15

}
glEnd();
}
void userdraw(void)
{
point2D_t
alas1[4]={{90,0},{600,0},{600,10},{90,10}};
//memblok dengan warna putih1
color_t putih1 ={1,1,1};
fillPolygon(alas1, 4, putih1);
//setColor(1,1,1);
drawPolygon(alas1,4);
point2D_t
alas2[4]={{120,10},{120,20},{570,20},{570,10}};
//memblok dengan warna cyan1
color_t cyan1 ={0,1,1};
fillPolygon(alas2, 4, cyan1);
//setColor(0,1,1);
drawPolygon(alas2,4);
point2D_t
dinding[4]={{150,20},{150,135},{540,135},{540,20}};
//memblok dengan warna blue
color_t blue ={0,0,1};

Laboratorium Multimedia 16

fillPolygon(dinding, 4, blue);
//setColor(0,0,1);
drawPolygon(dinding,4);
point2D_t
atap[4]={{180,135},{180,150},{510,150},{510,135}};
//memblok dengan warna cyan2
color_t cyan2 ={0,1,1};
fillPolygon(atap, 4, cyan2);
//setColor(0,1,1);
drawPolygon(atap,4);
point2D_t
atap1[4]={{160,150},{530,150},{460,180},{240,180}};
//memblok dengan warna merah1
color_t merah1 ={1,0,0};
fillPolygon(atap1, 4, merah1);
//setColor(1,0,0);
drawPolygon(atap1,4);
point2D_t
atap2[4]={{250,180},{250,190},{450,190},{450,180}};
//memblok dengan warna cyan3
color_t cyan3 ={0,1,1};
fillPolygon(atap2, 4, cyan3);
//setColor(0,1,1);

Laboratorium Multimedia 17

drawPolygon(atap2,4);
point2D_t
atap3[4]={{240,190},{345,225},{470,190}};
//memblok dengan warna merah2
color_t merah2 ={1,0,0};
fillPolygon(atap3, 3, merah2);
//setColor(1,0,0);
drawPolygon(atap3,3);
point2D_t
tiang[4]={{345,225},{345,235},{346,235},{346,225}};
//memblok dengan warna biru
color_t biru ={1,0,1};
fillPolygon(tiang, 4, biru);
//setColor(1,0,1);
drawPolygon(tiang,4);
point2D_t

pintu1[9]={{170,20},{170,95},{180,95},{180,105},{210,120},{240,105},{240,95},{250,95
},{250,20}};
//memblok dengan warna kuning
color_t kuning ={1,1,0};
fillPolygon(pintu1, 9, kuning);
//setColor(1,1,0);

Laboratorium Multimedia 18

drawPolygon(pintu1,9);
point2D_t

pintu2[9]={{300,20},{300,95},{310,95},{310,105},{355,120},{400,105},{400,95},{410,95
},{410,20}};
//memblok dengan warna kuning2
color_t kuning2 ={1,1,0};
fillPolygon(pintu2, 9, kuning2);
//setColor(1,1,0);
drawPolygon(pintu2,9);
point2D_t

pintu3[9]={{450,20},{450,95},{460,95},{460,105},{485,120},{510,105},{510,95},{520,95
},{520,20}};
//memblok dengan warna kuning3
color_t kuning3 ={1,1,0};
fillPolygon(pintu3, 9, kuning3);
//setColor(1,1,0);
drawPolygon(pintu3,9);
point2D_t
alasmenara[4]={{20,0},{20,10},{70,10},{70,0}};
//memblok dengan warna white
color_t white ={1,1,1};
fillPolygon(alasmenara, 4, white);

Laboratorium Multimedia 19

//setColor(1,1,1);
drawPolygon(alasmenara,4);
point2D_t
menara1[4]={{30,10},{30,150},{60,150},{60,10}};
//memblok dengan warna magenta
color_t magenta ={1,0,1};
fillPolygon(menara1, 4, magenta);
//setColor(1,0,1);
drawPolygon(menara1,4);
point2D_t
menara2[4]={{30,150},{30,180},{60,180},{60,150}};
//memblok dengan warna biru1
color_t biru1 ={0,0,1};
fillPolygon(menara2, 4, biru1);
//setColor(0,0,1);
drawPolygon(menara2,4);
point2D_t

pintumenara[7]={{35,150},{35,160},{40,160},{45,170},{50,160},{55,160},{55,150}};
//memblok dengan warna kuning5
color_t kuning5 ={1,1,0};
fillPolygon(pintumenara, 7, kuning5);
//setColor(1,1,0);

Laboratorium Multimedia 20

drawPolygon(pintumenara,7);
point2D_t
menara3[4]={{20,180},{20,185},{70,185},{70,180}};
//memblok dengan warna pink
color_t pink ={0,1,1};
fillPolygon(menara3, 4, pink);
//setColor(0,1,1);
drawPolygon(menara3,4);
point2D_t
atapmenara[3]={{10,185},{50,210},{80,185}};
//memblok dengan warna muda
color_t muda ={1,0,0};
fillPolygon(atapmenara, 3, muda);
//setColor(1,0,0);
drawPolygon(atapmenara,3);
}
void display(void)
{
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}

Laboratorium Multimedia 21

int main(int argc, char **argv)
{
glutInit(&argc,argv);//Inisialisasi Toolkit
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
//posisi layar
glutInitWindowPosition(100,100);
//ukuran layar
glutInitWindowSize(740,480);
//title windows
glutCreateWindow("gambar mesjid");
//warna back layar
glClearColor(0.0 , 0.0 , 0.0 , 0.0);
gluOrtho2D(0.,640.,-50.,240.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}






Laboratorium Multimedia 22

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);
}

Laboratorium Multimedia 23

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

Laboratorium Multimedia 24

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);

Laboratorium Multimedia 25

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);



Laboratorium Multimedia 26

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);

Laboratorium Multimedia 27

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}};

Laboratorium Multimedia 28

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;
}

Laboratorium Multimedia 29

c). Heptagram








List programnya:
#include <GL/glut.h>
void userdraw()
{
static int tick=0;
void drawDot(int x, int y);
glBegin(GL_LINES);
glVertex2i(100,250);
glVertex2i(300,250);
glVertex2i(300,250);
glVertex2i(250,50);
glVertex2i(250,50);
glVertex2i(50,150);
glVertex2i(50,150);

Laboratorium Multimedia 30

glVertex2i(200,300);
glVertex2i(200,300);
glVertex2i(350,150);
glVertex2i(350,150);
glVertex2i(150,50);
glVertex2i(150,50);
glVertex2i(100,250);
glEnd();
}
void display(void)
{
//BERSIH LAYAR
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("HEPTAGRAM");

Laboratorium Multimedia 31

glClearColor(0.0f,0.0f,1.0f,0.0f);
gluOrtho2D(0.,640.,0.,350.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}


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:








Laboratorium Multimedia 32

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

Laboratorium Multimedia 33

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;
}
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;

Laboratorium Multimedia 34

else
mat.m[i][j] = 0;
}
}
return mat;
}
matriks translasi(float dx, float dy, float dz) {
matriks trans = identitas();
trans.m[0][3] = dx;
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;
}

Laboratorium Multimedia 35

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;
}
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;

Laboratorium Multimedia 36

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) {
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) {

Laboratorium Multimedia 37

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)
{
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; }

Laboratorium Multimedia 38

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();
}
}
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);

Laboratorium Multimedia 39

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);
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();
}

Laboratorium Multimedia 40

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);

Laboratorium Multimedia 41

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);

Laboratorium Multimedia 42

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);

Laboratorium Multimedia 43

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;

Laboratorium Multimedia 44

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();
}

Laboratorium Multimedia 45

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:

Laboratorium Multimedia 46

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 */

Laboratorium Multimedia 47

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();
}















Laboratorium Multimedia 48

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.

















Laboratorium Multimedia 49

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.

5.3 Hasil Aplikasi
Primitif Drawing









Laboratorium Multimedia 50

Dua Dimensi (2D)























Laboratorium Multimedia 51

Tiga Dimensi (3D)









































Laboratorium Multimedia 52

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