laporan praktikum komputer grafik dengan opengl

5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL

1/

Laboratorium Multimedia 1

Laboratorium Multimedia

PraktikumKomputer Grafik

NAMA PRAKTIKANNOMOR

MAHASISWA

TANGGAL

KUMPUL

TANDA TANGAN

PRAKTIKAN

ARIF RAHMAN

HIDAYATULLAH1214370424

NAMA PENILAITANGGAL

KOREKSINILAI

TANDA TANGAN

DOSEN

INDRI SULISTIANINGSIH,S.KOM

Jurusan Teknik Informatika

Fakultas Teknik

Universitas Pembangunan Panca Budi Medan

2014

KELAS

SK 4B SORE


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 ......................................................................................... 31b) 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


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 kuliahkomputer 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


4/


BAB I

PENDAHULUAN

1.1UmumGrafik 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 diawalidengan 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.


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


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)


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) EntertainmentMisalnya 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 ProsesMisalnya menggambarkan layout kinerja proses public atau proses-proses yang

dalam modul saja.

3) Visualisasi Hasil PenelitianVisualisasi hasil penelitian ini seperti menggambar perfomers grafik perubahan

bahkan grafik model hasil implementasi program.

4) Image ProsesiImage Prosesi digunakan sebagai algoritma identifikasi seperti yang dilakukan

pada kepolisian untuk menggambar wajah seseorang dan identifikasi seseorang.

5) GIS ( Geografic Information Sytem).


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 ImageRaster 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 ImageVektor 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.


9/


BAB III

PRAKTIKUM

3.1 Latihan Fungsi dari Primitive drawing

Beberapa objek yang dihasilkan dari fungsi primitive drawing, sebagai berikut:

a) Garis

L ist Programnya:

#include

void userdraw()

{

static int tick=0;

void drawline(int x1,int x2, int y1,int y2);

glBegin(GL_LINES);

glVertex2i(100,100);


glEnd();


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;

}


11


b) Persegi

L ist programnya:

#include

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(50,50);

glVertex2i(50,150);

glVertex2i(50,150);



12


glEnd();

}

void display(void)

{

//clear screen


userdraw();

glutSwapBuffers();

}


{





glutCreateWindow("PERSEGI");


gluOrtho2D(0.,640.,-240.,240.);



glutMainLoop();

return 0;

}


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

L ist programnya:

#include

typedef struct

{

int x,y;

}point2D_t;

typedef struct

{

float r,g,b;


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


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


16


fillPolygon(dinding, 4, blue);

//setColor(0,0,1);

drawPolygon(dinding,4);

point2D_t

atap[4]={{180,135},{180,150},{510,150},{510,135}};



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



fillPolygon(atap2, 4, cyan3);

//setColor(0,1,1);


17



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


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


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


point2D_t

pintu3[9]={{450,20},{450,95},{460,95},{460,105},{485,120},{510,105},{510,95},{520,95

},{520,20}};



fillPolygon(pintu3, 9, kuning3);

//setColor(1,1,0);


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


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


point2D_t

pintumenara[7]={{35,150},{35,160},{40,160},{45,170},{50,160},{55,160},{55,150}};



fillPolygon(pintumenara, 7, kuning5);

//setColor(1,1,0);


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


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


userdraw();

glutSwapBuffers();

}


21



{



//posisi layar


//ukuran layar


//title windows

glutCreateWindow("gambar mesjid");

//warna back layar

glClearColor(0.0 , 0.0 , 0.0 , 0.0);

gluOrtho2D(0.,640.,-50.,240.);



glutMainLoop();

return 0;

}


22


b). Monas

L ist programnya:

#include

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

}


23


void drawPolygon(point2D_t pnt[],int n)

{

int i;

glBegin(GL_LINE_LOOP);

for (i=0; i


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


fillpolygon(petaktengah2, 4, kuning2);


point2D_t

petaktengah3[4]={{80,90},{70,110},{290,110},{280,90}};


fillpolygon(petaktengah3, 4, kuning3);


25



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


fillpolygon(batang, 4, putih2);

drawPolygon(batang,4);

point2D_t

petaktengah4[4]={{70,110},{70,120},{290,120},{290,110}};


fillpolygon(petaktengah4, 4, hitam3);


point2D_t

segitiga[3]={{170,530},{180,580},{190,530}};


fillpolygon(segitiga, 3, kuning4);

drawPolygon(segitiga,3);


26


point2D_t

bayangbatang[4]={{160,530},{160,535},{200,535},{200,530}};


fillpolygon(bayangbatang, 4, putih3);

drawPolygon(bayangbatang,4);

point2D_t

bayangbatang2[4]={{200,510},{200,535},{203,535},{203,510}};


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


fillpolygon(tanggatgh2, 4, hitam2);

drawPolygon(tanggatgh2,4);

point2D_t

tangga2[4]={{10,10},{50,50},{310,50},{340,10}};

drawPolygon(tangga2,4);


27


point2D_t

petaktengah11[4]={{110,50},{100,70},{260,70},{250,50}};


point2D_t

petaktengah22[4]={{100,70},{80,90},{280,90},{260,70}};


point2D_t

petaktengah33[4]={{80,90},{70,110},{290,110},{280,90}};


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


point2D_t

anaktangga4[4]={{150,10},{150,15},{210,15},{210,10}};


28



}

void display(void)

{

//clear screen


userdraw();

glutSwapBuffers();

}


{





glutCreateWindow("MONUMEN NASIONAL JAKARTA");


gluOrtho2D(0.,350.,-5.,600.);



glutMainLoop();

return 0;

}


29


c). Heptagram

L ist programnya:

#include

void userdraw()

{

static int tick=0;

void drawDot(int x, int y);

glBegin(GL_LINES);




glVertex2i(250,50);

glVertex2i(250,50);

glVertex2i(50,150);

glVertex2i(50,150);


30






glVertex2i(150,50);

glVertex2i(150,50);


glEnd();

}

void display(void)

{

//BERSIH LAYAR


userdraw();

glutSwapBuffers();

}

int main(int argc,char **argv)

{





glutCreateWindow("HEPTAGRAM");


31


glClearColor(0.0f,0.0f,1.0f,0.0f);

gluOrtho2D(0.,640.,0.,350.);



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:


32


L ist Programnya:

#include

#include

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;


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


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;


return rotate;

}


35


matriks rotasiY(float theta) {








return rotate;

}

matriks rotasiZ(float theta) {








return rotate;

}

vektor kali (matriks mat, vektor b) {

int i,j;

vektor c;


36


for (i=0;i


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


38


glColor3f(r,g,b);

for(j=0;j


39


HslTitik = vektor2point(HslKali);

balok.titik[i] = HslTitik;

}

DrawPolygon(balok);

}

void UserDraw() {

glClearColor(1.0f,1.0f,1.0f,0.0f);


glRotatef(0.1f,0.0f,1.0f,0.0f);

gambarbalok();

glutSwapBuffers();

}

void main(int argc,char **argv) {

glutInit(&argc,argv);




glutCreateWindow("Point To Vektor");

glOrtho(-100.0f,100.0f,-100.0f,100.0f,-100.0f,100.0f);

glutIdleFunc(UserDraw);

glutDisplayFunc(UserDraw);

glutMainLoop();

}


40


b. The Cube World

L ist Programnya:

#include

#include

#include

#include /* 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);


41


glutInitWindowSize(600, 600);

glutInitWindowPosition(40, 40);

glutCreateWindow("The Cube World");

init();


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


42


else


/* 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(-87, 32, 1);

drawcube(-26, 75, 2);


drawcube(-3, 12, 1);


43



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;


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

}


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:


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_small); /* back */

glVertex3f(x_big,0.0,z_small);

glVertex3f(x_small,0.0,z_small);


glVertex3f(x_big,10.0,z_big); /* right */




glVertex3f(x_small,10.0,z_small); /* left */


47





glVertex3f(x_small,10.0,z_big); /* top */




glVertex3f(x_small,0.0,z_small); /* bottom */




glEnd();

}


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.


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


50


Dua Dimensi (2D)


51


Tiga Dimensi (3D)


52


DAFTAR PUSTAKA

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

laporan praktikum komputer grafik dengan opengl

Documents