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.

http://2.bp.blogspot.com/-RBqG_93yEwY/UYEtZP5Sa5I/AAAAAAAAACM/Wfquj7T-4Qg/s1600/Capture3.JPG

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








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


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


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


void userdraw()

{

static int tick=0;

void drawDot(int x,int y);

glBegin(GL_LINES);

glVertex2i(100,250);







glVertex2i(200,50);


glVertex2i(200,50);


glVertex2i(200,50);

glEnd();

}

void display(void)

{

//BERSIH LAYAR

23


userdraw();

glutSwapBuffers();

}

int main(int argc,char**argv)

{

glutInit(&argc,argv);//Inisialisasi Toolkit




glutCreateWindow("Diamond");

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

gluOrtho2D(0.,440.,0.,300.);



glutMainLoop();

return 0;

}

3. Rumah Tingkat

24


Contoh Program Yang Menampilkan Objek Rumah


typedef struct

{

int x,y;

}

point2D_t;

typedef struct

{

float r,g,b;

}

color_t;


{


25

}


{

int i;

glBegin(GL_LINE_LOOP);

for (i=0; i<n; i++)

{


}

glEnd();

}


{

int i;

setColor(color);


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


point2D_t

kaca6[4]={{750,750},{850,750},{830,730},{730,730}};


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


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


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


point2D_t

blankon3[4]={{450,550},{470,550},{470,500},{450,500}};


point2D_t

blankon4[4]={{470,550},{500,550},{500,500},{470,500}};


point2D_t

blankon5[4]={{500,550},{530,550},{530,500},{500,500}};

28


point2D_t

blankon6[4]={{530,550},{550,550},{550,500},{530,500}};


point2D_t

blankon7[4]={{550,550},{570,550},{570,500},{550,500}};


point2D_t

blankon8[4]={{600,550},{630,550},{630,500},{600,500}};


point2D_t

blankon9[4]={{630,550},{650,550},{650,500},{630,500}};


point2D_t

blankon10[4]={{650,550},{670,550},{670,500},{650,500}};


point2D_t

blankon11[4]={{670,550},{700,550},{700,500},{670,500}};


point2D_t

blankon12[4]={{700,550},{730,550},{730,500},{700,500}};


29

point2D_t

blankon13[4]={{730,550},{750,550},{750,500},{730,500}};


point2D_t

blankon14[4]={{750,550},{770,550},{770,500},{750,500}};


point2D_t

blankon15[4]={{770,550},{800,550},{800,500},{770,500}};


point2D_t

blankon16[4]={{800,550},{830,550},{830,500},{800,500}};


point2D_t

blankon17[4]={{830,550},{850,550},{850,500},{830,500}};


point2D_t

blankon18[4]={{850,550},{870,550},{870,500},{850,500}};


point2D_t

blankon19[4]={{870,550},{900,550},{900,500},{870,500}};


point2D_t

blankon20[4]={{900,550},{930,550},{930,500},{900,500}};

30


point2D_t

blankon21[4]={{930,550},{950,550},{950,500},{930,500}};


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


point2D_t

atap3[4]={{500,500},{600,500},{570,450},{470,450}};


31

point2D_t

atap4[4]={{600,500},{700,500},{670,450},{570,450}};


point2D_t

atap5[4]={{700,500},{800,500},{770,450},{670,450}};


point2D_t

atap6[4]={{800,500},{900,500},{870,450},{770,450}};


point2D_t

atap7[4]={{900,500},{990,470},{970,450},{870,450}};


point2D_t

atap8[4]={{300,450},{370,450},{350,400},{250,400}};


point2D_t

atap9[4]={{370,450},{470,450},{450,400},{350,400}};


point2D_t

atap10[4]={{470,450},{570,450},{550,400},{450,400}};


point2D_t

atap11[4]={{570,450},{670,450},{650,400},{550,400}};

32


point2D_t

atap12[4]={{670,450},{770,450},{750,400},{650,400}};


point2D_t

atap13[4]={{770,450},{870,450},{850,400},{750,400}};


point2D_t

atap14[4]={{870,450},{970,450},{950,400},{850,400}};


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


point2D_t

kaca1[4]={{400,300},{450,300},{430,230},{370,230}};


33

point2D_t

jendela2[4]={{500,300},{550,300},{550,200},{500,200}};


point2D_t

kaca2[4]={{500,300},{550,300},{530,230},{470,230}};


point2D_t

jendela3[4]={{800,300},{850,300},{850,200},{800,200}};


point2D_t

kaca3[4]={{800,300},{850,300},{830,230},{770,230}};


point2D_t

jendela4[4]={{900,300},{950,300},{950,200},{900,200}};


point2D_t

kaca4[4]={{900,300},{950,300},{930,230},{870,230}};


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


point2D_t

jaring3[8]={{800,350},{850,350},{850,330},{800,330},{800,350},{850,330},{850,350},{800,330}};


point2D_t

jaring4[8]={{900,350},{950,350},{950,330},{900,330},{900,350},{950,330},{950,350},{900,330}};


point2D_t

pintu1[4]={{650,250},{700,250},{700,100},{650,100}};


point2D_t

pintu2[4]={{700,250},{750,250},{750,100},{700,100}};


point2D_t

kunci1[4]={{690,200},{700,200},{700,190},{690,190}};


point2D_t

kunci2[4]={{700,200},{710,200},{710,190},{700,190}};


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


point2D_t

lantai3[4]={{550,100},{650,100},{600,40},{500,40}};


point2D_t

lantai5[4]={{650,100},{750,100},{700,40},{600,40}};


point2D_t

lantai6[4]={{750,100},{850,100},{800,40},{700,40}};


point2D_t

lantai7[4]={{850,100},{950,100},{900,40},{800,40}};


point2D_t

lantai8[4]={{950,100},{1000,100},{950,40},{900,40}};


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


point2D_t

daun3[3]={{130,370},{170,430},{220,370}};


}

void display(void)

{

//clear screen


userdraw();

glutSwapBuffers();

}


{


//Inisialisasi Toolkit


//posisi layar


//ukuran layar


//title windows

glutCreateWindow("MENGGAMBAR 2D");

//warna back layar

37

//glClearColor(0.0,0.0,0.0,0.0);

gluOrtho2D(-100.,1240.,-400.,1240.);



glutMainLoop();

return 0;

}

4. Lingkaran


Contoh Program Yang Menampilkan Objek Lingkaran


#include<math.h>

typedef struct

{

int x,y;

}point2D_t;

38

typedef struct

{

float r,g,b;

}color_t;


{


}


{

int i;


for (i=0; i<n; i++)

{


}

glEnd();

}


{ int i;

setColor(color);


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


userdraw();

glutSwapBuffers();

}


{



//posisi layar


//ukuran layar


//title windows

40

glutCreateWindow("MENGGAMBAR 2D");

//warna back layar


gluOrtho2D(-200.,280.,-200.,280.);



glutMainLoop();

return 0;

}

3.3.Contoh Objek 3D

1. Kubus


Contoh Program Yang Menampilkan Objek Kubus:


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


return rotate;

}

matriks rotasiY(float theta) {








return rotate;

}

matriks rotasiZ(float theta) {








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;


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



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

gambarbalok();

glutSwapBuffers();

}

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





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


Contoh Program Ynag Menampilkan Objek Prisma:


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








return rotate;

}

matriks rotasiY(float theta) {







50


return rotate;

}

matriks rotasiZ(float theta) {








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;


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


53


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

gambarprisma();

glutSwapBuffers();

}

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





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


Contoh Program Yang Menampilkan Objek Monas:


typedef struct

{

int x,y;

}point2D_t;

typedef struct

{

float r,g,b;

}color_t;

void setColor(color_t col)

{


}

55


{

int i;


for (i=0; i<n; i++)

{


}

glEnd();

}

void fillpolygon(point2D_t pnt[],int n,color_t color)

{

int i;

setColor(color);


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


point2D_t

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


fillpolygon(petaktengah3, 4, kuning3);


point2D_t

batang2[4]={{160,510},{160,530},{200,530},{200,510}};


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


fillpolygon(petaktengah4, 4, hitam3);


point2D_t

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


fillpolygon(segitiga, 3, kuning4);

drawPolygon(segitiga,3);

point2D_t

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


fillpolygon(bayangbatang, 4, putih3);

drawPolygon(bayangbatang,4);

point2D_t

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


fillpolygon(bayangbatang2, 4, putih4);

drawPolygon(bayangbatang2,4);

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


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


point2D_t

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


point2D_t

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


point2D_t

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


point2D_t

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


}

void display(void)

{

//clear screen


userdraw();

glutSwapBuffers();

}


{




60


glutCreateWindow("MONUMEN NASIONAL JAKARTA");


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



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

Documents

Eva Martia (1214370066)