Upload
arifhidayatullah13
View
419
Download
19
Embed Size (px)
Citation preview
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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
2/
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 ......................................................................................... 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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
3/
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 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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
4/
Laboratorium Multimedia 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/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
5/
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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
6/
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)
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
7/
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) 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).
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
8/
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 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.
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
9/
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
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);
glVertex2i(200,150);
glEnd();
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
10
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;
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
11
Laboratorium Multimedia 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(150,150);
glVertex2i(50,50);
glVertex2i(50,150);
glVertex2i(50,150);
glVertex2i(150,150);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
12
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;
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
13
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
L ist programnya:
#include
typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
14
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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
15
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};
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
16
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
17
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
18
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
19
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
20
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();
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
21
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;
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
22
Laboratorium Multimedia 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);
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
23
Laboratorium Multimedia 23
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
24
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
25
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
26
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
27
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}};
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
28
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;
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
29
Laboratorium Multimedia 29
c). Heptagram
L ist programnya:
#include
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
30
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");
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
31
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:
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
32
Laboratorium Multimedia 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;
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
33
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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
34
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;
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
35
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;
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
36
Laboratorium Multimedia 36
for (i=0;i
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
37
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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
38
Laboratorium Multimedia 38
glColor3f(r,g,b);
for(j=0;j
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
39
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();
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
40
Laboratorium Multimedia 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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
41
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
42
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);
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
43
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;
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
44
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();
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
45
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:
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
46
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 */
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
47
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();
}
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
48
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.
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
49
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
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
50
Laboratorium Multimedia 50
Dua Dimensi (2D)
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
51
Laboratorium Multimedia 51
Tiga Dimensi (3D)
5/24/2018 Laporan Praktikum Komputer Grafik dengan OpenGL
52
Laboratorium Multimedia 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