SKRIPSI Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Jurusan Teknik Informatika

Gratis

0
0
87
7 months ago
Preview
Full text

  TEKNIK CELL SHADING MENGGUNAKAN OPENGL SKRIPSI Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Jurusan Teknik Informatika DISUSUN OLEH: Stanislaus Charlo Desanto NIM : 015314037 PROGRAM STUDI TEKNIK INFORMATIKA FAKULTAS SAINS DAN TEKNOLOGI UNIVERSITAS SANATA DHARMA YOGYAKARTA 2008

CELL SHADING TECHNIQUE USING OPENGL

  

A Thesis

Presented as Partial Fulfillment of the Requirements

to Obtain the Sarjana Teknik Degree

in Informatics Engineering

  

By:

Stanislaus Charlo Desanto

NIM : 015314037

  

DEPARTMENT OF INFORMATICS ENGINEERING

FACULTY OF SCIENCE AND TECHNOLOGY

SANATA DHARMA UNIVERSITY

YOGYAKARTA

PERNYATAAN KEASLIAN KARYA

  Dengan ini saya menyatakan bahwa tugas akhir ini tidak terdapat karya yang pernah diajukan untuk memperoleh gelar sarjana disuatu perguruan tinggi, dan sepanjang pengetahuan saya, juga tidak terdapat karya atau pendapat yang pernah ditulis atau diterbitkan oleh orang lain, kecuali yang secara tertulis diacu dalam naskah ini dan disebutkan dalam daftar pustaka.

  Yogyakarta, 21 Januari 2008 Penulis

  Stanislaus Charlo Desanto

HALAMAN PERSEMBAHAN

  Kupersembahkan semua ini kepada: 2. Tuhan Yang Maha Esa atas kehidupan di dunia.

  3. Ayah dan ibuku yang tercinta.

  4. Semua kakak-kakakku yang begitu berarti dalam kehidupanku.

  5. Semua teman-temanku yang menjadi sahabat dalam suka dan duka.

  

HALAMAN MOTTO

HARAPAN, IMAN DAN CINTA KASIH

  • Ajaran Katolik--

  

ABSTRAKSI

  Tujuan dari pembuatan program ini adalah mempelajari teknik cell

  

shading dan mengimplementasikan pada rendering 3-Dimensi menggunakan API

OpenGL.

  Metodologi penelitian yang digunakan adalah laboratory experiment yaitu mempelajari teori cell shading dan OpenGL kemudian melakukan pemrograman serta mengujikan kedalam bentuk program.

  Hasil program mampu merender obyek 3-Dimensi bertipe RAW secara terus menerus dengan teknik cell shading.

  

ABSTRACT

  The aim of this program is researching cell shading technique and implementing at 3-Dimension rendering using OpenGL API .

  methodology

  The used is laboratory experiment , which are learn about cell shading theory and OpenGL then do programming and testing it at application.

  The result of this application could render as real time rendering RAW type 3-Dimension based at cell shading method.

KATA PENGANTAR

  Puji syukur penulis panjatkan kepada Tuhan Yang Maha Esa atas berkat dan petunjuk-Nya sehingga tugas akhir ini dapat terselesaikan.

  Tugas akhir ini dibuat untuk memenuhi salah satu syarat akademis yang harus dilaksanakan untuk mendapat mendapat gelar sarjana strata-1 di jurusan Teknik Informatika fakultas Teknik Universitas Sanata Dharma.

  Pada kesempatan ini, penulis ingin menyampaikan terima kasih yang sebesar-besarnya kepada:

  1. Prof. F. Soesianto, B.Sc.E.,Ph.D. yang telah membimbing dalam menyusun tugas akhir ini.

  2. Seluruh dosen Teknik Informatika Sanata Dharma yang telah memberi banyak ilmu dan bimbingan.

  3. Karyawan Sekretariatan Teknik, Petugas Laboratorium yang telah banyak membantu.

  4. Teman-teman angkatan 2001 khususnya kelas A yang banyak membantu dan memberi semangat dalam menyusun tugas akhir ini.

  Yogyakarta, 24 Januari 2008 Penulis

  

DAFTAR ISI

  BAB I Pendahuluan ……………..…… ……………………………… .1

  2.2.1 Aplikasi...................... ………….…..………………… 6

  2.2 Saluran Rendering Citra.……..…………….…………………… 5

  2.1 Real Time Rendering........……..……………………………….. 5

  BAB II LANDASAN TEORI ……………..…………………………………. 5

  1.6 Sistematika Penulisan ……………..……………………………. 3

  1.5 Metode Penelitian……………..………………………………… 3

  1.4 Rumusan Masalah.......................……………………………….. 3

  1.3 Tujuan dan Manfaat Penelitian...……………………………….3

  1.2 Batasan Masalah .................... …………………………………. 2

  1.1 Latar Belakang …………………………………………………. 1

  Daftar Tabel xii

  Halaman Judul i

  Daftar Gambar xi

  Daftar Isi x

  Kata Pengantar ix

  Abstract viii

  Abstrak vii

  Halaman Motto vi

  Halaman Persembahan v

  Pernyataan Keaslian Karya iv

  Halaman Pengesahan iii

  Halaman Persetujuan ii

  2.2.2 Geometri........................................................................... 7

  5.2.2.1Transformasi Model dan Sudut Pandang.......... 7

  2.5.2 Pemakaian OpenGL ...................................................... 23

  4.2 Penempatan OpenGL di Visual C++ .......................................... 37

  4.1 Pemakaian OpenGL .................................................................... 36

  BAB IV IMPLEMENTASI ................................................................................ 36

  3.3.2 Flowchart......................................................................... 34

  3.3.1 Metode Cell shading …….......…………...…………… 31

  3.3. Cell shading …………………………………….................…... 30

  3.2 Toon shading…….....................……………………………….… 28

  3.1 Shading...... ……………..………………………………………. 28

  BAB III ANALISA........................... ……………….………………………… 28

  2.6 Visual C++ dan aplikasi Windows………..…………………... 25

  2.5.1 Sejarah OpenGL ............................................................ 20

  2.2.2.2 Pencahayaan ................................................... 9

  2.5 OpenGL................................... ……….……………………….. 19

  2.4 Pembuatan Model....………..…………………………………. 17

  2.3.4 Perhitungan Komponen-komponen................................ 15

  2.3.3 Komponen Ambient ....................................................... 15

  2.3.2 Komponen Specular ...................................................... 14

  2.3.1 Komponen Diffuse ......................................................... 12

  2.3 Sumber Cahaya ......………..………………….………………. 12

  2.2.3 Rasterisasi..................................................................... 12

  2.2.2.5 Screen Mapping............................................. 11

  2.2.2.4 Clipping ......................................................... 10

  2.2.2.3 Proyeksi .......................................................... 9

  4.3 Membuat jendela OpenGL ........................................................... 39

  4.3.1 Fungsi CreateGLWindow ................................................ 40

  4.3.2 Fungsi KillGLWindow .................................................... 41

  4.3.3 Fungsi WndProc ............................................................... 44

  4.3.4 Fungsi ResizeGLScene .................................................... 45

  4.4 Rendering ..................................................................................... 45

  4.5 Penggunaan Model ....................................................................... 48

  4.6 Rotasi Obyek ............................................................................. 49

  4.7 Pemakaianan File untuk Modeling .............................................. 51

  4.8 Cell shading ................................................................................. 55

  4.9 Garis Tepi .................................................................................... 59

  4.10 Pemberian Warna ……………………………………………... 62

  BAB V ANALISA HASIL ............................................................................... 64 BAB VI KESIMPULAN ................................................................................... 66 DAFTAR PUSTAKA …………………………………………………………. 67 lampiran A ………………………………………………....…………………. 68 lampiran B ……………………………………………………………….…. .. 71

  DAFTAR GAMBAR Gambar Keterangan Halaman

  4.10 Hasil render cell shading ditambah garis tepi

  53

  4.6 Rendering dengan pencahayaan normal

  55

  4.7 Hasil render cell shading 2 warna

  59

  4.8 Hasil render cell shading 3 warna

  59

  4.9 Hasil render kawat polygon

  61

  61

  50

  4.11 Hasil akhir rendering

  62

  5.1 Hasil yang ingin diperoleh

  63

  5.2 Hasil render realistik

  64

  5.3 Hasil render cell shading

  64 L.1 proyeksi orthographic

  69 L.2 proyeksi perspective

  4.5 Rendering model dari file

  4.4 Rendering model sederhana

  2.1 arsitektur rendering citra berdasarkan implementasi

  20 2.11 proses pembuatan jendela Windows

  6 2.2 subbagian geometri menurut fungsinya

  7 2.3 transformasi sudut pandang

  8 2.4 proyeksi

  10 2.5 clipping

  10 2.6 screen mapping

  11 2.7 komponen diffuse

  12 2.8 komponen specular

  14 2.9 normal

  18 2.10 mesh polygon

  27

  47

  3.1 Model shading untuk pencahayaan nyata

  28

  3.2 Ciri-ciri kartun tradisional

  29 3.3 tabel teksture 1-Dimensi

  33 3.4 flowchart

  35 4.1 hasil pelacakan visual C++

  39

  4.2 Jendela OpenGL

  45

  4.3 Rendering dasar OpenGL

  70

BAB I PENDAHULUAN

1.1 LATAR BELAKANG

  Salah satu tujuan industri grafika komputer saat ini adalah menampilkan citra 3-Dimensi yang bagus dalam satuan waktu sekian milidetik pada layar komputer. Untuk menghasilkan gambar 3-Dimensi yang realistik diperlukan banyak proses yang perlu dilakukan, contohnya pembuatan model, pencahayaan, texturing, pemberian efek khusus, dan lainnya. Selain pembuatan gambar 3-Dimensi yang realistik, ada alternatif lain untuk menghasilkan gambar yang bagus, yaitu membuat tampilan hasil rendering tidak seperti kenyataan atau Non-photorealistic Rendering (NPR). Dalam NPR hasil rendering akan berupa seperti hasil gambaran tangan manusia ataupun seni lainnya. Salah satu teknik yang termasuk dalam NPR adalah

  toon shading. Hasil dari teknik toon shading akan membuat obyek terlihat

  seperti gambar kartun tradisional atau bergaya komik. Gambar bergaya kartun atau toon shading mempunyai dua kecenderungan yaitu penonjolan jelas pada tepi gambar (silhouettes) dan pewarnaan sederhana serta terdapat perubahan warna jelas antar daerah pada gambar (cel shading). Teknik Cel

  shading menggunakan perhitungan cahaya, texture mapping 1-Dimensi dan

  perhitungan vektor. Teknik silhouettes memilih bagian-bagian tertentu untuk diolah dengan warna hitam atau putih sesuai dengan posisinya. Dalam penggunaan lebih lanjut, hasil silhouettes digunakan sebagai garis tepi sebuah obyek 3-Dimensi.

  Teknik toon shading telah banyak diterapkan dalam game, komik dan animasi. Toon shading juga lebih efisien dibandingkan dengan penggambaran manual satu persatu untuk menghasilkan kartun 2D. Oleh karena itu, penulis tertarik untuk mempelajari teknik cel shading bagian dari

  toon shading dan menerapkannya dalam bentuk program aplikasi.

  1.2 BATASAN MASALAH

  Mengingat keterbatasan waktu dan tenaga, cell shading yang dibahas dalam tulisan ini dibuat menggunakan model lightning, tidak dengan pendekatan seni ataupun raytracing serta tidak membahas masalah perangkat keras seperti arsitektur memori, buses, chipsets. Program kompiler yang digunakan untuk implementasi adalah Visual C++ 6 dan API OpenGL , serta obyek model yang digunakan adalah modifikasi RAW files. Toon shading yang dihasilkan hanya berasal dari cell shading saja tidak sekaligus dengan silhouettes.

  1.3 TUJUAN DAN MANFAAT PENELITIAN

  Maksud penulisan ini adalah sebagai salah satu syarat untuk mencapai jenjang derajat sarjana S-1 Program Studi Teknik Informatika, Jurusan Teknik Informatika, Fakultas Teknik, Universitas Sanata Dharma

  Tujuan penulisan ini adalah untuk mempelajari dan memahami teknik cel shading khususnya, dan real time rendering secara umum.

  Manfaat yang didapat adalah peningkatan mutu citra 3-Dimensi dengan gaya tradisional seperti kartun.

1.4 RUMUSAN MASALAH

  Permasalahan yang dihadapi penelitian ini adalah bagaimana melakukan rendering 3-Dimensi yang menghasilkan citra bergaya kartun dengan teknik

  cel shading menggunakan OpenGL.

  1.5 METODOLOGI PENELITIAN

  Dalam penulisan ini, metode penulisan yang digunakan adalah

  laboratory experiment. Pertama, penulis akan melakukan studi pustaka

  melalui buku sumber maupun internet, kemudian melakukan pemrograman serta mengujikan hasil studi pustaka ke dalam bentuk program.

  1.6 SISTEMATIKA PENULISAN

  Sistematika penulisan ini adalah sebagai berikut :

  BAB I. PENDAHULUAN Berisi tentang latar belakang masalah, pembatasan masalah, tujuan

  BAB II. LANDASAN TEORI Berisi tentang teori-teori yang diperlukan dalam menerangkan metode-metode yang dibahas agar lebih mudah dalam memahaminya.

  BAB III. PERANCANGAN Berisi pembahasan mengenai cel shading serta bagaimana mekanisme cara menghasilkannya dan menggambarkan bagaimana implementasi algoritma dan data struktur yang akan digunakan di bab berikutnya.

  BAB IV. IMPLEMENTASI Berisi tentang bagaimana mengimplementasikan perancangan yang telah dibuat dengan menggunakan OpenGL. BAB V. ANALISA HASIL Berisi gambar yang dihasilkan oleh program yang dibuat dan perbandingannya serta analisanya. BAB VI. KESIMPULAN Berisi kesimpulan dari analisa sebelumnya serta saran sehubungan topik yang dibahas. DAFTAR PUSTAKA LAMPIRAN

BAB II LANDASAN TEORI

  2.1 REAL TIME RENDERING

  Rendering adalah proses perubahan dari tetapan primitif dalam bentuk koordinat obyek ke bentuk citra dalam frame buffer. Rendering adalah operasi utama yang dilakukan oleh OpenGL. Jika melihat hasil perkembangan grafika komputer akhir-akhir ini, gambar tampil pada layar monitor, kemudian pemakai melakukan respon terhadap gambar dan respon ini memberikan efek lanjut terhadap gambar. Perputaran reaksi pemakai dan proses rendering terjadi terus menerus dalam kecepatan cukup tinggi yang tidak terlihat mata tetapi telah menjadi suatu proses dinamis. Real Time Rendering memberi perhatian terhadap pembuatan gambar dalam komputer secepat mungkin.

  2.2 SALURAN RENDERING CITRA Pipeline atau saluran, dapat ditemukan dalam berbagai bentuk misalnya

  saluran air. Dalam saluran tersebut terdapat bagian-bagian yang harus dilewati secara berurutan, demikian juga dalam rendering gambar. Dalam hubungannya dengan real time rendering, terdapat 3 bagian yang harus dilalui yaitu bagian aplikasi, geometri, dan rasterisasi. Seperti pemberian namanya bagian aplikasi diimplementasikan pada perangkat lunak, bagian keras tergantung pada arsitekturnya, sedangkan bagian rasterisasi diimplementasikan pada perangkat keras. Gambar 2.1 memperlihatkan hubungan ketiga bagian dalam real time rendering.

Gambar 2.1 Arsitektur rendering citra berdasarkan implementasi.

  Pada pelaksanaannya, tahap yang pertama kali diproses adalah tahap aplikasi. Tahap geometri dilakukan setelah tahap aplikasi selesai diproses dan setelah tahap ini selesai maka proses dilanjutkan pada tahap rasterisasi.

2.2.1 APLIKASI

  Pada bagian aplikasi, pengembang perangkat lunak mengendalikan secara penuh apa yang dibuat dan dapat merubah implementasi untuk meningkatkan mutu tampilan. Bagian ini mengurusi antara lain collision

  detection atau pendektesian, dan merespon dua obyek yang bertubrukan,

  teknik culling atau peningkatan kecepatan rendering dengan menyeleksi obyek melalui sudut pandang manusia, kontrol masukan dari media luar tidak diolah dibagian lain. Karena berbasis perangkat lunak maka bagian ini tidak dibagi menjadi subbagian lagi, meskipun bisa dieksekusi secara paralel pada beberapa prosesor.

2.2.2 GEOMETRI

  Tahap geometri bertanggung jawab terhadap mayoritas operasi tiap-tiap

  polygon atau tiap-tiap vertex. Bagian ini dibagi menjadi beberapa subbagian

  menurut fungsinya. Pemakaian subbagian ini mungkin akan sama dengan

  pipeline ataupun berbeda tergantung implementasinya. Gambar 2.2

  memperlihatkan hubungan antara bagian-bagian dari tahap geometri menurut fungsinya.

Gambar 2.2 Subbagian geometri menurut fungsinya

2.2.2.1 TRANSFORMASI MODEL DAN SUDUT PANDANG

  Pada perjalanan menuju layar, obyek model diubah pada beberapa sistem koordinat atau space yang berbeda. Sebenarnya, obyek model terletak pada

  model space tersendiri yang berarti tidak berubah secara keseluruhan. Setiap

  model dapat dikumpulkan dengan transformasi model sehingga dapat diorientasikan atau diposisikan. Yang diubah oleh transformasi model adalah

  

vertex dan normal dan setelah perubahan, model akan menggunakan

  koordinat obyek hasil perubahan. Transformasi model diimplementasikan dengan matrik 4 X 4, dan dasar-dasarnya akan dijelaskan pada Lampiran A.

  Untuk menampilkan gambar dibutuhkan kamera, dan hanya model yang terlihat oleh kamera saja yang akan ditampilkan. Untuk memfasilitasi proyeksi dan clipping, kamera dan semua model diubah sedemikian rupa dengan transformasi sudut pandang. Tujuan transformasi sudut pandang adalah meletakkan kamera pada asal dan bidikannya, serta terlihat dari arah sumbu Z, dengan sumbu Y mengarah ke atas dan sumbu X ke arah kanan.

Gambar 2.3 menunjukkan bagaimana penempatan kamera dan perpindahan model pada tahap ini.Gambar 2.3 transformasi sudut pandang

  2.2.2.2 PENCAHAYAAN

  Untuk menampilkan tampilan yang mirip dengan kenyataan, pemandangan perlu dilengkapi dengan satu atau lebih sumber cahaya. Beberapa kasus mungkin tidak memasukkan pencahayaan dalam geometri karena mungkin model obyek telah dilengkapi warna tiap vertex atau teksture yang menempel padanya. Untuk model yang masih memerlukan sumber cahaya, perhitungan cahaya digunakan untuk menghitung warna tiap vertex. Persamaan yang digunakan menggunakan perhitungan dalam dunia nyata yaitu perhitungan perkiraan photon dan permukaan benda.

  2.2.2.3 PROYEKSI

  Setelah pencahayaan, sistem rendering dilanjutkan dengan pembuatan proyeksi yang mengubah ukuran tampilan menjadi sebuah kubus dengan T T T titik tertinggi ( 1 1 1) dan (-1 -1 -1) (operator v = bentuk transformasi dari vektor v). Unit kubus tersebut dinamakan

  canonical view volume. Dasar dari proyeksi ada dua yaitu metode orthographics dan metode prespective yang keduanya bisa diperoleh melalui

  matrik 4 x 4. Ciri khas dari orthographics adalah garis paralel masih tetap paralel setelah perubahan. Proyeksi prespective lebih rumit, karena bagian jauh obyek yang tergaris dari kamera, menghasilkan gambar yang lebih kecil. Walaupun perubahan pada bagian ini mengubah isi, proses ini disebut proyeksi karena setelah ditampilkan koordinat-Z tidak ditampilkan pada ini model diproyeksikan dari 3-dimensi menjadi 2-dimensi. Bentuk perhitungannya dijelaskan pada Lampiran B. Gambar 2.4 memperlihatkan perbedaan antara proyeksi orthographics dan proyeksi prespective.

Gambar 2.4 proyeksi

2.2.2.4 CLIPPING

  Hanya keseluruhan ataupun sebagian obyek yang terdapat dalam view

  volume saja yang akan dilanjutkan ke proses rasterisasi atau digambarkan ke

  layar. Jika obyek hanya sebagian saja dalam view volume maka diperlukan proses clipping. Clipping akan membuang bagian luar dari unit kubus dan membuat vertex baru pada bagian pinggir unit kubus.

Gambar 2.5 memperlihatkan bagaimana cara kerja proses Clipping.Gambar 2.5 Clipping

2.2.2.5 SCREEN MAPPING

  Hanya obyek hasil dari proses clipping saja yang akan melewati proses

  screen mapping. Obyek-obyek tersebut masih mempunyai koordinat 3- Dimensi, koordinat X dan koordinat Y diubah ke dalam koordinat layar.

  Sedangkan koordinat Z ( -1 ? Z ? 1) disimpan untuk proses rasterisasi.

Gambar 2.6 memperlihatkan cara kerja screen mapping.Gambar 2.6 Screen mapping

2.2.3 RASTERISASI

  Tujuan dari proses rasterisasi atau sering disebut scan conversion adalah memberikan warna yang benar kepada piksel untuk dirender dengan menggunakan vertex yang telah diolah dan diproyeksikan, beserta warna dan koordinat teksture dari proses geometri sebelumnya. Berbeda dengan proses geometri yang mengolah tiap-tiap vertex atau polygon, rasterisasi menangani operasi tiap piksel. Proses ini mengubah dari vertex 2-Dimensi menjadi piksel ke dalam layar monitor dengan nilai-Z (nilai kedalaman), warna, dan mungkin koordinat teksture yang disertakan pada tiap vertex.

2.3 SUMBER CAHAYA

  Lighting atau pencahayaan adalah istilah yang digunakan untuk menandakan

  interaksi antara material dan sumber cahaya. Lighting bisa berupa warna, teksture, atau transparansi. Semua elemen tersebut dikombinasikan menjadi dihitung menggunakan lighting model. Untuk tujuan real time graphics, umumnya lighting model dibagi menjadi tiga bagian penting yaitu komponen

  diffuse, komponen specular, dan komponen ambient.

2.3.1 KOMPONEN DIFFUSE

  Sinar diffuse datang dari satu arah, sehingga lebih terang jika datangnya secara tepat jatuh pada permukaan, dibandingkan jika hanya sekilas pada permukaannya. Sekali menyentuh permukaan, sinar berpencar sama ke semua arah, maka sinar terlihat terang, tidak masalah dari mana mata memandang. Sinar-sinar yang datang dari posisi atau arah khusus kemungkinan mempunyai komponen diffuse. Gambar 2.7 menunjukkan hubungan antara sinar (l) dan normal (n).

Gambar 2.7 komponen diffuse

  Model sinar ini mendekati kenyataan dan melibatkan interaksi photon dan permukaan benda. Efek ini mempunyai nilai sebagai berikut.

  リ i diff = n . l = cos Nilai intensitas diffuse ( i diff ) ditentukan oleh nilai cosinus antara permukaan normal n dan vektor sinar l yang bersinar dari titik permukaan P ke sumber cahaya. Sebagai contoh nilai intensitas diffuse bernilai 0 jika sudut リ bernilai kurang dari π/2. Dalam kenyataannya permukaan material atau obyek mempunyai warna tersendiri ( m diff ) serta sumber cahaya juga mempunyai warna tersendiri ( s diff ).

  Faktanya adalah sudut リ bernilai kurang dari π/2, maka persamaannya : Rumus intensitas diffuse tersebut mengandung perkalian komponen vektor sinar dan material.

  Contohnya sebuah sinar mempunyai warna biru s diff = ( 0.0 0.0 1.0 ) , dan material berwarna merah m diff = ( 1.0 0.0 0.0), maka perkalian keduanya menghasilkan (0.0

  0.0 0.0). Kesimpulannya permukaan dengan warna merah tidak bisa memantulkan warna biru.

2.3.2 KOMPONEN SPECULAR

  Sinar specular datang dari arah khusus, dan cenderung untuk memantulkan permukaan dalam arah yang berlebihan. Sinar laser dengan kualitas baik akan menghasilkan pantulan specular hampir 100%. Besi yang mengkilap atau plastik mempunyai komponen specular yang tinggi, kapur atau karpet hampir tidak mempunyainya. Specular bisa disebut juga kilapan atau kilauan. Gambar 2.8 memperlihatkan hubungan antara normal (n), normalisasi vektor (h), vektor menuju mata (v).

Gambar 2.8 Komponen specular

  Model yang digunakan untuk menghitung intensitas cahaya specular biasanya menggunakan perhitungan cahaya phong.

  mshi mshi

i spec = ( n . h ) = (cos )

  Dalam perhitungan ini, digunakan parameter m shi yang merupakan parameter kecemerlangan, normal ( n ) dan normalisasi vektor ( h ) antara vektor v yang memantulkan cahaya ke mata dan vektor sinar l.

  Seperti dalam komponen diffuse, terdapat parameter lain yaitu material m spec spec dan sumber cahaya s . Selain itu jika sudut antara n dan h lebih dari π/2 maka kontribusi nilai specular bernilai 0.

  2.3.3 KOMPONEN AMBIENT

  Komponen ambient adalah sinar yang datang dari sumber yang menyebar luas oleh lingkungan yang arahnya tidak bisa ditentukan (seperti datang dari semua arah). Sinar dalam kamar mempunyai komponen ambient yang banyak, karena kebanyakan sinar terpantul beberapa kali sebelum terpantul ke mata. Lampu pijar yang berada diluar ruang, mempunyai komponen

  ambient yang kecil, misalnya lampu pengatur lalu lintas melewati arah yang

  sama dan kecil kemungkinan sinar mencapai mata setelah terpantul beberapa benda. Ketika sinar ambient mengenai permukaan, sinar menyebar sama ke semua arah. Perhitungan nilai intensitas nilai ambient hanya melibatkan material dan sumber cahaya.

  2.3.4 PERHITUNGAN KOMPONEN-KOMPONEN

  Nilai lighting keseluruhan yang dipakai adalah penjumlahan ketiga komponen tersebut ( i = nilai intensitas cahaya).

  

i tot = i amb + i diff + i spec

  Dalam kenyataannya sinar yang jauh akan mengalami pelemahan, begitu juga dengan dengan sinar yang terarah seperti komponen diffuse dan komponen specular. Faktor yang melemahkan sinar disebut attenuation. Faktor attenuation (d) dipengaruhi oleh posisi sumber sinar cahaya ( s pos ), titik yang dituju oleh sinar cahaya ( P ), nilai attenuation konstant ( s c ), nilai l q attenuation linear ( s ), nilai attenuation kuadrat ( s ).

  Nilai lighting keseluruhan juga akan terpengaruhi oleh faktor attenuation maka persamaannya akan berubah :

  i tot = i amb + d ( i diff + i spec )

  Selain sumber sinar yang terarah, terdapat jenis sinar lain yang mirip titik tetapi memancarkan sinar seperti kerucut yang disebut sumber sinar spot.

  Sumber sinar ini memancarkan beberapa sinar berbeda-beda tergantung arah dan sudut sinar dengan sinar utamanya. Terdapat parameter yang mewakili spot spot ini yaitu c . Jika tidak ada sumber sinar spot, maka nilai c adalah 1. Jika c spot bernilai 0 maka terdapat sumber sinar c spot yang tidak mengenai vertex.

  i tot = c spot ( i amb + d ( i diff + i spec ))

  Masih ada nilai lain yang akan dihitung dalam perhitungan ini yaitu sinar emi

  

emitted (m ) yang berada pada obyek dan tidak terpengaruh oleh sumber

  cahaya. Dalam OpenGL ataupun Direct3D juga terdapat parameter lain antara lain ambient global (a glob ) yang merupakan cahaya latar belakang secara keseluruhan. Ambient global digunakan berpasangan dengan material ambient. Rumus di atas merupakan rumus untuk sebuah sinar. Jika ada terdapat banyak sinar maka persamaan adalah sebagai berikut :

2.4 PEMBUATAN MODEL

  

Vertex adalah sebuah titik pada alam 3-Dimensi. Triangle atau Segitiga

  adalah polygon dengan tiga sudut dan selalu cembung. Quadrilateral atau

  

quad atau segiempat adalah polygon dengan empat sudut. Polygon adalah

  sebuah permukaan bidang yang dibatasi oleh sudut dari vertek. Setiap segitiga dari triangle mesh atau segiempat dari quadrilateral mesh adalah

  

polygon. Gambar 3.9 memperlihatkan hubungan antara normal dan polygon.

  normal

  Gbr.2.9

  Normal adalah tiga komponen dari persamaan yang menjelaskan siku atau arah 45 ー dari sebuah permukaan. Untuk membuat normal sebuah vektor, bagi setiap komponen dengan akar kuadrat dari penjumlahan dari masing- masing kuadrat. Jika normal adalah sebuah vektor dari hasil vektor asalnya ke titik berikutnya (nx', ny', nz'), maka vektor tersebut mempunyai nilai 2 2 2 factor = sqrt(nx + ny + nz ) nx' = nx / factor ny' = ny / factor nz' = nz / factor Pembuatan model antara lain dengan sistem RAW atau terstruktur yaitu memasukkan polygon sesuai dengan urutannya. Misal untuk polygon segitiga maka dituliskan koordinat X1, Y1, Z1 kemudian X2, Y2, Z2 kemudian X3, Y3, Z3 dan diulang lagi untuk polygon selanjutnya. Segitiga

  

strips hanya menjabarkan sekali koordinat X1, Y1, Z1, X2, Y2, Z2, X3, Y3,

  Z3, kemudian dilanjutkan polygon selanjutnya dengan X4, Y4, 54 dimana dua titik lainnya adalah X2, Y2, Z2, X3, Y3, Z3 dan polygon terusnya adalah X5, Y5, Z5 dimana titik lainnya adalah X3, Y3, Z3 dan X4, Y4, 54. Segitiga fan sama dengan segitiga strip tetapi untuk tiap polygon terdapat X1, Y1, Z1 sebagai titik pusat sehingga hasilnya membentuk seperti kipas atau fan.

  Segitiga strips atau fan adalah teknik polygon primitif untuk percepatan yang dahulu populer, tetapi sekarang terdapat polygon mesh yang didukung baik oleh OpenGL dan Direct3D. Kecenderungannya sekarang untuk percepatan grafika adalah mengambil keuntungan dari mesh sebanyak mungkin untuk menambah kecepatan render. Perbedaan mendasar adalah strips dan fans mengijinkan beberapa pemakaian bersama data, mesh mengijinkan pemakaian bersama secara penuh.

  Polygon mesh terdiri dari daftar vertex dan sebuah set garis bentuk ( segitiga

  atau segiempat ) sering disebut dengan face. Setiap vertex terdiri dari posisi dan tambahan data seperti warna diffuse, warna specular, normal, koordinat teksture dan tanda pinggir. Setiap set garis bentuk mempunyai daftar indeks angka cacah mulai 0 sampai n – 1, dimana n adalah jumlah vertex dan angka tersebut menunjuk pada sebuah vertex dalam daftar. Gambar 2.10 memperlihatkan hubungan antara mesh, face, dan vertex.

Gambar 2.10 mesh polygon

2.5 OPENGL OpenGL adalah program antar muka untuk perangkat keras grafika.

  Program ini terdiri sekitar 120 perintah nyata yang dapat digunakan untuk menetapkan obyek dan operasi yang dibutuhkan untuk memperoleh aplikasi 3-Dimensi secara interaktif.

  OpenGL didesain untuk bekerja efektif terutama dalam jaringan komputer dengan menggunakan perintah gambar OpenGL. Selain itu OpenGL juga didesain sebagai pemersingkat, antar muka yang bebas untuk dapat diterapkan pada banyak jenis perangkat keras yang berbeda. Untuk mencapai kualitas, OpenGL tidak mempunyai perintah untuk membentuk tugas

  windows atau masukan data. Meskipun begitu, pemakai tetap harus bekerja

  melalui apa yang sistem window mengontrol perangkat keras yang digunakan. OpenGL tidak menyediakan perintah tingkat tinggi untuk menjelaskan model obyek tiga dimensi, seperti perintah yang mengijinkan untuk membentuk model khusus yang relatif sulit misalnya bagian tubuh, mobil, pesawat, atau molekul. OpenGL hanya dapat membuat model obyek dari bentuk primitif seperti titik, garis dan polygon.

2.5.1 SEJARAH OPENGL

  OpenGL adalah perkembangan dari API program 3-Dimensi IRIS GL yang dibuat oleh perusahaan Silicon Graphics Inc. (SGI) pada tahun sekitar akhir 1980-an. Tujuan awalnya API ini adalah mengembangkan aplikasi citra seperti CAD dan animasi. Sampai sekarang terdapat lebih dari 1500 aplikasi yang menggunakan IRIS GL untuk proses rendering. Kekurangan dari IRIS GL adalah hak kepemilikannya pada batasan sistem window yang membuat pengubahan kode sulit meski menggunakan produk dari SGI sendiri.

  Pada tahun 1992 SGI memperkenalkan API 3-Dimensi baru bernama Open

  OpenGL mengijinkan penggambaran 3-Dimensi tanpa menggunakan batasan sistem window. API OpenGL menggunakan nama unik dimana semua perintah diawali huruf kecil “gl” (glColor, glEnable) dan tipe data diawali huruf besar “GL” (GLfloat, Gldouble).

  Selama beberapa tahun, industri grafika menggunakan OpenGL ketika industri game masih menggunakan perangkat keras DOS tanpa kartu grafik akselerasi. SGI membuat badan untuk menangani kemajuan API bernama OpenGL Architecture Review Board (ARB) termasuk didalamnya perusahaan SGI, nVIDIA, ATI, Matrox, 3Dlabs dan lain-lain. Anggota ARB beberapa kali dalam setahun membahas bagaimana API yang diinginkan. Pada tahun pertengahan 1990, perangkat keras akselerasi merosot harga jualnya dan kartu akselerasi video mulai dijual dengan kemampuan khusus library dari perusahaannya saja yang dapat diakses. Windows 95 dan NT4 mengatasi perkembangan ini dengan menambah perangkat lunak yang mendukung OpenGL. Pada tahun 1995 Brian Paul membuat API 3-Dimensi bernama Mesa yang merupakan implementasi open source dari OpenGL. Ketika Mesa mulai dibuat, Brian Paul mendapat ijin dari SGI untuk menggunakan struktur perintah dari OpenGL. Karena Mesa tidak secara resmi berhubungan dengan SGI maka tidak ada garansi bahwa kode program dapat bekerja secara sempurna.

  Pada tahun 1996 pengembang game id software mengeluarkan tiga program

  Dimensi pada industri game. Tiga patch tersebut antara lain Verite Quake, Rendition Quake, dan GL Quake yang menggunakan OpenGL. Quake adalah game pertama yang menggunakan kelebihan perangkat keras akselerasi secara penuh dan permasalahannya adalah sedikit kartu grafik yang mendukung rendering OpenGL. Kartu grafis pendukung OpenGL pertama yang dijual untuk konsumen umum adalah 3DFX Voodoo atau seri Voodoo dari perusahaan Interactive. Sejak saat itu penggunaan kartu grafis mulai diterima konsumen umum dan perusahaan kartu grafis lainnya mulai membuat kartu yang diberi label mendukung GL Quake. 3DFX juga membuat API 3-Dimensi sendiri bernama GLIDE Pada tahun 1998, Microsoft memperkenalkan API 3-Dimensi yang disebut Direct3D yang dimasukkan dalam komponen multimedia DirectX. Karena kepopuleran GL Quake, banyak software yang memakai mesin Quake untuk membuat game dan menjadikannya standar untuk grafik game komputer. Setelah beberapa tahun, perkembangan OpenGL masih tetap sedangkan Direct3D semakin populer dan menjadi standar untuk perkembangan game.

  Kelebihan OpenGL ada pada pengembangan grafika CAD dan sifatnya yang dapat berjalan pada banyak sistem operasi. Sebagai perbandingan, Glide hanya mendukung Windows dan GNU atau linux dan sekarang sangat jarang dipakai. Direct3D hanya mendukung Windows dan mesin video game Xbox.

  OpenGL dapat mendukung Windows, GNU linux, Mac OS, UNIX, AIX, HP- UX, FreeBSD, NEXTstep, OPENstep, OS/2, BeOS dan Playstation 2

  Pada Juli 2002 OpenGL mengeluarkan versi 1.04 yang diikuti dengan Mesa versi 5 yang dikenalkan pada Oktober 2002. Kedua API ini mempunyai kemampuan yang sama. Baik OpenGL dan Mesa mendukung rendering oleh perangkat keras akselerasi yang berarti kartu grafis dapat melakukan perhitungan yang biasanya dihitung oleh CPU. Jika tidak ada perangkat keras akselerasi maka perhitungan akan dilakukan oleh CPU. Contohnya pada proses memutar obyek dan perubahan ukuran, prosesor menghitung dan kemudian menggambar obyeknya. Proses tersebut akan memperlambat proses rendering karena CPU membuang waktu karena ada operasi lain juga memerlukan perhitungan seperti AI, suara, dan lain-lain.

2.5.2 PEMAKAIAN OPENGL

  API OpenGL dibagi menjadi 3 bagian antara lain

  1 Fungsi-fungsi yang didefinisikan oleh OpenGL yang sama seperti ditetapkan pada OpenGL Architecture Review Board yaitu yang berada pada library opengl32.dll dengan file header gl.h. Fungsi dari library ini berawalan kata gl.

  2 Fungsi-fungsi yang ada pada OpenGL Utility Library (GLU) atau glu32.dll dengan file header glu.h. Library ini berisi beberapa fungsi yang membuat tugas lebih mudah seperti pembuatan matrik, pembuatan polygon dan rendering permukaan. Library ini sebenarnya dibuat menggunakan perintah OpenGL yang kemudian digaransikan dapat bekerja dalam semua sistem yang mendukung OpenGL. Fungsi- fungsi ini berawalan kata glu.

  3 Fungsi-fungsi yang ada dalam Auxiliary (bantuan) atau AUX yang ada pada library glaux.lib dengan file header glaux.h. Fungsi yang ada di sini bukan merupakan bagian dari yang ditetapkan OpenGL, tetapi karena library bantuan ini menyediakan kerangka kerja yang bebas untuk memanggil fungsi OpenGL. Library ini berasal dari SDK Win32 dan fungsi-fungsinya berawalan aux.

  Library AUX digunakan hanya di sistem operasi Windows dan untuk sistem operasi lain digunakan library yang berbeda. Pada X-Window, library bantuan yang digunakan adalah OpenGL Extension to the X Window System (GLX). Microsoft Windows menggunakan WGL yang hanya bisa menggambar pada satu buah jendela dan dengan bantuan library AUX dapat membuat banyak jendela seperti menu, kotak dialog dan lain-lain. IBM OS/2 digunakan Presentation Manager to OpenGL interface (PGL).

  OpenGL juga mempunyai alat bantu yang bisa menyembunyikan kerumitan pemrograman windows yaitu OpenGL Utility Toolkit (GLUT) yang dibuat Mark Kilgard. Selain itu juga terdapat Open Inventor yang merupakan alat bantu berorientasi obyek yang menyediakan obyek dan metode untuk menciptakan grafik 3-Dimensi.

  Visual C++ adalah bahasa pemrograman C++ versi Microsoft. Bahasa C++ berkembang berdasar pada bahasa pemrograman C yang berevolusi lebih lanjut dan mendukung pemrograman berorientasi obyek.

  Untuk membuat jendela pada sistem operasi Microsoft Windows terdapat 4 bagian yang harus dilewati karena Windows mempunyai API tersendiri.

  Bagian-bagian tersebut antara lain:

  1 Menentukan dan mendaftar class Windows Hal yang dilakukan adalah menentukan headernya windows.h yang mencakup semua fungsi, struktur, konstanta API WIN32.

  Selanjutnya pendeklarasian fungsi WndProc untuk penanganan pesan (message handler) utama dan fungsi utamanya yaitu fungsi WinMain dengan pengembalian integer.

  2 Pembuatan Windows Dua hal utama yang dilakukan disini adalah mendefinisikan class Windows dan pembuatan jendela Windows sebenarnya.

  3 Looping pesan dari Windows Ketika aplikasi berjalan, aplikasi tersbut terus menerus mendapat pesan dari program Windows. Pesan tersebut kemudian dikirim ke antrian pesan. Keika aplikasi siap memproses pesan berikutnya maka aplikasi akan memanggil pesan GetMessage yang akan memanggil pesan dari antrian ke bentuk struktur MSG dan kemudian diubah dan diproses oleh penanganan pesan (message handler). Agar aplikasi selalu berjalan dan memproses semua pesan maka dibuat loop sampai pemakai menghentikan aplikasi.

  4 Pembuatan penanganan pesan atau message handler Message handler yang telah didefinisikan di langkah awal adalah fungsi yang menangani semua pesan yang dikirim ke aplikasi Windows. Ketika pemakai menekan tombol atau menggerakkan mouse, pesan akan terkirim ke aplikasi. Ketika hal tersebut terjadi ada pilihan untuk memprosesnya atau membiarkannya sesuai dengan yang telah ditentukan pembuat aplikasi tersebut. Gambar 2.11 memperlihatkan bagaimana proses pembuatan Windows pada API Win32.

Gambar 2.11 Proses pembuatan jendela Windows

BAB III ANALISA MASALAH

3.1 SHADING

  Shading adalah proses dari perhitungan pembuatan cahaya dan menentukan

  warna pikselnya. Ada tiga tipe utama shading yang sering digunakan yaitu

  flat, gouraud dan phong yang kesemuanya merespon perhitungan cahaya

  tiap polygon, tiap vertex dan tiap piksel. Pada flat shading, warna dihitung pada segitiga dan segitiga tersebut diisi dengan warna. Pada gouraud

  shading, cahaya pada setiap vertex dari segitiga ditentukan dan sinar cahaya

  disisipkan di atas permukaan segitiga. Pada phong shading, normal shading disimpan pada vertex yang digunakan untuk menyisipkan efek pada piksel.

  Selain itu masih ada tipe shading lain semisalnya toon shading atau cell shading. Gambar 3.1 adalah contoh shading untuk efek realistik.

Gambar 3.1 Model shading untuk pencahayaan nyata

3.2 TOON SHADING

  Seperti merubah jenis huruf cetakan pada tulisan akan memberikan rasa yang berbeda, jenis rendering yang berbeda juga akan memberikan suasana, arti, dan persepsi tersendiri. Ada banyak perhatian yang diberikan pada salah satu bagian bentuk non photorealistic rendering ini yaitu cell shading atau toon rendering. Sejak diperkenalkan, cell shading diidentifikasikan dengan kartun, dan dikonotasikan dengan fantasi dan sesuatu yang kekanak- anakan.

Gambar 3.2 menunjukkan beberapa ciri khas gaya kartun non realistic antara lain adanya perpotongan gambar yang jelas, ciri warna penuh pada gambar,

  dan garis tepi jelas. Salah satu alasan mengapa gaya ini populer adalah konsep penguatan melalui penyederhanaan. Penyederhanaannya, obyek digambar dengan garis yang jelas, dan membagi daerah yang mempunyai warna penuh. Dengan penyederhanaan dan membuang kerumitan, akan dihasilkan efek dari informasi yang berkaitan dengan apa yang disajikan. Untuk karakter kartun, penonton umumnya akan mengindentifikasikan dengan sesuatu yang digambar dengan gaya yang sederhana. Gaya toon rendering telah digunakan di grafika komputer selama lebih dari sepuluh tahun untuk menyatukan model 3-Dimensi dengan animasi 2-Dimensi. Penyatuan ini membuat toon

  

rendering berjalan bagus karena pembangkit otomatis oleh komputer yang

lebih mudah didefinisikan daripada bentuk NPR lainnya.

  Ada beberapa pendekatan yang berbeda pada toon rendering. Untuk model dengan teksture dan tidak ada pencahayaan, gaya kartun dengan pengisian padat dapat di perkirakan oleh penghitungan teksture. Untuk shading, dua metode yang umum adalah mengisi daerah dengan warna padat atau menggunakan pendekatan dua tingkatan yang mewakili cahaya dan bayangan. Pembuatan warna yang padat akan mudah dibuat, tetapi pendekatan dua tingkatan (sering disebut hard shading) dapat dibentuk dengan mengubah perhitungan elemen cahaya. Selain itu juga terdapat silhoutte yang juga

3.3 CELL SHADING

  Lake et al dan Lander keduanya menggunakan ide dengan menghitung cahaya

  diffuse dengan dikalikan n-1 untuk setiap vertex dan menggunakan nilai ini

  sebagai koordinat teksture untuk mengakses tabel teksture 1-Dimensi. Teknik tersebut bisa diimplementasikan dengan sebuah vertex shader sederhana.

  Tabel teksture tersebut hanya mempunyai dua warna yaitu terang dan gelap. Jika permukaan face dari polygon menghadap menghadap sinar cahaya, maka pemberian warna terang dilakukan. Penggunaan umumnya pada cahaya diffuse adalah jika masa n . 1 < 0 berarti permukaan tidak menghadap sinar cahaya dan berada dalam bayangan. Penggunaan ini juga digunakan dengan membuat tabel teksture lain dengan nilai yang diinginkan.

3.3.1 METODE CELL SHADING

  Teknik yang digunakan pada cell shading ini adalah mencari batasan perubahan antara daerah yang terkena cahaya dan yang tidak, kemudian mengisi setiap daerah dengan warna padat. Untuk itu digunakan rumus pencahayaan komponen diffuse sebagai berikut.

  C 1 = a glob x m amb + s amb x m amb + (max ((n . l),0)) s diff x m diff C 1 adalah warna pada vertex i. Variabel lain (a) adalah ambient, (m) adalah material, (s) adalah cahaya dan bagian penerangannya (glob) untuk global, (amb) untuk ambient dan (diff) untuk diffuse serta (l) adalah vektor darri sumber cahaya ke vertex, (n) adalah normal untuk permukaan pada vertex.

  Faktor tambahan dalam hasil perkalian diffuse membuat bagian dari istilah yang penting jika sinar cahya mengenai permukaan dalam sudut lebih dari o 90 . Jika hasil perkalian adalah negatif dan semua nilai adalah 0. ini menjadi kasus ketika cahaya datang dari belakang permukaan, yang sama dengan bayangan. Itu terjadi pada persamaan di atas yaitu tidak ada cahaya ditambahkan pada sinar ambient.

  I dihitung melalui normalisasi jarak dari vektor s dari asal ke posisi cahaya dengan vektor p ke titik posisi obyek dalam bentuk koordinat. Bentuk dari

  Pendekatan nyata untuk menghasilkan shading gaya kartun adalah shading menurut urutan tiap-tiap piksel. Tetapi ini tidak menguntungkan, di mana perangkat keras grafik tidak menyediakan dukungan pada operasi itu. Pilihan lain yang mungkin adalah penggunaan perangkat keras dengan variasi

  

gouraud shading yang juga tidak didukung oleh perangkat keras grafik juga.

  Tetapi ada pilihan yang rumit tetapi memberikan jalan keluar yang cepat pada permasalahan ini. Daripada menghitung warna tiap vertex, digunakan tabel teksture 1-Dimensi dengan warna yang sedikit. Tanpa beberapa keuntungan seperti penonjolan, tabel ini memberikan warna yang minimum yaitu dua, satu untuk warna yang terkena cahaya dan satunya untuk warna terang seperti

gambar 3.2. Catatan bahwa perubahan titik antara dua warna bisa diubah- ubah, dalam kasus ini adalah pada nilai tengah (0,5) tetapi tidak

  mempengaruhi tampilan pada hasil akhir untuk menghasilkan perbedaan yang kuat. Semakin gelap teksture semakin gelap gambar yang dihasilkan.

Gambar 3.2 tabel teksture 1-Dimensi warna yang lebih terang dari tabel teksture dihitung jika ini langsung terang.

  o Ini berarti sinar akan ada sudut dari 0 antara l dan n. Ketika hasil perkalian adalah sama dengan cosinus dari sudut antara dua vektor, hasil l.n menghasilkan satu (lihat persamaan lengkap di awal). Maka perubahan perhitungan untuk warna terang adalah sebagai berikut.

  C 1 = a glob x m amb + s amb x m amb + s diff x m diff

  Warna bayangan untuk bayangan dalam tabel teksture juga dihitung. Jika tidak ada sinar yang berperan, hanya bagian sinar ambient saja yang menyediakan intensitas bukan cahaya. Perhitungan l . n ditetapkan 0 maka persamaannya sebagai berikut.

  C 1 = a glob x m amb + s amb x m amb

  Perhitungan ini dihitung tiap material dan disimpan sebelum melakukan

  render. Ketika render setiap frame dihitung max(l.n) setiap vertex dan

  menggunakan tiap nilai vertex sebagai nilai koordinat dalam perhitungan sebelum pemberian teksture pada obyek. Vertex tersebut kemudian ditentukan nilai warnanya sesuai dengan yang ada dalam tabel teksture. Setiap titik diwarnai sesuai dengan teknik tersebut, keseluruhan gambar kemudian dilakukan render.

3.3.2 FLOWCHART

Gambar 3.3 adalah flowcart bagaimana proses cell shading sebelum dilakukan rendering.Gambar 3.3 Flowchart metode cell shading

BAB IV IMPLEMENTASI

4.1 PEMAKAIAN OPENGL

  Ada dua API grafika populer yang sering digunakan, yaitu OpenGL dan DirectX. Kelebihan utama dari OpenGL adalah bisa digunakan dan dikembangkan di berbagai sistem operasi seperti Windows, Mac OS, Linux dan sistem operasi lainnya. Sedangkan DirectX hanya bisa digunakan di lingkungan Microsoft atau Windows.

  Sebagai API yang bisa digunakan di banyak sistem operasi, pemrograman OpenGL bisa dibagi dalam berbagai cara antara lain memakai Windows atau Linux atau Mac OS. Jika memakai Windows pilihan lain adalah apakah memakai GLUT ataukah Win32. GLUT (OpenGL Utility Toolkit) adalah library yang digunakan untuk mempersingkat proses penciptaan jendela OpenGL sebaik proses penangkapan masukan dari mouse dan keyboard. Keuntungan pemakaian library ini adalah bisa digunakan di banyak sistem operasi dan bebas digunakan. Keuntungan pemakaian Win32 adalah lebih lengkap, lebih fleksibel, lebih banyak pilihan tatap muka pemakai, modifikasi properti, dan lain-lain. Kekurangan dari pemakaian Win32 adalah hanya bisa digunakan dalam lingkungan Windows. Dengan kemudahan pemakaian dan lebih fleksibel maka implementasi menggunakan Win32 dalam sistem operasi Windows dan kompiler yang dipilih adalah Visual C++ versi 6.

4.2 PENEMPATAN OPENGL DI VISUAL C++

  Pembuatan program dalam Visual C++ memerlukan pembuatan proyek sebagai tempat file-file disimpan. Jenis proyek yang ditawarkan Visual C++ ada banyak seperti MFC AppWizard dan WIN32 dalam berbagai bentuk. Proyek yang umum dipakai untuk pemrograman OpenGL adalah proyek MFC AppWizard atau Win32 Application atau Win32 Console. Win32 Console biasa digunakan untuk pemrograman UNIX atau DOS dan pemrograman OpenGL-nya biasanya menggunakan GLUT. Pemakaian MFC AppWizard akan rumit berdasarkan Microsoft Foundation Classes, dan aplikasi yang dibuat mempunyai jendela program yang kompleks.

  Pemakaian Win32 Application lebih sederhana karena akan membuat program aplikasi standar Windows atau Win32. Implementasi dalam program ini memakai Win32 Application dengan membuat jendela Windows seperlunya saja. Bentuk proyek Win32 Application yang dipakai adalah proyek kosong.

  Setelah membuat proyek maka semua file berisi perintah-perintah program seperti file CPP, header dan lainnya dimasukkan dalam proyek. Hindari pembuatan file terlebih dahulu, karena kemungkinan ada kesalahan terjadi seperti proyek yang tidak sesuai program.

  Dengan memilih proyek WIN32 Application semua library yang

  Selain library yang diperlukan untuk pemrograman Win32, ada tiga file library yang diperlukan untuk pemrograman OpenGL berbasis Win32 yaitu OpenGL32.lib, GLu32.lib dan GLaux.lib. Ketiga library ini perlu dihubungkan pada proyek aplikasi OpenGL dengan menambahkan ketiganya pada daftar file yang akan di-link pada pembuatan file Cara lain penghubungan library adalah menambahkan kalimat perintah yang akan menghubungkan proyek aplikasi pada library OpenGL.

  #pragma comment(lib, "opengl32.lib") #pragma comment(lib, "glu32.lib") #pragma comment(lib, “glaux.lib) Selain itu proyek aplikasi OpenGL juga perlu dihubungkan pada file headernya untuk keperluan pembuatan aplikasinya yaitu windows.h yang berisi deklarasi untuk semua tugas dalam API Win32 dan tiga file header dari library yang dibutuhkan.

  #include <windows.h> #include <GL/gl.h> #include <GL/glu.h> #include <GL/glaux.h>

  Untuk memulai program diperlukan fungsi utama untuk dieksekusi yaitu yaitu fungsi WinMain. Nilai return berisikan nol jika tidak ada kesalahan yang terjadi. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE

  { glEnable(GL_LIGHTING); return 0; }

  Pengecekan terhadap koneksi OpenGl dapat dilakukan dengan menambahkan sebuah perintah OpenGL pada fungsi WinMain misalkan glEnable(GL_LIGHTING). Jika setelah dikompile benar tetapi pada pembuatan file aplikasi ditemukan kesalahan berarti link pada OpenGL belum tepat posisinya. Jika pada pembuatan file berhasil tanpa tampilan kesalahan maka pemakaianan OpenGL sukses. Gambar 4.1 menunjukkan bagaimana pesan berhasil pemakaian OpenGL pada visual C++.

Gambar 4.1 hasil pelacakan Visual C++

4.3 MEMBUAT JENDELA OPENGL OpenGL bisa membuat aplikasi layar penuh atau dalam jendela.

  Implementasi aplikasi ini membuat program dalam bentuk jendela OpenGL agar lebih mudah pembandingannya serta dapat diubah ukuran jendelanya.

  Pembuatan aplikasi OpenGL memerlukan fungsi yang menangani

  OpenGL. Selain itu Jendela OpenGL yang berdasar API windows juga dilengkapi fungsi untuk masukan dari keyboard dan mouse serta fungsi untuk perubahan proyeksi dan model view ketika jendela diubah ukurannya.

  Pada fungsi WinMain yang dieksekusi pertama kali program berjalan perlu ditambahkan perintah yang memanggil fungsi pembuatan jendela windows yaitu CreateGLWindow.

  If(!CreateGLWindow("Membuat Jendela OpenGL",640,480,16)) { return 0; }

4.3.1 FUNGSI CREATEGLWINDOW

  Pada fungsi CreateGLWindow dibuat jendela dengan perintah-perintah dari API Win32. Perintah-perintah awal adalah membuat jendela pada sistem operasi Windows. Perintah yang berhubungan dengan OpenGL adalah struktur PIXELFORMATDESCRIPTOR. Struktur ini memuat data yang disimpan untuk setiap piksel pada aplikasi. Banyak buffer yang dibuat oleh OpenGL dan setiap buffer memerlukan tambahan memori untuk disediakan tiap piksel.

  Isi dari struktur PIXELFORMATDESCRIPTOR antara lain PIXELFORMATDESCRIPTOR pfd = sizeof(PIXELFORMATDESCRIPTOR), ( WORD nSize - Ukuran dari data struktur biasanya menggunakan perintah sizeof() dari struktur itu sendiri).

  1, ( WORD nVersion – versi dari struktur ini yaitu versi 1)

  PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL PFD_DOUBLEBUFFER,

  ( DWORD dwFlags – properti buffer piksel antara lain : PFD_DRAW_TO_WINDOW buffer dapat menggambar ke window.

  PFD_DRAW_TO_BITMAP buffer dapat menggambar di memori bitmap. PFD_SUPPORT_OPENGL buffer mendukung penggambaran OpenGL. PFD_DOUBLEBUFFER dapat menggunakan buffer ganda yang diperlukan untuk memperhalus ketika merender secara real time)

  PFD_TYPE_RGBA, ( BYTE iPixelType – tipe data piksel bisa diisi PFD_TYPE_RGBA atau PFD_TYPE_COLORINDEX tergantung tipe pewarnaan yang digunakan) bits,

  ( BYTE cColorBits – menunjukkan jumlah warna pada setiap buffer warna, mewakili bit tiap piksel yang disediakan ) 0, 0, 0, 0, 0, 0, 0, 0,

  ( BYTE c BYTE c Red/Green/Blue/Alpha Bits (atas) dan BYTE c Red/Green/Blue/Alpha Shift (bawah) – atas adalah hitungan jumlah untuk setiap kadar warna terpisah (color bits), bawah adalah hitungan perubahan setiap kadar warna yang berubah (alpha bits, perubahan). Jika tidak digunakan maka nilai yang dimasukkan adalah nol.)

  I 0, 0, 0, 0, ( BYTE cAccumBits dan BYTE cAccum Red/Green/Blue/Alpha

  Bits – nilai pertama adalah tanda apakah menggunakan akumulasi bit, empat nilai terakhir adalah jumlah nilai warnanya dalam buffer akumulasi.

  Nilai nol diberikan jika tidak digunakan) 16,

  ( BYTE cDepthBits – menunjukkan jumlah dari bits dari depth buffer yang digunakan untuk menentukan obyek mana yang tampak depan atau belakang. Aplikasi ini menggunakan kedalaman 16 BIT)

  0, ( BYTE cStencilBits – menunjukkan kedalaman dari stencil buffer) 0, ( BYTE cAuxillaryBuffers – menunjukkan jumlah dari auxillary buffers atau buffer bantuan) PFD_MAIN_PLANE, ( BYTE iLayerType – Tipe lapisan untuk menggambar utama diisikan PFD_MAIN_PLANE, versi dahulu dikosongkan)

  0, 0, 0 ( DWORD dw Layer/Visible/Damage Mask – Lapisan atas adalah lapisan cadangan dan bawah adalah lapisan mask yang menyediakan transparasi warna atau indek yang melandasi suatu bidang)

  ; } Hal penting dalam fungsi CreateGLWindow selain pembuatan jendela dan struktur PIXELFORMATDESCRIPTOR adalah beberapa pengecekan apakah pembuatan windows berhasil. if (!(hDC=GetDC(hWnd)))

  Fungsi perintah ini adalah mengecek apakah mendapat device context dari Windows . if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))

  Fungsi perintah ini adalah mengecek apakah format piksel yang dibuat cocok dengan yang ada di Windows. if(!SetPixelFormat(hDC,PixelFormat,&pfd))

  Fungsi perintah ini adalah mengecek apakah Windows dapat membuat format piksel yang telah buat.

  Setelah pembuatan Jendela Windows, pembuatan struktur PIXELFORMATDESCRIPTOR, dan pengecekan berhasil maka Jendela Window bisa ditampilkan dengan perintah ShowWindow(hWnd,SW_SHOW). Pembuatan Jendela Window diikuti dengan perintah lain yaitu pengesetan fokus dan foreground dan yang penting adalah pemanggilan fungsi untuk membuat proyeksi dan model view yaitu fungsi ReSizeGLScene.

  4.3.2 FUNGSI KILLGLWINDOW

  Selain fungsi untuk membuat jendela Windows diperlukan juga fungsi untuk mematikan jendela Windows tersebut. Dalam aplikasi ini fungsi itu diberi nama KillGLWindow. Fungsi ini dipanggil jika terdapat kesalahan dalam program atau mendapat masukan ESC atau WM_Close dari jendela.

  Ada tiga tahap yang diperlukan untuk menutup jendela Window dan jika menggunakan render maka tahapan tersebut akan menjadi lima. Tahap pertama untuk menutup jendela tanpa render adalah Melepaskan Device Context dari Windows yang tidak kita gunakan lagi. Tahap kedua adalah menghancurkan jendela Windows secara aman setelah tahap sebelumnya.

  Tahap ketiga adalah melepaskan register dari class yang digunakan.

   4.3.3 FUNGSI WNDPROC

  Pada pemrograman Win32 terdapat penanganan peristiwa seperti jika ada masukan dari keyboard atau mouse, screen saver, dan lain-lain. Penanganan tersebut menggunakan fungsi WndProc. Fungsi ini memerlukan bantuan dua variabel tambahan yaitu active dan keys [256].

  Variabel active digunakan untuk membuat looping pada fungsi WinMain dan jika terdapat input atau kejadian yang bertujuan mematikan program yang mewakili tombol keyboard dan setiap tombol disimpan dalam bentuk boolean untuk mengetahui apakah ditekan ataukah tidak.

4.3.4 FUNGSI RESIZEGLSCENE Fungsi ini berguna untuk mengubah Windows dan inisialisasi Windows.

  glViewport(0,0,width,height)berguna untuk mereset sudut pandang, glMatrixMode(GL_PROJECTION) untuk memilih jenis proyeksi dan glLoadIdentity() untuk mereset matrik. Selain itu perintah gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f) berguna untuk menghitung perbandingan dengan jendela Windows dan perintah glMatrixMode(GL_MODELVIEW) untuk memilih jenis matrik yang dipakai. Gambar 4.2 adalah hasil dari pembuatan windows tanpa rendering.

Gambar 4.2 Jendela OpenGL

4.4 RENDERING

  Rendering gambar atau animasi adalah hadiah pada akhir kerja dari sebuah desain dan animasi 3-Dimensi. OpenGL mendukung fungsi-fungsi untuk rendering yang memungkinkan layar komputer menghasilkan gambar yang diinginkan.

  Secara umum ada tiga perintah utama yang diperlukan untuk menggunakan fasilitas rendering. Perintah pertama adalah glClearColor. Perintah ini memberi keterangan warna apa yang ditampilkan bilamana buffer warna dikosongkan. Ada empat parameter yang digunakan perintah glClearColor yaitu untuk mewakili warna RGB yaitu merah, hijau, biru dan warna alpa yang digunakan untuk fungsi transparansi dan blending. Pemberian warnanya diisi menurut kadar campuran warna RGB misalnya warna merah tanpa efek alpa adalah (1, 0, 0, 0), abu-abu adalah (0.5, 0.5, 0.5, 0).

  Biasanya perintah glClearColor ditempatkan pada fungsi inisialisasi dan ditambahkan perintah-perintah lain yang mendukung seperti glShadeModel, glEnable, dan lain-lain yang mendukung proses rendering. Perintah utama kedua untuk rendering adalah glClear. Perintah glClear berguna untuk mengosongkan buffer-buffer dalam OpenGL seperti jika mengisikan GL_COLOR_BUFFER_BIT berarti mengosongkan buffer warna atau mengisikan GL_DEPTH_BUFFER_BIT berarti mengosongkan buffer kedalaman. Perintah ini biasanya ditambah dengan perintah lain seperti glLoadIdentity untuk reset matrik. Perintah glClear ditempatkan pada fungsi display atau utama untuk memulai penggambaran dengan OpenGL.

  Perintah utama ketiga untuk rendering adalah glFlush. Perintah glFlush berguna memastikan OpenGL bahwa semua perintah OpenGL telah siap diproses atau dirender. Perintah ini diletakkan setelah perintah glClear beserta perintah-perintah openGL yang berfungsi untuk penggambaran.

  Fungsi ini bisa dihilangkan jika yang digambar oleh OpenGL adalah gambar sederhana, tetapi akan terasa jika gambar yang dibuat adalah gambar lengkap dan besar. Perintah ini akan menghilangkan flick (ceklikan) pada saat rendering gambar dan sangat berguna dalam pemrograman jaringan.

  Pada implementasi ini, perintah glClear berada pada fungsi DrawGLScene yang akan dipanggil terus menerus dari fungsi WinMain. Kemampuan aplikasi untuk rendering ini memerlukan tambahan perintah yang mendukung rendering yaitu pengecekan apakah bisa rendering dan percobaan rendering pada fungsi CreateGLWindow dan pengecekan apakah ada bentuk rendering dan percobaan mematikan bentuk rendering pada fungsi killGLWindow. Gambar 4.3 adalah hasil render sederhana OpenGL.

Gambar 4.3 Rendering dasar OpenGL

4.5 PENGGUNAAN MODEL

  Setelah mendapat jendela window yang dapat melakukan rendering langkah selanjutnya yang dilakukan adalah membuat model untuk ditampilkan.

  Model yang dibuat dalam implementasi ini adalah model 3-Dimensi seperti tujuan awal adalah membuat model 3-Dimensi terlihat seperti 2-Dimensi.

  Sebagai perbandingan, Direct3D mempunyai file tersendiri yaitu file .X yang berisi model 3-Dimensi dengan bentuk model berupa mesh polygon beserta properti dan animasinya. Mesh polygon dalam Direct3D dapat ditemukan dalam bentuk struktur mesh dalam file .X atau kelas

  ID3DXMesh dan lain-lain. Pada OpenGL file tidak ada model yang resmi dan yang biasa digunakan adalah file berekstensi OBJ, MD2, MD3 serta lainnya. Untuk pembuatan model secara struktural berupa mesh polygon,

  OpenGL memakai perintah yang memanfaatkan segitiga atau segiempat yang dibentuk menjadi bentuk polygon.

  Pembuatan mesh polygon secara struktural dimulai dengan perintah glBegin diikuti dalam kurung bentuk face yang diinginkan yaitu GL_TRIANGLES untuk segitiga atau GL_QUADS untuk segiempat dan ada juga lainnya seperti GL_POLYGONS, GL_LINES, GL_POINTS, dan lain-lain. Perintah glBegin akan ditutup dengan perintah glEnd yang berarti telah selesai membuat polygon. Semua pembuatan tersebut dilakukan pada fungsi DrawGLScene antara perintah glClear dan glFlush. Penentuan titik vertex pada pembuatan obyek 3-dimensi menggunakan perintah glVertex3f dengan mengisikan posisi koordinat-X, koordinat-Y, koordinat Z. Jika hanya menggambar 2-Dimensi maka perintah yang digunakan adalah glVertex2f. Selain itu digunakan perintah glNormal3f untuk menentukan normal. Normal berguna untuk menentukan letak bagian luar atau sudut sinar datang dan efeknya akan terasa pada saat pencahayaan.

  Contoh pembuatan kubus adalah menentukan titik-titik pembangun kubus yang terdiri dari delapan buah titik TITIK

  X Y Z

  • 1.0 -1.0

  1.0

  1 1.0 -1.0

  1.0

  2

  1.0

  1.0

  1.0 4 -1.0

  1.0

  1.0 5 -1.0 -1.0 -1.0 6 -1.0 1.0 -1.0

  7

  1.0 1.0 -1.0

  8 1.0 -1.0 -1.0 Normal dari kubus ada 6 yang mewakili arah menghadap permukaan sisi. Daftar muka nX nY nZ

  0.0

  0.0

  1.0

  1

  0.0 0.0 -1.0

  2

  0.0

  1.0

  0.0

  3 0.0 -1.0

  0.0

  4

  1.0

  0.0

  0.0 5 -1.0

  0.0

  0.0 Contoh pembuatan kubus adalah menentukan Titik-titik yang telah ada dengan daftar muka yang ada atau dengan kata lain sesuai dengan arah permukaan sisi. Selain itu pembuatan polygon untuk membuat obyek penentuan titiknya harus sesuai dengan arah jarum jam seperti contoh yang ada dalam tabel.

  Muka Titik Nor mal

  0 Depan 0,1,2,3 0,0,0,0

  1 Belakang 4,5,6,7 1,1,1,1

  2 Atas 5,3,2,6 2,2,2,2

  3 Bawah 4,7,1,0 3,3,3,3

  4 Kanan 7,6,2,1 4,4,4,4

  5 Kiri 4,0,3,5 5,5,5,5

Gambar 4.4 adalah contoh hasil render yang menggunakan model yaitu model kubus sederhana yang dibuat dengan menentukan titik dan sisinya

  secara manual.

Gambar 4.4 Rendering model sederhana

4.6 ROTASI OBYEK

  Langkah selanjutnya adalah membuat animasi sederhana sebagai petunjuk bahwa rendering yang dilakukan adalah secara real time dan sebagai kelebihan penggunaan aplikasi 3-Dimensi daripada aplikasi 2-Dimensi. Animasi yang akan dibuat sangat sederhana yaitu membuat obyek berputar dan hanya menggunakan beberapa perintah saja untuk melakukannya.

  Dalam aplikasi 3-Dimensi tradisional diperlukan perkalian antar matrik yaitu antara matrik obyek dan matrik pengubah nilai 4 x 4 untuk membuat obyek bergerak, berputar atau lainnya. OpenGL memberikan kemudahan dengan memberi perintah seperti glRotatef, glTranslatef, glScalef untuk nilai float, glRotated, glTranslated, glScaled untuk nilai double yang bisa digunakan untuk animasi sederhana. Penggunaan glRotatef untuk perputaran obyek adalah dengan mengisikan nilai perputaran atau letak bendanya sesuai dengan koordinat sumbunya, serta diperlukan sebuah nilai yang akan berkembang sesuai dengan pergerakan yang ada.

4.7 PEMAKAIAN FILE UNTUK MODELING

  Pembuatan model secara manual sangat sukar, terutama saat penentuan posisi titiknya dan menentukan normalnya. Alternatif lain untuk menghasilkan model adalah dengan menggunakan bantuan program aplikasi 3-Dimensi seperti 3DMax, Maya, Blender, Milkshake dan lainnya untuk menghasilkan obyek 3-Dimensi. OpenGL hanya mendukung sedikit obyek bawaan seperti Cube, Torus, Sphere dan poligon dasar lain. Dengan menggunakan program pembuat model 3-Dimensi, model lebih mudah dibuat dan format filenya bermacam-macam. Format file 3-Dimensi yang mudah dipahami antara lain berekstensi X, RAW, PLY, VRML, OFF, EGG dengan alasan adalah semuanya menggunakan format text bukan binary.

  Hal yang pertama dilakukan untuk pemakaian model dari file luar adalah membuat struktur yang mempresentasikan mesh polygon. Struktur mesh polygon ini berisi titik-titik beserta normalnya serta koordinat teksturenya atau warnanya. typedef struct tagVECTOR

  { float X, Y, Z; } VECTOR; typedef struct tagVERTEX { VECTOR Nor; typedef struct tagPOLYGON {

  VERTEX Verts[3]; } POLYGON Pengisian koordinat teksture dilakukan dengan perintah glTexCoord2f atau glTexCoord1f sesuai dengan tabel warna yang dipakai. Jika memakai file lain seperti file gambar untuk menempel model kita maka digunakan glTexCoord2f, sedangkan jika untuk memberi warna sederhana seperti cell

  

shading hanya diperlukan satu tabel warna dan menggunakan

  glTexCoord1f. Pembuatan polygon struktur di atas hanya mendukung pemodelan dengan GL_TRIANGLES. Penggunakan GL_TRIANGLES ini akan membentuk poligon atau face secara otomatis setelah tiga kali vertex atau 9 verts atau setiap polygon. Jika ingin menggunakan GL_QUADS, maka diperlukan 4 vertex sehingga struktur yang dipakai harus diubah menjadi 4 verts setiap polygon.

  Setelah mempunyai struktural tersebut nilai-nilai koordinat X, Y, Z dapat dimasukkan setelah memodifikasi salah satu file di atas. Sebagai contoh adalah pemakaian file RAW yang cara penulisannya adalah secara berturutan setiap baris membentuk polygon segitiga yaitu X1, Y1, Z1, X2, Y2, Z2, X3, Y3, Z3 tanpa normal. File OFF menjabarkan koordinat titik- titiknya dengan indek angka urutannya dan kemudian membuat polygon yang menunjukkan angka urutan titik-titik tersebut. File egg dan X sama penggunaanya dengan file OFF tetapi dilengkapi dengan normalnya.

  C++ yaitu dengan menambah header stdio.h yang merupakan standar untuk memasukkan atau mengirim data dan header fstream.h yang digunakan untuk berhubungan dengan file lain.

Gambar 4.5 Rendering model dari file

  Setelah mendapat struktur poligon yang diinginkan, maka poligon-poligon tersebut perlu digambarkan kembali dengan perintah glVertex3f secara berurutan untuk koordinat titiknya atau dengan perintah glVertex3fv untuk setiap posisi vertsnya yang mencakup semua koordinat X, Y, Z beserta normalnya. Gambar 4.5 adalah contoh hasil rendering yang mengambil model dari file model yang terpisah dari aplikasi yang dibuat.

  Untuk dapat memakai efek cahaya, hal yang pertama dilakukan adalah mengaktifkan cahaya tersebut dengan mengetikkan glEnable(GL_LIGHTING). Ada tiga macam cahaya yang dapat dipakai yaitu specular yang terpantul tidak seragam, diffuse yang pantulannya tersebar dan ambient yang jatuh ke obyek dari berbagai sudut pandang lingkungan dan juga shinisess yang mengkilap. Sebelum memakainya dengan perintah glLightfv dengan mengisikan nama cahaya, jenis cahaya dan ketentuan yang dibuat sebelumnya seperti warna atau posisi. Hal terakhir yang dilakukan adalah mengaktifkan cahaya tersebut dengan memanggil nama cahaya tersebut yaitu dengan mengetik glEnable dan mengisi nama cahaya dalam kurung. Dengan sistem penamaan maka dimungkinkan untuk membuat cahaya lebih dari satu. Hasil cahaya yang didapat pada sebuah obyek adalah warna dari pertambahan warna-warna cahaya beserta intensitasnya yang mengenai obyek tersebut. Gambar 4.6 adalah hasil rendering dengan pencahayaan normal.

Gambar 4.6 rendering dengan pencahayaan normal.

4.8 Cell shading Metode model cahaya cell shading telah dibahas dalam bab tiga.

  Implementasi algoritmanya dalam OpenGL akan dibagi dalam dua bagian yaitu sebelum proses dan proses setiap saat.

  Sebelum proses dilakukan hal yang perlu diperhatikan adalah

  1 membuat lightning pada OpenGL tidak aktif, hal ini berguna agar obyek terlihat normal seperti kartun pada umumnya. glDisable (GL_LIGHTING);

  2 Membuat efek blend atau efek pencampuran vertex tidak efek. Hal ini berguna agar obyek tidak terlihat bercampur dengan yang lain. glDisable (GL_BLEND);

  3 Pembuatan tabel teksture 1-Dimensi berisi warna RGB yang digunakan sebagai indek untuk pewarnaan vertex. Warna tersebut adalah tabel yang sama pada gambar 3.2. float shaderData[2][3];

  Tabel teksture tersebut diisikan nilai 1.0 dan 0.0 atau lebih baik warna hitam diganti dengan warna yang lebih halus semisal bernilai 0.2.

  Untuk mendukung proses rendering, hal yang perlu ditambahkan adalah fungsi-fungsi untuk perhitungan normalisasi, dan perkalian untuk rumus n.L dimana jika hasil akhirnya bernilai negatif akan diubah nilainya menjadi nol. Semua proses persiapan rendering selain fungsi ditulis pada fungsi initGL.

  

Cell shading menggunakan pewarnaan vertek yang berasal dari tabel warna

  1-Dimensi. Untuk menggunakannya diperlukan perintah untuk inisialisasi yaitu glGenTextures(1, &shaderTexture[0]); glBindTexture(GL_TEXTURE_1D, shaderTexture[0]);

  Selain itu, diperlukan perintah untuk mengecek dan memfilter apakah nanti teksture yang dibuat terlalu besar atau kecil. glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTE

  R,GL_NEAREST); glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER ,GL_NEAREST); Hal selanjutnya adalah penentuan jenis teksture yang akan dipakai dengan mengisikan tipe teksture yaitu GL_TEXTURE_!D, dimensi, tipe warna yaitu GL_RGB, tipe teksture yaitu GL_UNSIGNED_BYTE dan struktur data yang dipakai oleh teksture. Parameter terakhir berupa array dengan tipe data GLUbyte. glTexImage1D (GL_TEXTURE_1D, 0, GL_RGB, 2, 0, GL_RGB ,

  GL_FLOAT, shaderData); Setelah persiapan diatas selesai, sekarang membahas tentang renderingnya.

  Proses rendering ini dilakukan oleh program dengan memanggil fungsi GLDrawScene berulang-ulang maka semua perintah dibawah ini ditulis difungsi tersebut. Langkah pertama adalah mengaktifkan teksture 1- glEnable (GL_TEXTURE_1D);. Langkah berikutnya adalah mengikat teksture dengan identitas teksture yaitu shaderTexture[] yang berguna untuk penyimpanan teksture . glBindTexture (GL_TEXTURE_1D, shaderTexture[0]);

  Proses rendering dilanjutkan dengan menampilkan vertek-vertek ke layar komputer. Sebelum ditampilkan normal-normal dari setiap titik dihitung terlebih dahulu sesuai dengan perputaran obyek dan kemudian dilakukan normalisasi.

  Proses pewarnaan dimulai dari perkalian antara normal hasil normalisasi dengan cahaya yang kita punya atau dengan kata lain adalah sudut pandang mata. Hasil perkalian itu akan dimasukkan ke dalam identitas teksure dan jika nilai perkalian kurang dari nol maka nilai identitas teksture tersebut adalah nol. Dengan kata lain jika hasil perkalian bernilai nol maka tidak ada cahaya yang mengenainya maka warna diset nol atau sesuai warna dasarnya dan nilai lain adalah warna dasar ditambahkan warna cahaya atau telah ditentukan bahwa warnanya adalah warna terang.

  Perkembangan lanjut cell shading adalah menentukan warnanya bukan hanya warna gelap dan terang saja yang dipakai tetapi dengan tiga kombinasi warna yaitu warna gelap, warna peralihan dan warna terang. Warna ini lebih realistik daripada menggunakan dua warna karena perbandingan tiga warna ini sedikit gelap dan terang atau yang terkena cahaya lebih dominan. Dengan pertambahan warna tersebut maka tabel warna perlu diubah menjadi float shaderData[32][3]; dan untuk memudahkan maka pengisian warnanya dilakukan dari luar program. Hal lain yang perlu diubah adalah perintah glTexImage1D dengan mengisi nilai 32 menggantikan nilai 2 sesuai dengan jumlah warna yang dimasukkan.

Gambar 4.7 adalah hasil dari cell shading dengan 2 tingkatan warna dan Gambar 4.8 adalah hasil cell shading dengan 3 tingkatan warna.Gambar 4.7 Hasil render cell shading 2 warnaGambar 4.8 Hasil render cell shading 3 warna

4.9 Garis Tepi

  Selain cell shading masih ada satu proses lagi yang diperlukan untuk memberikan efek kartun tradisional. Proses tersebut adalah pemberian garis tepi pada model. Proses pemberian garis tepi umumnya dilakukan dengan menggunakan teknik sillhoute. Teknik sillhoute menggunakan cara mengecek tiap vertex untuk mengetahui apakah vertex tersebut berada di tepi dari model atau tidak. Jika vertex berada di tepi maka vertex akan dirender didepan model. Selain teknik sillhoute masih ada cara lain untuk memberikan efek garis tepi yaitu dengan menambahkan hasil render cell shading dengan hasil render bentuk kawat polygon. Efek ini berhasil jika render kawat polygon yang menghadap depan tidak ditampilkan dan garis kawat polygon tersebut lebih besar dari besarnya garis pada cell shading.

  Cara menambahkan render polygon adalah dengan memberitahu OpenGL bahwa model blender atau pencampuran boleh dilakukan yaitu dengan mengetik glEnable (GL_BLEND);. Penggunaan render dengan bentuk kawat polygon dilakukan setelah proses

  

cell shading selesai dilakukan yaitu dengan mengetik glPolygonMode

(GL_BACK, GL_LINE);.

  Kemudian perintah untuk membuat OpenGL tidak merender kawat polygon yang menghadap ke depan adalah glCullFace (GL_FRONT);.

  Perintah untuk menentukan besarnya garis kawat polygon adalah

  

glLineWidth (2.0f); dengan pengisian angka yang lebih besar dari 1 atau

lebih daripada saat memproses cell shading.

  Setelah melakukan render kawat polygon kembalikan keadaan seperti semula agar proses cell shading selanjutnya dapat dilakukan.

  Gbr 4.9 Hasil render kawat polygon

  Gbr 4.10 Hasil cell shading ditambah garis tepi

4.10 Pemberian warna

  Pemberian warna pada model ini dilakukan pada tiap polygon atau tiap

  vertex dengan perintah glColorf (R,G,B); di mana R adalah tingkatan warna merah, G adalah tingkatan warna hijau dan B adalah tingkatan warna biru.

  Pemberian warna dilakukan secara sama dan keseluruhan pada semua

  vertex model atau bidang tertentu agar didapatkan warna penuh. Setelah

  model terdapat warna maka hasil pencahayaan dari cell shading akan memberikan efek bayangan dengan garis tegas dan juga warna masih penuh.

  Gbr 4.11 Hasil akhir rendering

BAB V ANALISA HASIL

5 ANALISA HASIL

  Hasil yang ingin didapatkan adalah hasil rendering model 3-Dimensi yang terlihat seperti gambar 2-Dimensi yang memenuhi kriteria dalam bab 3.2 atau seperti yang ada dalam gambar 5.1 berikut ini.

Gambar 5.1 Hasil yang ingin diperoleh

  Hasil yang diperbandingkan adalah hasil percobaan terakhir yaitu hasil percobaan cell shading 3 tingkatan warna pada bab 4.9. Pada pengamatan mata terlihat bahwa gambar yang diperoleh sedikit berbeda dengan yang diinginkan. Perbedaan terjadi pada bayangan yang terdapat pada hasil akhir seperti pada gambar 5.3. Sedangkan gambar 5.2 adalah gambar dari model asal yang dirender secara realistis

Gambar 5.2 Hasil render realistik atau hasil awalGambar 5.3 Hasil render cell shading atau hasil akhir

BAB VI KESIMPULAN

6. KESIMPULAN

  Kesimpulan yang didapat adalah API OpenGL dapat membuat cell shading dengan baik.

  Langkah selanjutnya adalah membuat aplikasi cell shading yang memanfaatkan GPU untuk menghitung perhitungan vertex. Hal tersebut karena pada saat ini proses cell shading tidak lagi dibuat menggunakan proses perhitungan dari perangkat lunak, melainkan perhitungan vertex oleh GPU.

DAFTAR PUSTAKA

  1. Moller, Tomas and Haines, Eric 1999 Real Time Rendering, A K Press, Natick Massachusetts.

  2. Sillicon Graphics, 1997, The Official Guide to Learning OpenGL, version 1.1, Addison Wesley Publishing.

  3. Seddon, Chris, 2005, OpenGL Game Development, WordWare Publishing inc, Texas.

  4. Wright, Richard Jr and Sweet, Michael, 1996 Open GL Super Bible, Macmillan Computer Publishing.

  5. Suyoto, 2003, Teori dan Pemrograman Grafika Komputer dengan Visual C++ V.6 dan OpenGL, Gaya Media, Yogyakarta.

  6. Graf, Christian, 2002, NPR shading of 3D modes in Cartoon like : A

  tutorial on how to create cartoon shaded figures from 3D models, University of Auckland.

  7.

  8.

Dokumen baru

Tags

Dokumen yang terkait

Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Pendidikan
0
0
17
Diajukan Untuk Memenuhi Salah Satu Syarat Dalam Memperoleh Gelar Sarjana Ekonomi Jurusan Manajemen
0
0
18
SKRIPSI Ditujukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
0
117
SKRIPSI Ditujukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
2
161
SKRIPSI Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
1
127
SKRIPSI Ditujukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
0
166
Tugas Akhir Diajukan untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
0
127
SKRIPSI Diajukan untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
0
98
SKRIPSI Diajukan untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Program Studi Teknik Informatika
0
0
113
SKRIPSI Diajukan untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Program Studi Teknik Informatika
0
1
76
TUGAS AKHIR Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Mesin
0
0
82
Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Mesin
0
0
119
Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana
0
1
97
Tugas Akhir Dikerjakan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
0
97
SKRIPSI Ditujukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik Jurusan Teknik Informatika
0
0
138
Show more