LAPORAN PRAKTIKUM KOMPUTER GRAFIK

Transkripsi

1 LAPORAN PRAKTIKUM KOMPUTER GRAFIK KELAS TI4C SORE NAMA PRAKTIKAN Mulia Hamonangan Tambunan NOMOR TANGGAL TANDA TANGAN MAHASISWA KUMPUL PRAKTIKAN NAMA PENILAI TANGGAL KOREKSI NILAI TANDA TANGAN DOSEN Indri Sulistianingsih S.Kom Universitas Pembangunan Panca Budi Fakultas Teknik Jurusan Teknik Informatika Medan 2014

2 DAFTAR ISI DAFTAR ISI...1 KATA PENGANTAR...2 BAB I PENDAHULUAN Umum Latar Belakang Tujuan Praktikum...5 BAB II LANDASAN TEORI...6 BAB III PRAKTIKUM Latihan Fungsi Primitif Drawing...8 a) Garis...8 b) Persegi Latihan Fungsi Dua Dimensi (2D)...12 a) Diamond...12 b) Bunga...14 c) Heptagram...18 d) Rumah Minimalis...20 e) Meja dan Kursi Latihan Fungsi Tiga Dimensi (3D)...37 a) Point to Vector...37 b) The Cube World...44 BAB IV ANALISA...51 BAB V PENUTUP Kesimpulan Saran Hasil Aplikasi...53 DAFTAR PUSTAKA

3 KATA PENGANTAR Puji dan Syukur penulis panjatkan kepada Tuhan Yang Maha Esa 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 Tuhan Yang Maha Esa memberikan balasan yang berlipat ganda kepada semuanya. Demi perbaikan selanjutnya, saran dan kritik yang membangun akan penulis terima dengan senang hati. Akhirnya, hanya kepada Tuhan Yang Maha Esa penulis serahkan segalanya mudah-mudahan dapat bermanfaat khususnya bagi penulis umumnya bagi kita semua. Medan, 8 Juni 2014 Penulis 2

4 BAB I PENDAHULUAN 1.1 Umum 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. OpenGL (Open Graphics Library) adalah standar API yang dapat digunakan untuk membuat aplikasi berbasis 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 X- Windows. 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. 3

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 idea tau 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 4

6 wajah menjadi lebih mudah dan akurat, scanner 3D membuat proses 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 MS- Windows, 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

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, ku rva, 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 6

8 Image Prosesi digunakan sebagai algoritma identifikasi seperti yang dilakukan pada kepolisian untuk menggambar wajah seseorang dan identifikasi seseorang. 5) GIS ( Geografic Information Sytem). 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. 7

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

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

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

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

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). Diamond 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(100,250); glvertex2i(200,200); glvertex2i(200,200); glvertex2i(300,250); glvertex2i(100,250); glvertex2i(200,50); 12

14 glvertex2i(200,200); glvertex2i(200,50); glvertex2i(300,250); glvertex2i(200,50); 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("diamond"); glclearcolor(0.0f,0.0f,1.0f,0.0f); gluortho2d(0.,640.,0.,300.); glutidlefunc(display); glutdisplayfunc(display); glutmainloop(); return 0; 13

15 b) Bunga List Programnya: #include <GL/glut.h> #include <math.h> typedef struct int x,y; ; typedef struct float r,g,b; color_t; void setcolor (color_t col) glcolor3f(col.r, col.g, col.b); 14

16 void drawpolygon( pnt[],int n) int i; glbegin(gl_polygon); for (i=0; i<n; i++) glvertex2i(pnt[i].x,pnt[i].y); glend(); void fillpolygon ( 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() batang[4]=-5,-190,- 5,0,5,0,5,-190; color_t biru =0,0,1; fillpolygon(batang,4, biru); 15

17 drawpolygon(batang,4); pot[4]=-60,-190,60,-190,30,-240,- 30,-240; color_t hitam =0,0,0; fillpolygon(pot,4, hitam); drawpolygon(pot,4); pot2[6]=-80,-160,-50,-160,-50,-190,-60,-190,-60,-170,- 80,-170; color_t hitam3 =0,0,0; fillpolygon(pot2,4, hitam3); drawpolygon(pot2,4); pot3[6]=80,-160,50,-160,50,-190,60,-190,60,- 170,80,-170; color_t hitam2 =0,0,0; fillpolygon(pot3,4, hitam2); drawpolygon(pot3,4); static int tick=0; shape[360]; double srad,r; for(int s=0; s<360; s++) srad =(s+tick)*3.14/360; r=80*sin(200*srad); shape [s].x = (float)(r*cos(100*srad)); shape [s].y = (float)(r*sin(100*srad)); 16

18 color_t merah =1,0,0; fillpolygon(shape,1, merah); drawpolygon(shape, 360); void display(void) //clear screen glclear(gl_color_buffer_bit); userdraw(); glutswapbuffers(); int main(int argc, char **argv) glutinit(&argc,argv); glutinitdisplaymode(glut_double GLUT_RGB); //posisi layar glutinitwindowposition(150,150); //ukuran layar glutinitwindowsize(640,480); //title windows glutcreatewindow("bunga Raflesia"); //warna back layar glclearcolor(1.0,1.0,1.0,0.0); gluortho2d(-300.,400.,-300.,300.); glutidlefunc(display); glutdisplayfunc(display); glutmainloop(); return 0; 17

19 c) Heptagram List Program: #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); glvertex2i(200,300); glvertex2i(200,300); glvertex2i(350,150); 18

20 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"); glclearcolor(0.0f,0.0f,1.0f,0.0f); gluortho2d(0.,640.,0.,350.); glutidlefunc(display); glutdisplayfunc(display); glutmainloop(); return 0; 19

21 d) Rumah Minimalis List Programnya: #include <GL/glut.h> typedef struct int x,y; ; void polyline( pnt[],int n) int i; glbegin(gl_line_loop); for (i=0; i<n; i++) glvertex2f(pnt[i].x,pnt[i].y); glend(); void userdraw(void) 20

22 petak[4]=100,50,100,250,350,250,350,50; polyline(petak,4); plang[4]=50,250,50,270,400,270,400,250; polyline(plang,4); plang2[4]=400,250,400,270,700,270,700,250; polyline(plang2,4); segitiga[3]=50,270,220.5,400,400,270; polyline(segitiga,3); jendela[4]=120.5,70.5,120.5,150,170.5,150,170.5,70.5; polyline(jendela,4); jendela2[4]=270.5,70.5,270.5,150,320.5,150,320.5,70.5; polyline(jendela2,4); pintu[4]=200,50,200,150,250,150,250,50; polyline(pintu,4); pin[4]=200.5,90.5,200.5,100,210,100,210,90.5; 21

23 polyline(pin,4); daunjendela[4]=110,60,120.5,150,170.5,150,160.5,60; polyline(daunjendela,4); daunjendela2[4]=260,60,270.5,150,320.5,150,310.5,60; polyline(daunjendela2,4); jalan[4]=100,- 250,170.5,50,270.5,50,200,-250; polyline(jalan,4); garisjln[4]=120,-160,120.5,-150,220.5,- 150,220,-160; polyline(garisjln,4); garisjln2[4]=140.5,-60,150,-50,250,- 50,240.5,-60; polyline(garisjln2,4); cerobong[4]=150,340.5,150,450,200,450,200,380.5; polyline(cerobong,4); petak2[4]=350,50,350,250,650,250,650,50; polyline(petak2,4); 22

24 genteng[6]=400,250,400,270,220.5,400,520.5,400,700,270,700,250; polyline(genteng,6); jendela3[9]=450,100,450,170.5,500,170.5,500,100,450,170.5,450,100,500,170. 5,450,100,500,100; polyline(jendela3,9); jendela4[9]=500,100,500,170.5,550,170.5,550,100,500,170.5,500,100,550,170. 5,500,100,550,100; polyline(jendela4,9); atapjendela[4]=430.5,160,430.5,170.5,500,210,500,200; polyline(atapjendela,4); atapjendela2[4]=500,200,500,210,570,170,570,160; polyline(atapjendela2,4); pot[4]=30.5,-120.5,20.5,-70.5,70.5,- 70.5,60.5,-120.5; polyline(pot,4); pot2[4]=310,-120.5,300,-70.5,350,- 70.5,340,-120.5; polyline(pot2,4); bunga[4]=30.5,-70.5,20.5,-50,30.5,- 50,40.5,-70.5; 23

25 polyline(bunga,4); bunga2[4]=40.5,-70.5,40.5,-20.5,50.5,- 20.5,50.5,-70.5; polyline(bunga2,4); bunga3[4]=50.5,-70.5,60.5,-50,70.5,- 50,60.5,-70.5; polyline(bunga3,4); bunga4[4]=310,-70.5,300,-50,310,- 50,320,-70.5; polyline(bunga4,4); bunga5[4]=320,-70.5,320,-20.5,330,- 20.5,330,-70.5; polyline(bunga5,4); bunga6[4]=330,-70.5,340,-50,350,- 50,340,-70.5; polyline(bunga6,4); pagar[4]=-250,-250,-250,-150,-230,-150,- 230,-250; polyline(pagar,4); pagar2[4]=-150,-250,-150,-150,-130,-150,- 130,-250; polyline(pagar2,4); 24

26 pagar3[4]=-50,-250,-50,-150,-30,-150,-30,- 250; polyline(pagar3,4); pagar4[4]=50,-250,50,-150,70,- 150,70,-250; polyline(pagar4,4); pagar5[4]=250,-250,250,-150,270,- 150,270,-250; polyline(pagar5,4); pagar6[4]=350,-250,350,-150,370,- 150,370,-250; polyline(pagar6,4); pagar7[4]=450,-250,450,-150,470,- 150,470,-250; polyline(pagar7,4); pagar8[4]=550,-250,550,-150,570,- 150,570,-250; polyline(pagar8,4); pagar9[4]=650,-250,650,-150,670,- 150,670,-250; polyline(pagar9,4); pagar10[4]=750,-250,750,-150,770,- 150,770,-250; polyline(pagar10,4); 25

27 palang[4]=-230,-210,-230,-190,-150,-190,- 150,-210; polyline(palang,4); palang2[4]=-130,-210,-130,-190,-50,-190,- 50,-210; polyline(palang2,4); palang3[4]=-30,-210,-30,-190,50,- 190,50,-210; polyline(palang3,4); palang4[4]=270,-210,270,-190,350,- 190,350,-210; polyline(palang4,4); palang5[4]=370,-210,370,-190,450,- 190,450,-210; polyline(palang5,4); palang6[4]=470,-210,470,-190,550,- 190,550,-210; polyline(palang6,4); palang7[4]=570,-210,570,-190,650,- 190,650,-210; polyline(palang7,4); palang8[4]=670,-210,670,-190,750,- 190,750,-210; polyline(palang8,4); 26

28 tembok[6]=-230,-190,-230,-150,-250,-150,100,200,100,100,- 190,-190; polyline(tembok,6); tembok2[4]=650,100,650,200,1020,200,950,100; polyline(tembok2,4); tembok3[4]=770,-250,770,- 150,1020,200,1020,100; polyline(tembok3,4); temboksegitiga[3]=-230,-230,-230,-210,- 210,-210; polyline(temboksegitiga,3); jndlkecil[9]=130.5,170.5,130.5,200,160.5,200,160.5,170.5,130.5,200,130.5,170.5,160.5,200,130.5,170.5,160.5,170.5; polyline(jndlkecil,9); jndlkecil2[9]=280.5,170.5,280.5,200,310.5,200,310.5,170.5,280.5,200,280.5,170.5,310.5,200,280.5,170.5,310.5,170.5; polyline(jndlkecil2,9); asesoris[3]=220.5,290,210.5,310.5,220.5,320.5; polyline(asesoris,3); 27

29 asesoris2[3]=210.5,310.5,190,320.5,220.5,320.5; polyline(asesoris2,3); asesoris3[3]=190,320.5,210.5,330.5,220.5,320.5; polyline(asesoris3,3); asesoris4[3]=210.5,330.5,220.5,360,220.5,320.5; polyline(asesoris4,3); asesoris5[3]=220.5,360,230.5,330.5,220.5,320.5; polyline(asesoris5,3); asesoris6[3]=230.5,330.5,260,320.5,220.5,320.5; polyline(asesoris6,3); asesoris7[3]=260,320.5,230.5,310.5,220.5,320.5; polyline(asesoris7,3); asesoris8[3]=230.5,310.5,220.5,290,220.5,320.5; polyline(asesoris8,3); tiang[4]=780, ,780,70.5,790.5,70.5,790.5,-270.5; polyline(tiang,4); 28

30 tiangatas[4]=720.5,50.5,720.5,60.5,780,60.5,780,50.5; polyline(tiangatas,4); gantunganlampu[4]=740,40.5,740,50.5,750,50.5,750,40.5; polyline(gantunganlampu,4); gantunganlampu2[4]=720.5,20.5,740,40.5,750,40.5,760.5,20.5; polyline(gantunganlampu2,4); lampu[4]=740,10.5,740,20.5,750,20.5,750,10.5; polyline(lampu,4); batangpohon[4]=850,50,860.5,150,880.5,150,900,50; polyline(batangpohon,4); pohon[4]=790,150,860.5,220.5,880.5,220.5,960,150; polyline(pohon,4); pohon2[4]=810,220.5,860.5,300,880.5,300,940,220.5; polyline(pohon2,4); pohon3[4]=820.5,300,860.5,350,880.5,350,920.5,300; 29

31 polyline(pohon3,4); pohon4[3]=840,350,870.5,400,910,350; polyline(pohon4,3); atap[4]=400,270,220.5,400,300,400,470.5,270; polyline(atap,4); atap2[4]=470.5,270,300,400,370.5,400,550,270; polyline(atap2,4); atap3[4]=550,270,370.5,400,450,400,620.5,270; polyline(atap3,4); atap4[4]=260,370.5,220.5,400,520.5,400,560,370.5; polyline(atap4,4); atap5[4]=320.5,330,290.5,350,590,350,620.5,330; polyline(atap5,4); atap6[4]=360,300,320.5,330,620.5,330,660,300; polyline(atap6,4); 30

32 void display(void) //clear screen glclear(gl_color_buffer_bit); userdraw(); glutswapbuffers(); int main(int argc,char**argv) glutinit(&argc,argv);//lnisialisasi toolkit glutinitdisplaymode(glut_double GLUT_RGB); glutinitwindowposition(100,100); glutinitwindowsize(940,580); glutcreatewindow("gambar Garis"); glclearcolor(0.0,0.0,0.0,0.0); gluortho2d(- 300.,1240.,-300.,1240.); glutidlefunc(display); glutdisplayfunc(display); glutmainloop(); return 0; 31

33 e) Meja dan Kursi List Programnya: #include<gl/glut.h> #include<math.h> typedef struct float x,y; ; typedef struct int r,g,b; color_t; void setcolor ( color_t col ) glcolor3f(col.r, col.g, col.b); void fillpolygon ( pnt[], int n, color_t color) int i; setcolor(color); glbegin(gl_polygon); for (i=0; i<n; ++i) 32

34 glvertex2f(pnt[i].x, pnt[i].y); glend(); void drawpolygon( pnt[], int n) int i; glbegin(gl_polygon); for(i=0; i<n; i++) glvertex2f(pnt[i].x, pnt[i].y); glend(); void userdraw() static int tic = 0; meja[4]=20,80,60,160,200,160,160,80; color_t magenta =1,1,0; fillpolygon(meja,4, magenta); //setcolor(1,1,0); drawpolygon(meja,4); depankiri[4]=20,20, 20,80, 30,80, 30,20; color_t white =1,1,1; fillpolygon(depankiri,4, white); //setcolor(1,1,1); drawpolygon(depankiri,4); 33

35 depankanan[4]=150,20,150,80,160,80,160,20; color_t green =0,1,0; fillpolygon(depankanan,4, green); drawpolygon(depankanan,4); belakangkiri[4]=60,50,60,80,70,80,70,50; color_t yellow =1,1,0; fillpolygon(belakangkiri,4, yellow); drawpolygon(belakangkiri,4); belakangkanan[4]=190,50,190,140,200,160,200,50; color_t red =1,0,0; fillpolygon(belakangkanan,4, red); drawpolygon(belakangkanan,4); kursi[4]=220,80,240,120,320,120,300,80; color_t birumuda =0,1,1; fillpolygon(kursi,4, birumuda); //setcolor(0,0,1); drawpolygon(kursi,4); depankiri1[4]=220,20, 220,80, 230,80, 230,20; color_t hijau =0,1,0; fillpolygon(depankiri1,4, hijau); //setcolor(0,1,0); drawpolygon(depankiri1,4); 34

36 depankanan1[4]=290,20,290,80,300,80,300,20; color_t biru =0,0,1; fillpolygon(depankanan1,4, biru); drawpolygon(depankanan1,4); belakangkiri1[4]=240,50,240,80,250,80,250,50; color_t kuning =1,1,0; fillpolygon(belakangkiri1,4, kuning); drawpolygon(belakangkiri1,4); belakangkanan1[4]=310,50,310,100,320,120,320,50; color_t merah =1,0,0; fillpolygon(belakangkanan1,4, merah); drawpolygon(belakangkanan1,4); kursi1[4]=300,80,300,160,320,200,320,120; color_t putih =1,1,1; fillpolygon(kursi1,4, putih); //setcolor(1,1,1); drawpolygon(kursi1,4); kursi2[4]=290,160,310,200,320,200,300,160; color_t ungu =1,0,1; fillpolygon(kursi2,4, ungu); //setcolor(1,0,1); drawpolygon(kursi2,4); 35

37 kursi3[4]=290,160,290,80,300,80,300,160; color_t hijau1 =0,1,0; fillpolygon(kursi3,4, hijau1); //setcolor(0,1,0); drawpolygon(kursi3,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(640,480); glutcreatewindow("meja Kursi"); glclearcolor(0.0,0.0,0.0,0.0); gluortho2d(0.,640.,- 240.,240.); glutidlefunc(display); glutdisplayfunc(display); glutmainloop(); return 0; 36

38 3.3 Latihan Fungsi dari Tiga Dimensi (3D) Grafik Komputer 3D merupakan perkembangan dari grafik 2D. Istilah atau Pengertian Grafik 3D adalah sebuah gambar,garis,lengkungan,dan sebagainya yang memiliki titik-titik yang menghubungkan menjadi sebuah bentuk 3D. Berikut beberapa objek dari grafik tiga dimensi (3D), yakni: a. Point to Vektor Dapat dilihat pada gambar di bawah bahwa objek kubus tersebut bergerak: List Programnya: #include <GL/glut.h> #include <math.h> struct point float x,y,z; ; struct vektor float v[4]; ; struct matriks float m[4][4]; ; struct face int jumtitikons; int indextitik[40]; 37

39 ; struct objek int jumtitik; point titik[40]; int jumsisi; face sisi[30]; ; matriks mat; float theta=0.5; vektor point2vektor(objek balok, int i) vektor vec; vec.v[0] = balok.titik[i].x; vec.v[1] = balok.titik[i].y; vec.v[2] = balok.titik[i].z; vec.v[3] = 1; return vec; 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) 38

40 mat.m[i][j] = 1; else mat.m[i][j] = 0; return mat; matriks translasi(float dx, float dy, float dz) matriks trans = identitas(); trans.m[0][3] = dx; trans.m[1][3] = dx; trans.m[2][3] = dx; return trans; matriks rotasix(float theta) matriks rotate = identitas(); float cs = cos(theta); float sn = sin(theta); rotate.m[1][1] = cs; rotate.m[1][2] = -sn; rotate.m[2][1] = sn; rotate.m[2][2] = cs; return rotate; matriks rotasiy(float theta) matriks rotate = identitas(); float cs = cos(theta); float sn = sin(theta); rotate.m[0][0] = cs; rotate.m[0][2] = sn; rotate.m[2][0] = -sn; 39

41 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; 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; 40

42 for (k=0;k<4;k++) c.m[i][j]+=a.m[i][k] * b.m[k][j]; return c; matriks titling = kalim(rotasix(theta),rotasiy(- theta)); vektor cross (vektor a, vektor b) vektor c; c.v[0] = a.v[1]*b.v[2]-a.v[2]*b.v[1]; c.v[1] = a.v[2]*b.v[0]-a.v[0]*b.v[2]; c.v[2] = a.v[0]*b.v[1]-a.v[1]*b.v[0]; c.v[3] = 1; return c; void DrawPolygon(objek obj) 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; 41

43 if (i==6) r=0.5f; g=0.0f; b=1.0f; if (i==7) r=0.5f; g=0.5f; b=0.5f; glcolor3f(r,g,b); for(j=0;j<obj.sisi[i].jumtitikons;j++) glvertex3f(obj.titik[obj.sisi[i].indextitik[j]].x, obj.titik[obj.sisi[i].indextitik[j]].y, obj.titik[obj.sisi[i].indextitik[j]].z); glend(); void gambarbalok() int i; vektor hasil,hslkali; point HslTitik; mat = titling; objek balok = 8,10,15,30,30,15,30,30,15,10,10,15,10,10,30,30,30,30,30,30,30,10,10,30,10, 6,4,0,1,5,4,4,3,2,6,7,4,0,3,7,4,4,1,2,6,5,4,0,1,2,3,4,4,5,6,7; for (i=0;i<8;i++) hasil = point2vektor(balok,i); HslKali = kali(mat,hasil); HslTitik = vektor2point(hslkali); balok.titik[i] = HslTitik; DrawPolygon(balok); void UserDraw() 42

44 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( f,100.0f,-100.0f,100.0f,-100.0f,100.0f); glutidlefunc(userdraw); glutdisplayfunc(userdraw); glutmainloop(); 43

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

46 glutinitdisplaymode(glut_double GLUT_RGB); 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); else glclear(gl_color_buffer_bit); /* draw the floor */ 45

47 glbegin(gl_quads); glcolor3f(0.2f, 0.2f, 0.2f); glvertex3f(-100.0, 0.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, ); 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); 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 46

48 "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; 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 47

49 is_depth = 1; glenable(gl_depth_test); display(); 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, ); 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; 48

50 float x_small = (float)x_offset - 5; float z_small = (float)z_offset - 5; switch(color) case 1: 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 */ 49

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

52 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. 51

53 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. 52

54 5.3 Hasil Aplikasi Primitif Drawing Dua Dimensi (2D) 53

55 Tiga Dimensi (3D) 54

56 DAFTAR PUSTAKA