Download - Eva Martia (1214370066)
1
LLAAPPOORRAANN PPRRAATTIIKKUUMM
KKOOMMPPUUTTEERR GGRRAAFFIIKK
NNaamm aa
PPrraa tt ii kkuumm
NNoommoo rr
MMaahh aass ii ssww aa
TTaann ggggaa ll
KKuummpp uu ll
TTaann dd aa TT aann ggaa nn
PPrraa tt ii kkuumm
EEvvaa MM aarr tt ii aa 11221144 337700 006666 1122-- 0066 --2200 1144
NNaamm aa PP eenn ii ll aa ii TTaann ggggaa ll
KKoo rree kkss ii NNii ll aa ii
TTaann dd aa TT aann ggaa nn
DDooss eenn
IInn dd rr ii SS uu ll ii ss tt ii aann iinn ggss ii hh
SS ..KKoomm
Fakultas Teknik
Jurusan Sistem Komputer
Universitas Pembangunan Panca Budi
Medan
2014
Kelas
TI-4 SORE D
2
KATA PENGANTAR
Puji syukur kami panjatkan ke hadirat Allah Subhanahu wata’ala, karena
berkat rahmat-Nya kami dapat menyelesaikan makalah “LAPORAN PRATIKUM
KOMPUTER GRAFIK”. Makalah ini diajukan guna memenuhi tugas mata kuliah
Komputer Grafik.
Kami mengucapkan terima kasih kepada semua pihak yang telah membantu
sehingga makalah ini dapat diselesaikan sesuai dengan waktunya. Makalah ini masih
jauh dari sempurna. Oleh karena itu kami mengharapkan kritik dan saran yang
bersifat membangun demi kesempurnaan makalah ini.
Semoga makalah ini memberikan informasi bagi masyarakat dan bermanfaat
untuk pengembangan ilmu pengetahuan bagi kita semua.
Medan, 12 Juni 2014
Penyusun,
Eva Martia
3
DAFTAR ISI
KATA PENGANTAR ......................................................................................................................................................... 2
BAB I...................................................................................................................................................................................... 4
PENDAHULUAN ................................................................................................................................................................ 4
I.1. Latar belakang ................................................................................................................................................... 4
I.2. Rumusan masalah ........................................................................................................................................... 5
I.3. Tujuan Penyusunan proposal ................................................................................................................... 5
BAB II .................................................................................................................................................................................... 5
Landasan Teori ............................................................................................................................................................... 5
2.1. Pengertian Grafika Komputer ............................................................................................................... 6
2.2. Elemen Dasar Grafika ............................................................................................................................... 7
2.3. Sejarah Perkembangan Grafika Komputer ................................................................................... 8
2.4. Open GL ............................................................................................................................................................ 9
2.5. Objek 2 Dimensi ........................................................................................................................................ 17
2.6. Objek 3 Dimensi ........................................................................................................................................ 40
BAB III ................................................................................................................................................................................ 15
HASIL PRATIKUM ......................................................................................................................................................... 15
3.1. Primitive Drawing ....................................................................................................................................... 15
3.2. Contoh 2 Dimensi .................................................................................................................................... 16
3.3. Contoh 3 Dimensi .................................................................................................................................... 39
BAB IV ................................................................................................................................................................................ 61
ANALISA PRATIKUM ................................................................................................................................................... 61
PENUTUP .......................................................................................................................................................................... 62
A. KESIMPULAN ....................................................................................................................................................... 62
B. SARAN ..................................................................................................................................................................... 62
DAFTAR PUSTAKA ...................................................................................................................................................... 63
4
BAB I
PENDAHULUAN
1.1.Latar Belakang
Perkembangan grafika komputer menuntut para pengembang sistem aplikasi grafika
komputer untuk dapat mengembangkan suatu informasi yang dilengkapi dengan visualisasi
dan animasi, agar dapat lebih mudah dipahami oleh pihak yang menggunakan sistem tersebut.
Grafika komputer telah menunjukkan kemajuan yang pesat dalam pengembangan berbagai
aplikasi untuk menghasilkan gambar. Grafika komputer digunakan untuk menunjang
berbagai bidang dengan teknologi grafika berbasis komputer. Penggunaan grafika komputer
telah lama digunakan dalam beberapa macam aplikasi, diantaranya pendidikan, kedokteran,
fisika, matematika, multimedia, dan lain-lain. Pada saat ini grafika komputer sudah
digunakan pada bidang sains, engineering, kedokteran, bisnis, industri, pemerintahan, seni,
hiburan, iklan, pendidikan, dan lain-lain. Oleh karena itu, sudah semakin banyak pula bahasa
pemrograman yang dilengkapi dengan tools/library pembuatan grafik Salah satu tools/library
pembuatan aplikasi grafik adalah OpenGL (Open Graphics Library). OpenGL(Open Graphics
Library) adalah suatu spefikasi grafik yang low-level yang menyediakan fungsi untuk
pembuatan grafik primitif termasuk titik, garis, dan lingkaran. OpenGL digunakan untuk
mendefinisikan suatu objek, baik objek 2 dimensi maupun objek 3 dimensi. Dan makalah
yang disampaikan kali ini khusus membahas mengenai perancangan bangun 3 dimensi
menggunakan Visual Basic 6.0
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 obyek 3D menjadi lebih mudah, facial capture membuat animasi
ekspresi 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 siap pakai (pre-made) serta sistem template 3D
mempercepat desain suatu model objek tiga dimensi.
5
1.2. Rumusan Masalah
Dari latar belakang yang telah dipaparkan di atas, penulis dapat merumuskan masalah yang
akan dikaji yaitu:
1. Jelaskan tentang pengertian grafika komputer
2. Bagaimana sejarah perkembangan grafika komputer?
3. Bagaimana membuat grafik tiga dimensi dari suatu objek yang dapat dilihat dari berbagai
sudut pandang.
1.3.Tujuan Masalah
Adapun tujuan dari penulisan makalah ini untuk mengetahui:
1. Menjelaskan Pengertian grafika komputer
2. Sejarah perkembangan grafika komputer
3. Dapat Merancang pemodelan objek 3D (tiga dimensi) menggunakan OpenGL.
4. Dapat Membuat simulasi objek 3D (tiga dimensi) menggunakan OpenGL.
5. Dapat Menjelaskan Fungsi-fungsi OpenGL
6
BAB II
LANDASAN TEORI
2.1. PENGERTIAN GRAFIKA KOMPUTER
Grafika komputer (Inggris: Computer graphics) adalah bagian dari ilmu komputer
yang berkaitan dengan pembuatan dan manipulasi gambar (visual) secara digital. Bentuk
sederhana dari grafika komputer adalah grafika komputer 2D yang kemudian berkembang
menjadi grafika komputer 3D, pemrosesan citra (image processing), dan pengenalan pola
(pattern recognition). Grafika computer sering dikenal juga dengan istilah visualisasi data.
Grafik meliputi gambar dan pencitraan lain yang dihasilkan oleh komputer berbentuk garis,
lengkungan, kurva dan sebagainya. Komputer dapat menghasilkan pencitraan dalam sejumlah
piksel, dan printer dot matrix akan mencetak citra/gambar tersebut dalam sejumlah titik.
Grafika komputer adalah bidang dari komputasi visual dimana penggunaan komputer
akan menghasilkan gambar visual secara sintetis dan mengintegrasikan atau mengubah
informasi mengenai ruang dan visual yang dicontohkan dari dunia nyata.
Grafis (graphic) adalah presentasi visual dari sebuah image yang bertujuan memberi
tanda, informasi, ilustrasi atau sekedar hiburan. Image (citra atau gambaran dapat diartikan
sebagai kesan visual yang ditangkap oleh indera penglihatan ketika mengamati suatu objek.
Manusia mentransformasi image ke dalam berbagai jenis media seperti kertas, kanvas, layar
komputer atau jenis lainnya sehingga menghasilkan presentasi dari image itu. Grafis
komputer membutuhkan dukungan piranti grafis. Piranti grafis adalah segala peripheral dan
perangkat lunak komputer yang bisa menjadikan komputer memiliki kemampuan untuk
menampilkan serta memanipulasi image digita (http://wawan.Sman1cepu.sch.id).
Komputer grafik (computer graphics) adalah seperangkat alat yang terdiri dari
hardware dan software untuk membuat gambar, foto, grafik atau citra realitic untuk seni,
game, dan film animasi.Dalam komputer grafik terdapat elemen dasar yaitu titik, garis, segi
empat dan lingkaran. Elemen dasar itu dapat dikombinasikan untuk menghasilkan objek yang
lebih kompleks.
Bagian dari grafika komputer meliputi:
1. Geometri :mempelajari cara menggambarkan permukaan bidang untuk menciptakan gambar
2D atau 3D
2. Animasi :cara menggambarkan dan memanipulasi gerakan untuk menampilkan tingkah laku
objek
7
3. Rendering :mempelajari algoritma untuk menampilkan efek cahaya agar gambar yang
diproduksi lebih solid dari model yang dibentuk
4. Citra (imaging) :mempelajari cara pengambilan dan penyuntingan gambar dengan cara di
desain dengan tangan atau hasil dari scan
Grafis komputer adalah suatu bidang ilmu yang mempelajari bagaimana membangun
grafik (gambar) baik 2D maupun 3D yang kelihatan nyata dengan menggunakan komputer.
Salah satu bidang grafika komputer yang sangat terkenal adalah desain grafis (Nana
Ramadijanti). Komputer grafis 2D adalah generasi komputer berbasis gambar digital.
Komputer grafis 2D terutama digunakan dalam aplikasi yang pada awalnya dikembangkan
pada saat pencetakan tradisional dan teknologi menggambar seperti kartografi, gambar
teknik, iklan dan lain-lain. Dalam aplikasi, gambar 2D bukan hanya dari objek dunia nyata
tetapi artefak independen dengan nilai tambah pembuatnya. Komputer grafis 3D adalah
representasi dari data geometrik 3 dimensi sebagai hasil dari pemrosesan dan pemberian efek
cahaya terhadap grafika komputer 2D. Hasil ini kadang kala ditampilkan secara waktu nyata
(real time) untuk keperluan animasi.
2.2. Elemen Dasar Grafika
Ada beberapa elemen dasar dari grafika komputer antara lain:
1. Point
2. Polyline
3. Polygon
4. Filled Polygon ( Face )
5. Gradate Polygon
Point
Point adalah sebuah titik yang digunakan untuk membangun obyek. Setiap titik dalam obyek
3 dimensi memiliki nilai dalam x, y dan z.
Polyline
Polyline adalah sebuah fungsi yang dibentuk dari beberapa garis yang saling berhubungan
dan membentuk sebuh kurva yang terbuka.
Polygon
Polygon adalah suatu fungsi yang mirip dengan polyline hanya saja hasilnya adalah kurva
tertutup, sedangkan polyline hasilnya kurva terbuka.
8
Filled Polygon (Face)
Filled Polygon adalah sebuah polygon yang bagian dalamnya diwarnai atau dipenuhi dengan
sebuah warna tertentu. Filled polygon biasanya digunakan sebagai face dari pembentukan
obyek–obyek 3 Dimensi.
Gradate Polygon
Gradate polygon adalah sebuah polygon yang bagian dalamnya memiliki warna – warna yang
bergradasi dari satu warna ke warna yang lainnya.
2.3. Sejarah Perkembangan Grafika Komputer
Grafika komputer adalah disiplin ilmu yang menghasilkan picture atau image dengan
menggunakan komputer telah secara luas digunakan. Sejarah perkembangan grafika
komputer diawali pada tahun 1950-an (Chandra T & Simarmata J).
- Pada tahun 1950-an, keluarannya via teletypes, lineprinte dan Cathode Ray Tube (CRT).
Suatu picture bisa direproduksi menggunakan karakter gelap dan terang. Tahun 1950: Ben
Laposky pertama kali menciptakan gambar grafis yaitu osiloskop yang dihasilkan oelh suatu
mesin (analog) elektronik.
- Pada tahun 1960-an merupakan permulaan grafik interaktif modern, keluarannya adalah
grafis vektor dan grafik interaktif. Kemajuan dalam komputer grafis adalah berasal dari
seorang mahasiswa MIT, Ivan Sutherland. Tahun 1963 Ivan Sutherland menciptakan program
Sketchpad yaitu sebuah sistem komunikasi grafis manusia dan mesin dengan fitur-fiturnya
adalah:
o Pop up menu
o Penggambaran constraint based
o Pemodelan hirarki
o Utilized lightpen untuk interaksi.
- Pada awal tahun 1970-an, keluaran menggunakan raster display, kemampuan grafik masih
tipis dan tebal. Tahun 1973, John Whitney. Jr. And Gary Demos – “Westworld”, adalah film
yang pertama kali menggunakan grafika komputer.
- Pada tahun 1980-an keluarannya adalah grafik raster built-in, gambar bitmap dan pixel.
Biaya-biaya komputer pribadi berkurang secara drastis, trackball dan mouse menjadi alat
interaktif yang baku. Tahun 1984, Waveron tech. –Polhemus, perangkat lunak pertama grafik
3D. Tahun 1987: IBM – VGA, dikenalkan Video graphics Array. Tahun 1989 dibentuk
Video Electronics Standards Association (VESA)- SVGA, Super VGA
9
- Pada tahun 1990-an, sejak diperkenalkan VGA dan SVGA, komputer pribadi bisa dengan
mudah menampilkan gambar hidup dan gambar photo-realistik. Gambar 3D renderings
menjadi kemajuan utama dan mampu merangsang aplikasi grafik sinematik. Tahun 1993,
University Of Illionis – Mosaic, Web browser grafik pertama.
- Pada tahun 2003: ID Software – mesin grafik Doom
2.4. Open GL
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. Keuntungan dari pendekatan ini adalah bahwa hal itu
memungkinkan fleksibilitas yang besar dalam proses menghasilkan gambar. Aplikasi ini
gratis untuk trade-off rendering kecepatan dan kualitas gambar dengan mengubah langkah-
langkah di mana foto tersebut diambil. Cara termudah untuk menunjukkan kekuatan dari
antarmuka prosedural adalah untuk dicatat bahwa antarmuka deskriptif dapat dibangun di
atas antarmuka prosedural, tetapi tidak sebaliknya. Pikirkan OpenGL sebagai "bahasa
assembly grafis": potongan-potongan fungsi OpenGL dapat dikombinasikan sebagai building
blocks untuk menciptakan teknik inovatif dan menghasilkan kemampuan baru grafis. Aspek
kedua adalah bahwa spesifikasi OpenGL tidak tepat piksel. Ini berarti bahwa dua
implementasi yang berbeda OpenGL sangat tidak mungkin untuk membuat gambar yang
sama persis. Hal ini memungkinkan OpenGL.
Cara Kerja OpenGL
OpenGL lebih mengarah pada prosedural daripada sebuah deskriptif API grafis.
Untuk mendeskripsikan scene dan bagaimana penampilannya, sebenarnya programer lebih
tahu untuk menentukan hal-hal yang dibutuhkan untuk menghasilkan efek yang diinginkan.
Langkah tersebut termasuk memanggil banyak perintah OpenGL, perintah tersebut digunakan
untuk menggambarkan grafis primitive seperti titik, garis dan poligon dalam tiga dimensi.
Sebagai tambahan, OpenGL mendukung lighting, shading, texture, mapping, blending,
transparancy, dan banyak kemampuan efek khusus lainnya. OpenGL mempunyai banyak
fungsi dan penggunaan perintah yang sangat luas. Penggunaan OpenGL membutuhkan
library tambahan yang harus di letakkan pada direktori sistem dari windows (OS).
10
Gambar 6. Sistem visualisasi real time
2.5. Objek 2 Dimensi
Grafik komputer 2D adalah pembuatan objek gambar dengan menggunakan 2 titik
sebagai acuannya yaitu sumbu x dan y. Grafik 2D ini dapat digunakan dalam berbagai
aplikasi yang pada awalnya dikembangkan pada teknologi cetak tradisional dan gambar,
seperti tipografi, kartografi, gambar teknik, iklan, dan lain-lain.
Grafik komputer 2D ini merupakan langkah paling awal dalam membentuk model
objek yang akan dibangun dalam grafik komputer 3D. Dalam aplikasi, gambar dua dimensi
adalah bukan hanya representasi dari objek dunia nyata, tetapi sebuah artefak independen
dengan nilai tambah semantik. Keseluruhan obyek 2D dapat dimasukkan dengan jumlah lebih
dari satu, model yang akan dibentuk sesuai dengan kebutuhan. Tahap rekayasa hasil obyek
2D dapat dilakukan dengan aplikasi program grafis seperti Adobe Photoshop, Corel Draw,
dan lain sebagainya.
2.6. Objek 3 Dimensi
Obyek 3-D adalah sekumpulan titik-titik 3-D (x,y,z) yang membentuk luasan-luasan (face)
yang digabungkan menjadi satu kesatuan. Face adalah gabungan titik-titik yang membentuk
luasan tertentu atau sering dinamakan dengan sisi.
11
Sistem Koordinat 3 Dimensi
Titik-titik yang membentuk obyek:
Titik 0 (0,150,0)
Titik 1 (100,0,0)
Titik 2 (0,0,100)
Titik 3 (-100,0,0)
Titik 4 (0,0,-100)
Fungsi OpenGL 3D
Membersihkan Windows
Pada komputer, memory untuk menampilkan gambar biasanya diisi dengan gambar yang
berasal dari perintah gambar paling akhir, jadi perlu dibersihkan dengan warna latar belakang
sebelum digambar lagi. Contoh berikut ini perintah yang digunakan untuk membersihkan
layar latar belakang dengan warna hitam dan buffer apa yang akan dibersihkan.
glClearColor 0, 0, 0, 0
12
glClear GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT
Spesifikasi Warna
Pada OpenGL mendeskripsikan objek dengan warna objek adalah proses yang berjalan
sendiri-sendiri. Sebelum warna diubah maka semua objek yang digambar sesudah perintah
tersebut akan menggunakan warna terakhir yang terdapat pada coloring scheme. Untuk warna
digunakan perintah glColor3f. Contoh berikut menunjukkan urutan langkah dalam proses
spesifikasi warna sebelum objek digambar. Warna yang ditampilkan adalah warna merah.
glColor3f 1, 0, 0
Memaksa Proses Menggambar Sampai Selesai
Kebanyakan sistem grafik modern sudah menggunakan sistem graphics pipeline. Dimana
CPU utama memberikan issue perintah menggambar dan hardware lain yang melakukan
transformasi, clipping, shading, texturing dan lain-lain. Pada arsitektur yang demikian,
proses tidak dilakukan pada satu computer karena setiap komputer mempunyai tugas sendiri.
CPU utama tidak harus menunggu proses pada masing-masing komputer tadi selesai, tapi
bisa dengan memberikan issue perintah gambar yang berikutnya. Untuk inilah OpenGL
menyediakan perintah glFlush yang memaksa client untuk segera mengirim paket network
walaupun belum penuh.
glFlush
Menggambar di Bidang Tiga Dimensi
Untuk menggambar grafik jenis apapun pada komputer biasanya dimulai dengan pixel. Pixel
adalah elemen terkecil dari layar monitor yang mempunyai atribut warna dan posisi.
Sedangkan untuk membentuk garis, poligon, objek dan lain-lain dapat dilakukan melalui
urutan pixel yang berbeda. Menggambar dengan menggunakan OpenGL mempunyai
perbedaan dengan bahasa lain, yaitu tidak perlu memikirkan koordinat layar secara fisik
tetapi hanya perlu menspesifikasikan posisi koordinat dengan volume penglihatan. OpenGL
memikirkan sendiri bagaimana caranya menggambar titik, garis, dan lainnya yang berada
dalam ruang tiga dimensi ke gambar dua dimensi pada layar komputer.
Area gambar yang dibatasi ini adalah ruang koordinat kartesian yang mempunyai range dari -
100 hingga 100 untuk sumbu x, y dan z. Secara sederhana bidang ini dapat dianggap sebagai
bidang gambar untuk perintah-perintah OpenGL.
13
Untuk menggambar titik digunakan suatu perintah OpenGL yaitu : glVertex. Fungsi ini dapat
mempunyai 2 sampai 4 parameter dari berbagai macam tipe data. Sebagai contoh perintah
glVertex di bawah ini akan menspesifikasikan sebuah titik pada posisi 4 sumbu x, 4 sumbu y
dan 0 untuk sumbu z. glVertex3f 4, 4, 0. Setelah diketahui cara untuk menspesifikasikan
sebuah titik di ruang pada OpenGL. Selanjutnya yang harus ditambahkan adalah informasi
tambahan mengenai titik tersebut, apakah titik tersebut akhir dari sebuah garis, atau
merupakan sebuah titik sudut dari sebuah poligon atau lainnya, karena definisi geometrik dari
sebuah vertex sebenarnya bukanlah hanya sebuah titik pada layar tetapi lebih merupakan
sebuah titik dimana terjadi interseksi antara dua buah garis atau kurva.
Primitif adalah interpretasi sejumlah set atau deretan titik pada sebuah bentuk yang digambar
pada layar. Pada OpenGL terdapat sepuluh macam primitif dari mulai menggambar sebuah
titik hingga poligon. Untuk itu digunakan perintah glBegin sebagai cara memberitahu
OpenGL untuk memulai menginterpretasi sederetan titik sebagai salah satu bentuk primitif.
Dan untuk mengakhiri deretan titik ini digunakan perintah glEnd. Sebagai Contoh sebagai
berikut :
glBegin bmPolygon // spesifikasikan titik sebagai primitif
glVertex3f 4, 4, 0 // spesifikasikan posisi titik
glEnd // mengakhiri perintah menggambar titik
Fungsi untuk keperluan Transformasi
1. Fungsi Translasi (Translation)
Translasi merupakan bentuk transformasi yang memindahkan posisi suatu objek, baik pada
sumbu x, sumbu y, atau sumbu z. Fungsi yang digunakan untuk melakukan translasi adalah :
glTranslatef Tx, Ty, Tz
Parameter Tx digunakan untuk menentukan arah dan seberapa jauh suatu benda akan
dipindahkan berdasarkan sumbu x. Parameter Ty digunakan untuk menentukan arah dan
seberapa jauh suatu benda akan dipindahkan berdasarkan sumbu y. Sedangkan parameter Tz
digunakan untuk menentukan arah dan seberapa jauh suatu benda akan dipindahkan
berdasarkan sumbu z.
Contohnya :
glTranslatef 2, 2, 2
14
2. Fungsi Rotasi (Rotation)
Rotasi merupakan bentuk transformasi yang digunakan untuk memutar posisisuatu benda.
Fungsi yang digunakan untuk melakukan rotasi ialah
glRotatef(θ, Rx, Ry, Rz)
Parameter yang dibutuhkan pada fungsi tersebut ada 4 macam, yaitu parameter θ untuk besar
sudut putaran, parameter Rx untuk putaran berdasarkan sumbu x, parameter Ry untuk putaran
berdasarkan sumbu y, dan parameter Rz untuk putaran berdasarkan sumbu z. Jika parameter θ
bernilai postif, maka objek akan diputar berlawanan arah jarum jam. Sedangkan jika
parameter θ bernilai negatif, maka objek akan diputar searah jarum jam.
Contohnya :
glRotatef -30, 2, 2, 1
3. Fungsi Skala (Scalling)
Skalasi merupakan bentuk transformasi yang dapat mengubah ukuran (besar-kecil) suatu
objek. Fungsi yang digunakan untuk melakukan skalasi ialah :
glScalef(Sx, Sy, Sz)
Perubahan ukuran suatu objek diperoleh dengan mengalikan semua titik atau atau vertex pada
objek dengan faktor skala pada masing-masing sumbu (parameter Sx untuk sumbu x, Sy
untuk sumbu y, dan Sz untuk sumbu z). Contohnya :
glScalef(2, 2, 2)
15
BAB III
HASIL PRATIKUM
2.7. Primitive Drawing
Primitive Drawing merupakan cara mudah untuk menggambar pada layar monitor
menggunakan teori geometri sederhana. Macam-macam primitive drawing seperti
menggambar sebuah titik, garis, atau gabungan antar keduanya.
Penghasilan gambar pada grafika komputer menggunakan primitif grafik dasar. Primitif ini
memudahkan untuk menggambar pada layar monitor sebagaimana penggunaan persamaan
geometrik sederhana.
Contoh primitif grafik dasar adalah :
o Titik
o Garis, Segiempat
o Kurva, Lingkaran, ellipse, kurva bezier, kurva lainnya
o Fill area
o Text
Gambar 1.Primitif Grafik
Objek kompleks dapat dibuat dengan kombinasi dari primitif ini. Adapun contoh grafik
primitif yang lain adalah :
o Poligaris yaitu urutan garis lurus yang saling terhubung.
o Teks adalah bentuk bahasa tulisan dengan simbol-simbol tertentu. Teks merupakan
kumpulan lebih dari dua karakter.
o Citra raster adalah gambar yang dibuat dengan piksel yang membedakan bayangan dan
warna. Citra raster disimpan dalam komputer sebagai larik bernilai numerik. Larik tersebut
dikenal sebagai piksel map atau bitmap. Ada tiga cara untuk menghasilkan citra grafik yaitu
16
Citra didisain dengan tangan, Citra yang didapat dari perhitungan dan Citra yang discan.
Pemaparan citra raster dinyatakan oleh piksel dengan video displays (Cathod-ray Tube CRT),
flat panel dispalys (LCD), hardcopy (printer laser, dot matrix printers, ink-jet printers).
Contoh proses pemaparan permukaan adalah citra yang ditangkap lalu disimpan di frame
buffer, kemudian digunakan untuk mewarnai sebuah titik pada permukaan pemapar.
Selanjutnya proses scan di CRT. Frame buffer adalah matriks 2 dimensi yang mewakili piksel
pada pemapar. Ukuran matriks harus cukup untuk menyimpan kedalam warna pemapar untuk
semua piksel. Sebagai contoh pemapar (monitor) berresolusi 1280 x 1024 mempunya
kedalaman warna 24 bit (~16 juta warna) membutuhkan ruang simpan sekitar 4 Mb.
o Piksel dan Bitmap. Jumlah bit yang digunakan untuk mewakili warna/bayangan dari masin-
masing piksel (picture element = pixel). 4 bit/piksel = 24 = 16 level abu-abu
IMPLEMENTASI
Contoh program untuk merepresentasikan model obyek segiempat 2D. OpenGL memiliki
beberapa komponen dasar untuk merepresentasikan suatu obyek. Komponen dasar tersebut,
disebut sebagai OpenGL Geometric primitives.
Setiap obyek harus dimodelkan sebagai kombinasi dari komponen-komponen dasar tersebut.
Sebagai contoh, obyek segiempat dimodelkan dengan menggunakan komponen dasar
GL_POLYGON. Obyek tersebut dapat pula dimodelkan dengan komponen dasar
GL_TRIANGLES atau pun GL_QUAD.
Dalam OpenGL, menggambar geometric primitives selalu dilakukan di antara fungsi
Setiap OpenGL geometric primitive dispesifikasi oleh urutan vertex-vertex-nya dalam bentuk
urutan koordinat homogenous. Koordinat homogenous adalah koordinat dalam bentuk ( x, y,
z, w ). Setiap primitive memiliki standar tentang bagaimana vertex-vertex diorganisasikan.
17
Bentuk umum coding untuk pembuatan garis :
glBegin(GL_LINES); /* Ingin menggambar garis */
glVertex2(tipe_data)(koordinat X1, koordinat Y1); /* menyatakan
sejumlah titik */
glVertex2(tipe_data)(koordinat X2, koordinat Y2); /* menyatakan
sejumlah titik */
glEnd(); /* Akhir menggambar titik */
Bentuk coding untuk pembuatan kotak :
glBegin(GL_POLYGON); // awal membuat objek kotak
glVertex2d(x0,y0); //menyatakan sejumlah titik
glVertex2d(x1,y1); //menyatakan sejumlah titik
glVertex2d(x2,y2); //menyatakan sejumlah titik
glVertex2d(x3,y3); //menyatakan sejumlah titik
glVertex2d(x4,y4); //menyatakan sejumlah titik
glVertex2d(x5,y5); //menyatakan sejumlah titik
glVertex2d(x6,y6); //menyatakan sejumlah titik
glVertex2d(x7,y7); //menyatakan sejumlah titik
glEnd(); // Akhir menggambar tit
3.2. Contoh Objek 2D
1) Bunga
Gambar : Hasil Percobaan
18
Contoh Program yang menampilkan Bunga:
#include <GL/glut.h>
#include <math.h>
typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;
}color_t;
void setColor (color_t col)
{
glColor3f(col.r, col.g, col.b);
}
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_POLYGON);
for (i=0; i<n; i++)
{
glVertex2i(pnt[i].x,pnt[i].y);
}
glEnd();
}
19
void fillPolygon (point2D_t pnt[], int n, color_t color)
{
int i;
setColor(color);
glBegin(GL_POLYGON);
for (i=0; i<n; i++)
{
glVertex2f(pnt[i].x, pnt[i].y);
}
glEnd();
}
void userdraw()
{
point2D_t
batang[4]={{-5,-190},{-5,0},{5,0},{5,-190}};
color_t biru ={0,0,1};
fillPolygon(batang,4, biru);
drawPolygon(batang,4);
point2D_t
pot[4]={{-60,-190},{60,-190},{30,-240},{-30,-240}};
color_t hitam ={0,0,0};
fillPolygon(pot,4, hitam);
drawPolygon(pot,4);
point2D_t
pot2[6]={{-80,-160},{-50,-160},{-50,-190},{-60,-190},{-60,-170},{-80,-170}};
color_t hitam3 ={0,0,0};
fillPolygon(pot2,4, hitam3);
20
drawPolygon(pot2,4);
point2D_t
pot3[6]={{80,-160},{50,-160},{50,-190},{60,-190},{60,-170},{80,-170}};
color_t hitam2 ={0,0,0};
fillPolygon(pot3,4, hitam2);
drawPolygon(pot3,4);
static int tick=0;
point2D_t shape[360];
double srad,r;
for(int s=0; s<360; s++)
{
srad =(s+tick)*3.14/360;
r=80*sin(200*srad);
shape [s].x = (float)(r*cos(100*srad));
shape [s].y = (float)(r*sin(100*srad));
color_t merah ={1,0,0};
fillPolygon(shape,1, merah);
}
drawPolygon(shape, 360);
}
void display(void)
{
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char **argv)
{
21
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;
}
2. Diamond
Gambar: Hasil Percobaan
22
Contoh Program Yang Menampilkan Diamond
#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);
glVertex2i(200,200);
glVertex2i(200,50);
glVertex2i(300,250);
glVertex2i(200,50);
glEnd();
}
void display(void)
{
//BERSIH LAYAR
23
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(1.0f,0.0f,1.0f,0.0f);
gluOrtho2D(0.,440.,0.,300.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
3. Rumah Tingkat
24
Gambar: Hasil Percobaan
Contoh Program Yang Menampilkan Objek Rumah
#include <GL/glut.h>
typedef struct
{
int x,y;
}
point2D_t;
typedef struct
{
float r,g,b;
}
color_t;
void setColor (color_t col)
{
glColor3f(col.r, col.g, col.b);
25
}
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i<n; i++)
{
glVertex2i(pnt[i].x,pnt[i].y);
}
glEnd();
}
void fillPolygon (point2D_t pnt[], int n, color_t color)
{
int i;
setColor(color);
glBegin(GL_POLYGON);
for (i=0; i<n; ++i)
{
glVertex2f(pnt[i].x, pnt[i].y);
}
glEnd();
}
void userdraw(void)
{
point2D_t
petak1[4]={{450,750},{900,750},{900,550},{450,550}};
drawPolygon(petak1,4);
point2D_t
jendela5[4]={{500,750},{600,750},{600,700},{500,700}};
26
drawPolygon(jendela5,4);
point2D_t
kaca5[4]={{500,750},{600,750},{570,730},{470,730}};
drawPolygon(kaca5,4);
point2D_t
jendela6[4]={{750,750},{850,750},{850,700},{750,700}};
drawPolygon(jendela6,4);
point2D_t
kaca6[4]={{750,750},{850,750},{830,730},{730,730}};
drawPolygon(kaca6,4);
point2D_t
pintu3[4]={{600,650},{650,650},{650,550},{600,550}};
drawPolygon(pintu3,4);
point2D_t
pintu4[4]={{650,650},{700,650},{700,550},{650,550}};
drawPolygon(pintu4,4);
point2D_t
kunci3[4]={{640,600},{650,600},{650,590},{640,590}};
drawPolygon(kunci3,4);
point2D_t
kunci4[4]={{650,600},{660,600},{660,590},{650,590}};
drawPolygon(kunci4,4);
27
point2D_t
segitiga[3]={{350,750},{670,950},{1000,750}};
drawPolygon(segitiga,3);
point2D_t
pipa1[4]={{500,950},{550,950},{550,870},{500,840}};
drawPolygon(pipa1,4);
point2D_t
tangan1[4]={{450,600},{450,570},{430,550},{400,550}};
drawPolygon(tangan1,4);
point2D_t
blankon1[4]={{400,550},{430,550},{430,500},{400,500}};
drawPolygon(blankon1,4);
point2D_t
blankon2[4]={{430,550},{450,550},{450,500},{430,500}};
drawPolygon(blankon2,4);
point2D_t
blankon3[4]={{450,550},{470,550},{470,500},{450,500}};
drawPolygon(blankon3,4);
point2D_t
blankon4[4]={{470,550},{500,550},{500,500},{470,500}};
drawPolygon(blankon4,4);
point2D_t
blankon5[4]={{500,550},{530,550},{530,500},{500,500}};
28
drawPolygon(blankon5,4);
point2D_t
blankon6[4]={{530,550},{550,550},{550,500},{530,500}};
drawPolygon(blankon6,4);
point2D_t
blankon7[4]={{550,550},{570,550},{570,500},{550,500}};
drawPolygon(blankon7,4);
point2D_t
blankon8[4]={{600,550},{630,550},{630,500},{600,500}};
drawPolygon(blankon8,4);
point2D_t
blankon9[4]={{630,550},{650,550},{650,500},{630,500}};
drawPolygon(blankon9,4);
point2D_t
blankon10[4]={{650,550},{670,550},{670,500},{650,500}};
drawPolygon(blankon10,4);
point2D_t
blankon11[4]={{670,550},{700,550},{700,500},{670,500}};
drawPolygon(blankon11,4);
point2D_t
blankon12[4]={{700,550},{730,550},{730,500},{700,500}};
drawPolygon(blankon12,4);
29
point2D_t
blankon13[4]={{730,550},{750,550},{750,500},{730,500}};
drawPolygon(blankon13,4);
point2D_t
blankon14[4]={{750,550},{770,550},{770,500},{750,500}};
drawPolygon(blankon14,4);
point2D_t
blankon15[4]={{770,550},{800,550},{800,500},{770,500}};
drawPolygon(blankon15,4);
point2D_t
blankon16[4]={{800,550},{830,550},{830,500},{800,500}};
drawPolygon(blankon16,4);
point2D_t
blankon17[4]={{830,550},{850,550},{850,500},{830,500}};
drawPolygon(blankon17,4);
point2D_t
blankon18[4]={{850,550},{870,550},{870,500},{850,500}};
drawPolygon(blankon18,4);
point2D_t
blankon19[4]={{870,550},{900,550},{900,500},{870,500}};
drawPolygon(blankon19,4);
point2D_t
blankon20[4]={{900,550},{930,550},{930,500},{900,500}};
30
drawPolygon(blankon20,4);
point2D_t
blankon21[4]={{930,550},{950,550},{950,500},{930,500}};
drawPolygon(blankon21,4);
point2D_t
tangan2[4]={{900,570},{900,600},{950,550},{930,550}};
drawPolygon(tangan2,4);
point2D_t
petak[4]={{350,400},{1000,400},{1000,100},{350,100}};
drawPolygon(petak,4);
point2D_t
atap[4]={{350,500},{950,500},{1100,400},{250,400}};
drawPolygon(atap,4);
point2D_t
atap1[4]={{350,500},{400,500},{370,450},{300,450}};
drawPolygon(atap1,4);
point2D_t
atap2[4]={{400,500},{500,500},{470,450},{370,450}};
drawPolygon(atap2,4);
point2D_t
atap3[4]={{500,500},{600,500},{570,450},{470,450}};
drawPolygon(atap3,4);
31
point2D_t
atap4[4]={{600,500},{700,500},{670,450},{570,450}};
drawPolygon(atap4,4);
point2D_t
atap5[4]={{700,500},{800,500},{770,450},{670,450}};
drawPolygon(atap5,4);
point2D_t
atap6[4]={{800,500},{900,500},{870,450},{770,450}};
drawPolygon(atap6,4);
point2D_t
atap7[4]={{900,500},{990,470},{970,450},{870,450}};
drawPolygon(atap7,4);
point2D_t
atap8[4]={{300,450},{370,450},{350,400},{250,400}};
drawPolygon(atap8,4);
point2D_t
atap9[4]={{370,450},{470,450},{450,400},{350,400}};
drawPolygon(atap9,4);
point2D_t
atap10[4]={{470,450},{570,450},{550,400},{450,400}};
drawPolygon(atap10,4);
point2D_t
atap11[4]={{570,450},{670,450},{650,400},{550,400}};
32
drawPolygon(atap11,4);
point2D_t
atap12[4]={{670,450},{770,450},{750,400},{650,400}};
drawPolygon(atap12,4);
point2D_t
atap13[4]={{770,450},{870,450},{850,400},{750,400}};
drawPolygon(atap13,4);
point2D_t
atap14[4]={{870,450},{970,450},{950,400},{850,400}};
drawPolygon(atap14,4);
point2D_t
lampu[6]={{650,400},{670,400},{670,370},{700,350},{620,350},{650,370}};
drawPolygon(lampu,6);
point2D_t
lampu1[4]={{650,350},{670,350},{670,330},{650,330}};
drawPolygon(lampu1,4);
point2D_t
jendela1[4]={{400,300},{450,300},{450,200},{400,200}};
drawPolygon(jendela1,4);
point2D_t
kaca1[4]={{400,300},{450,300},{430,230},{370,230}};
drawPolygon(kaca1,4);
33
point2D_t
jendela2[4]={{500,300},{550,300},{550,200},{500,200}};
drawPolygon(jendela2,4);
point2D_t
kaca2[4]={{500,300},{550,300},{530,230},{470,230}};
drawPolygon(kaca2,4);
point2D_t
jendela3[4]={{800,300},{850,300},{850,200},{800,200}};
drawPolygon(jendela3,4);
point2D_t
kaca3[4]={{800,300},{850,300},{830,230},{770,230}};
drawPolygon(kaca3,4);
point2D_t
jendela4[4]={{900,300},{950,300},{950,200},{900,200}};
drawPolygon(jendela4,4);
point2D_t
kaca4[4]={{900,300},{950,300},{930,230},{870,230}};
drawPolygon(kaca4,4);
point2D_t
jaring1[8]={{400,350},{450,350},{450,330},{400,330},{400,350},{450,330},{450,350},{400,330}};
drawPolygon(jaring1,8);
point2D_t
jaring2[8]={{500,350},{550,350},{550,330},{500,330},{500,350},{550,330},{550,350},{500,330}};
34
drawPolygon(jaring2,8);
point2D_t
jaring3[8]={{800,350},{850,350},{850,330},{800,330},{800,350},{850,330},{850,350},{800,330}};
drawPolygon(jaring3,8);
point2D_t
jaring4[8]={{900,350},{950,350},{950,330},{900,330},{900,350},{950,330},{950,350},{900,330}};
drawPolygon(jaring4,8);
point2D_t
pintu1[4]={{650,250},{700,250},{700,100},{650,100}};
drawPolygon(pintu1,4);
point2D_t
pintu2[4]={{700,250},{750,250},{750,100},{700,100}};
drawPolygon(pintu2,4);
point2D_t
kunci1[4]={{690,200},{700,200},{700,190},{690,190}};
drawPolygon(kunci1,4);
point2D_t
kunci2[4]={{700,200},{710,200},{710,190},{700,190}};
drawPolygon(kunci2,4);
point2D_t
lantai1[4]={{350,100},{450,100},{400,40},{300,40}};
drawPolygon(lantai1,4);
35
point2D_t
lantai2[4]={{450,100},{550,100},{500,40},{400,40}};
drawPolygon(lantai2,4);
point2D_t
lantai3[4]={{550,100},{650,100},{600,40},{500,40}};
drawPolygon(lantai3,4);
point2D_t
lantai5[4]={{650,100},{750,100},{700,40},{600,40}};
drawPolygon(lantai5,4);
point2D_t
lantai6[4]={{750,100},{850,100},{800,40},{700,40}};
drawPolygon(lantai6,4);
point2D_t
lantai7[4]={{850,100},{950,100},{900,40},{800,40}};
drawPolygon(lantai7,4);
point2D_t
lantai8[4]={{950,100},{1000,100},{950,40},{900,40}};
drawPolygon(lantai8,4);
point2D_t
pohon1[4]={{150,200},{200,200},{200,40},{150,40}};
drawPolygon(pohon1,4);
point2D_t
daun1[3]={{50,200},{170,300},{300,200}};
36
drawPolygon(daun1,3);
point2D_t
daun2[3]={{100,300},{170,370},{250,300}};
drawPolygon(daun2,3);
point2D_t
daun3[3]={{130,370},{170,430},{220,370}};
drawPolygon(daun3,3);
}
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);
//posisi layar
glutInitWindowPosition(200,200);
//ukuran layar
glutInitWindowSize(640,480);
//title windows
glutCreateWindow("MENGGAMBAR 2D");
//warna back layar
37
//glClearColor(0.0,0.0,0.0,0.0);
gluOrtho2D(-100.,1240.,-400.,1240.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
4. Lingkaran
Gambar: Hasil Percobaan
Contoh Program Yang Menampilkan Objek Lingkaran
#include <GL/glut.h>
#include<math.h>
typedef struct
{
int x,y;
}point2D_t;
38
typedef struct
{
float r,g,b;
}color_t;
void setColor (color_t col)
{
glColor3f(col.r, col.g, col.b);
}
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i<n; i++)
{
glVertex2i(pnt[i].x,pnt[i].y);
}
glEnd();
}
void fillPolygon (point2D_t pnt[], int n, color_t color)
{ int i;
setColor(color);
glBegin(GL_POLYGON);
for (i=0; i<n; ++i)
{ glVertex2f(pnt[i].x, pnt[i].y);
}
glEnd();
}
void userdraw()
{
39
static int tick=0;
point2D_t shape[360];
double srad,r;
for(int s=0;s<360;s++)
{ srad =(s+tick)*3.14/180;
r=100*sin(89*srad);
shape [s].x = (float)(r*cos(srad));
shape [s].y = (float)(r*sin(srad));
color_t blue ={0,1,1};
fillPolygon(shape,1, blue);
}
drawPolygon(shape ,360);
}
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);
//posisi layar
glutInitWindowPosition(100,100);
//ukuran layar
glutInitWindowSize(480,480);
//title windows
40
glutCreateWindow("MENGGAMBAR 2D");
//warna back layar
glClearColor(0.0,0.0,0.0,0.0);
gluOrtho2D(-200.,280.,-200.,280.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
3.3.Contoh Objek 3D
1. Kubus
Gambar: Hasil Percobaan
Contoh Program Yang Menampilkan Objek Kubus:
#include <GL/glut.h>
#include <math.h>
struct point {
float x,y,z;
};
41
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;
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];
42
pnt.y = vec.v[1];
pnt.z = vec.v[2];
return pnt;
}
matriks identitas(void) {
int i,j;
matriks mat;
for (i=0;i<4;i++) {
for (j=0;j<4;j++) {
if (i==j)
mat.m[i][j] = 1;
else
mat.m[i][j] = 0;
}
}
return mat;
}
matriks translasi(float dx, float dy, float dz) {
matriks trans = identitas();
trans.m[0][3] = dx;
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;
43
rotate.m[2][1] = sn;
rotate.m[2][2] = cs;
return rotate;
}
matriks rotasiY(float theta) {
matriks rotate = identitas();
float cs = cos(theta);
float sn = sin(theta);
rotate.m[0][0] = cs;
rotate.m[0][2] = sn;
rotate.m[2][0] = -sn;
rotate.m[2][2] = cs;
return rotate;
}
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;
44
for (j=0;j<4;j++) {
c.v[i]+= mat.m[i][j] * b.v[j];
}
}
return c;
}
matriks kalim (matriks a, matriks b) {
int i,j,k;
matriks c;
for (i=0;i<4;i++) {
for (j=0;j<4;j++) {
c.m[i][j] = 0;
for (k=0;k<4;k++) {
c.m[i][j]+=a.m[i][k] * b.m[k][j];
}
}
}
return c;
}
matriks titling = kalim(rotasiX(theta),rotasiY(-theta));
vektor cross (vektor a, vektor b) {
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)
{
45
int i,j;
float r,g,b;
for(i=0;i<obj.jumsisi;i++)
{
r=1.0f; g=0.0f; b=0.0f;
glBegin(GL_LINE_LOOP);
if (i==0) { r=1.0f; g=0.0f; b=0.0f; }
if (i==1) { r=0.0f; g=1.0f; b=0.0f; }
if (i==2) { r=0.0f; g=0.0f; b=1.0f; }
if (i==3) { r=1.0f; g=1.0f; b=0.0f; }
if (i==4) { r=1.0f; g=0.0f; b=1.0f; }
if (i==5) { r=0.0f; g=1.0f; b=1.0f; }
if (i==6) { r=0.5f; g=0.0f; b=1.0f; }
if (i==7) { r=0.5f; g=0.5f; b=0.5f; }
glColor3f(r,g,b);
for(j=0;j<obj.sisi[i].jumtitikons;j++)
{
glVertex3f(obj.titik[obj.sisi[i].indextitik[j]].x,
obj.titik[obj.sisi[i].indextitik[j]].y,
obj.titik[obj.sisi[i].indextitik[j]].z);
}
glEnd();
}
}
void gambarbalok() {
int i;
vektor hasil,HslKali;
point HslTitik;
mat = titling;
46
objek balok =
{8,{{10,15,30},{30,15,30},{30,15,10},{10,15,10},{10,30,30},{30,30,30},{30,30,10},{10,30,10}},
6,{{4,{0,1,5,4}},{4,{3,2,6,7}},{4,{0,3,7,4}},{4,{1,2,6,5}},{4,{0,1,2,3}},{4,{4,5,6,7}}}};
for (i=0;i<8;i++) {
hasil = point2vektor(balok,i);
HslKali = kali(mat,hasil);
HslTitik = vektor2point(HslKali);
balok.titik[i] = HslTitik;
}
DrawPolygon(balok);
}
void UserDraw() {
glClearColor(1.0f,1.0f,1.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT);
//glRotatef(0.1f,0.0f,1.0f,0.0f);
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();
}
47
2. Prisma
Gambar: Hasil Percobaan
Contoh Program Ynag Menampilkan Objek Prisma:
#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];
};
48
struct objek {
int jumtitik;
point titik[40];
int jumsisi;
face sisi[30];
};
matriks mat;
float theta=0.5;
vektor point2vektor(objek prisma, int i) {
vektor vec;
vec.v[0] = prisma.titik[i].x;
vec.v[1] = prisma.titik[i].y;
vec.v[2] = prisma.titik[i].z;
vec.v[3] = 1;
return vec;
}
point vektor2point(vektor vec) {
point pnt;
pnt.x = vec.v[0];
pnt.y = vec.v[1];
pnt.z = vec.v[2];
return pnt;
}
matriks identitas(void) {
int i,j;
matriks mat;
for (i=0;i<4;i++) {
for (j=0;j<4;j++) {
if (i==j)
mat.m[i][j] = 1;
49
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;
50
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++) {
51
c.m[i][j] = 0;
for (k=0;k<4;k++) {
c.m[i][j]+=a.m[i][k] * b.m[k][j];
}
}
}
return c;
}
matriks titling = kalim(rotasiX(theta),rotasiY(-theta));
vektor cross (vektor a, vektor b) {
vektor c;
c.v[0] = a.v[1]*b.v[2]-a.v[2]*b.v[1];
c.v[1] = a.v[2]*b.v[0]-a.v[0]*b.v[2];
c.v[2] = a.v[0]*b.v[1]-a.v[1]*b.v[0];
c.v[3] = 1;
return c;
}
void DrawPolygon(objek obj)
{
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_POLYGON);
if (i==0) { r=0.0f; g=1.0f; b=1.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; }
52
if (i==4) { r=1.0f; g=0.0f; b=0.0f; }
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 gambarprisma() {
int i;
vektor hasil,HslKali;
point HslTitik;
mat = titling;
objek prisma =
{5,{{0,100,0},{100,0,0},{0,0,100},{-100,0,0},{0,0,-100}},
5,{{3,{0,1,2}},{3,{0,2,3}},{3,{0,3,4}},{3,{0,4,1}},{4,{1,4,3,2}}}};
for (i=0;i<8;i++) {
hasil = point2vektor(prisma,i);
HslKali = kali(mat,hasil);
HslTitik = vektor2point(HslKali);
prisma.titik[i] = HslTitik;
}
DrawPolygon(prisma);
}
void UserDraw() {
glClearColor(0.0f,0.0f,0.0f,0.0f);
53
glClear(GL_COLOR_BUFFER_BIT);
//glRotatef(0.1f,1.0f,1.0f,0.0f);
gambarprisma();
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(-200.0f,200.0f,-200.0f,200.0f,-200.0f,200.0f);
glutIdleFunc(UserDraw);
glutDisplayFunc(UserDraw);
glutMainLoop();
}
3. Monas
54
Gambar: Hasil Percobaan
Contoh Program Yang Menampilkan Objek Monas:
#include <GL/glut.h>
typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;
}color_t;
void setColor(color_t col)
{
glColor3f(col.r, col.g, col.b);
}
55
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i<n; i++)
{
glVertex2i(pnt[i].x,pnt[i].y);
}
glEnd();
}
void fillpolygon(point2D_t pnt[],int n,color_t color)
{
int i;
setColor(color);
glBegin(GL_POLYGON);
for (i=0; i<n; ++i)
{ glVertex2f(pnt[i].x, pnt[i].y);
}
glEnd();
}
void userdraw(void)
{
point2D_t
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
56
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);
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
57
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);
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);
58
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);
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
59
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}};
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);
60
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;
}
61
BAB IV
ANALISA
1. Agar kita mengetahui fungsi-fungsi 2 Dimensi dan 3 Dimensi pada Open GL
2. Dapat mengetahui bagaimana menjalankan program pada Open GL dan mengetahui kesalahan
yang ada pada program
3. mengetahu dasar-dasar dari OpenGL dan cara kerjanya
62
BAB V
PENUTUP
A. Kesimpulan
Dari pembahasan dapat diambil kesimpulan sebagai berikut :
objek. Pemanggilan dan penggunaan titik-titik vektor akan berpengaruh terhadap
bentuk objek yang dibuat.
Gerakkan dari simulasi akan sesuai dengan variabel yang dikirimkan/diterima karena
simulasi yang dibuat terdapat sistem yang melakukan perbandingan antara variable
yang dikirimkan/diterima dengan variabel pada
Perbandingan hasil pembuatan program dengan menggunakan bahasa programan
lebih sulit dan berbeda jauh dari segi tampilan, maupun tata cara pembuatannya
dibandingkan dengan program aplikasi yang menerapkan system just click (event
driven).
OpenGL merupakan status mesin dalam proses rendering dan atribut-atribut diubah
melalui pemanggilan prosedur. Didesain untuk mengakomodasikan teknik rendering
grafis tingkat lanjut,
B. Saran
Setelah melihat uraian di atas, penyusun mempunyai saran.
1. Terlebih dahulu harus belajar algoritma, karena algorima adalah salah satu kunci
untuk dapat memahami permasalahan yang akan dihadapi didalam pembuatan grafik
komputer.
2. Bila ingin membuat suatu gambar/grafik, pilihlah program aplikasi yang lebih bagus
menurut anda, lebih kompleks, dan yang khusus menangani pembuatan
gambar/grafik serta yang mengikuti perkembangan jaman .
3. Harus memahami sintak-sintak (gaya bahasa penulisan dalam bahasa pemrograman
yang terdapat dalam bahasa pemrograman ataupun fitur – fitur yang terdapat
didalam
program aplikasi.
63
DAFTAR PUSTAKA
[1] Andi, “Pemrograman Microsoft Visual C++”, Wahana Komputer,
Yogyakarta dan Semarang, 2009.
[2] D. Astle & K. Hawkins, “Beginning OpenGL Game Programming”,
Thomson Course Technology, USA, 2004.
[3] Addison, “OpenGL Programming Guide”, Wesley Publishing
Company.
[4] B. Achmad & R. Nana, “Pengantar Grafika Komputer”, Politeknik
Elektronika Negeri Surabaya.
[5] OpenGL Programming, Resources and Headline News, tersedia di :http//www.opengl.org
[6] (http://journal.mercubuana.ac.id).
[7] (http://yusrizal.blogspot.com).