if13unikom2008.files.wordpress.com · Web viewGambar 3D (3 dimensi) seringkali kita dengar sewaktu kita masih kecil dulu, namun tidak sedikit orang yang tidak tahu bagaimana mengimplementasikan

PEMANDANGAN 3DMakalah Ini Dibuat untuk Memenuhi Tugas Besar Mata Kuliah Komputer Grafika

Dosen : Hendri Karisma, S. Kom.

Disusun Oleh :

Juni wer Alimang 10108636

Faisal Arda Muliana 10108637

Hendrik Pratama 10108639

Mohammad Husyein 10108647

Bian Robina 10108623

JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNIK DAN ILMU KOMPUTER

UNIVERSITAS KOMPUTER INDONESIA

BANDUNG

2012

Daftar Isi

Kata Pengantar..........................................................................................................................iAbstrak........................................................................................................................................iiDaftar Isi.....................................................................................................................................iiiBAB I Pendahuluan...................................................................................................................1

1.1 Latar belakang Masalah.......................................................................................................11.2 Maksud Dan Tujuan.............................................................................................................11.3 Tujuan Masalah...................................................................................................................21.4 Batasan Masalah.................................................................................................................2

BAB II Landasan Teori.............................................................................................................32.1 Pengertian Grafika...............................................................................................................32.2 Elemen Dasar Grafika...........................................................................................................3

2.2.1 Point..........................................................................................................................42.2.2 Polyline......................................................................................................................42.2.3 Polygon......................................................................................................................42.2.4 Filled Polygon (Face)...................................................................................................42.2.5 Gradate Polygon.........................................................................................................4

2.3 Grafika Komputer 2D...........................................................................................................42.4 Grafifka Komputer 3D..........................................................................................................52.5 Perbedaan Grafika Komputer 2D Dengan 3D........................................................................52.6 Transformasi........................................................................................................................52.7 Color (warna).......................................................................................................................82.8 Lighting (Pencahayaan)........................................................................................................92.9 Blending (Pencampuran)......................................................................................................102.10 Texture Mapping................................................................................................................11

2.10.1 Menentukan Texture Image......................................................................................112.10.2 Mendefinisikan Gambar sebagai Sebuah Texture......................................................122.10.3 Mengubah Gambar Texture......................................................................................122.10.4 Mapping Texture.......................................................................................................12

2.11 Fog.....................................................................................................................................132.12 Pengertian OpenGL............................................................................................................132.13 Sejarah OpenGL..................................................................................................................13

BAB III Implementasi Program...............................................................................................18BAB IV Kesimpulan Dan Saran...............................................................................................70

KATA PENGANTAR

Sebelumnya kami mengucapkan puji dan syukur kehadirat TUHAN YANG MAHA ESA yang telah

melimpahkan rahmat dan karunianya kepada kami, sehingga kami dapat menyelesaikan Tugas

Grafika Komputer ini tepat pada waktunya.

Terdorong oleh rasa ingin tahu, kemauan, kerja sama dan kerja keras, kami kerahkan seluruh

upaya demi mewujudkan ke ingin-tahuan dan tugas dari dosen pembimbing untuk

menyelesaikan tugas ini.

Semoga tulisan ini dapat memenuhi kewajiban kami dalam tugas perkuliahan Grafika

Komputer.

Adapun harapan kami, semoga tulisan ini dapat menambah wawasan pembaca mengenai

Grafika Komputer dan penerjemah bahasa pencitraan OpenGL, dengan maksud nantinya

pembaca mampu untuk memahami apa itu Grafika Komputer, OpenGL, dan lain sebagainya

yang menyangkut objek 3 dimensi (3D).

Kami menyadari bahwa tulisan ini masih jauh dari sempurna, untuk itu kami mengharapkan

kritik dan saran yang membangun dari pembaca demi kesempurnaan tulisan ini.

Bandung, 27 Juni 2012

Hormat Kami,

Tim Penulis

Abstrak

Gambar 3D (3 dimensi) seringkali kita dengar sewaktu kita masih kecil dulu, namun tidak sedikit

orang yang tidak tahu bagaimana mengimplementasikan suatu objek menjadi sesuatu yang

terlihat nyata dan megah. Seiring berjalannya waktu, dampak perkembangan teknologi sangat

terasa bagi kita bagaimana mudahnya membuat sesuatu yang kita bayangkan menjadi nyata

dalam hal ini yang dimaksud yaitu membuat suatu objek 3D.

Begitu banyak teknologi/perangkat lunak untuk mengimplementasikan apa yang kita

bayangkan menjadi sesuatu yang dapat kita ciptakan kedalam bentuk 3 dimensi (3D),

diantaranya yaitu OpenGL. OpenGL (Open Graphics Library) adalah suatu library grafis yang

digunakan untuk keperluan-keperluan pemrograman grafis. Spesifikasi standar yang dimiliki

oleh library ini mendefinisikan sebuah cross-bahasa, cross-platform API untuk menulis aplikasi

komputer dalam bentuk 2D dan 3D grafis. OpenGL bersifat open source, dapat dipakai pada

banyak platform (Windows ataupun Linux) dan dapat digunakan pada berbagai jenis compiler

bahasa pemrograman seperti C++, Delphi, Java ataupun VB.

Disini kami menggunakan Visual c++ 2010 dan OpenGL sebagai sarana untuk

mengimplementasikan animasi yang kami bangun yaitu “Pemandangan 3D”. Dimana terdapat

Objek-objek yang berupa :

1. Pegunungan.

2. Pohon. Dan,

3. Air yang menggenangi kaki gunung dan mengelilingi pegunungan tersebut.

BAB I

Pendahuluan1.1 Latar Belakang Masalah

Semakin berkembangnya ilmu pengetahuan dan teknologi grafis pada masa sekarang ini,

maka pengetahuan mengenai grafik komputer semakin banyak dipakai. Namun sebelum kita

membahas lebih jauh mengenai grafik komputer, kita akan mengetahui dahulu definisi

sebenarnya tentang apa itu grafik komputer.

Secara umum grafik komputer adalah gambar yang dihasilkan oleh komputer, yang

hasilnya sudah sering kita lihat seperti di majalah dan televisi. Disini dibahas bahwa tiap karakter

yang dihasilkan diambil dari library dari bentuk karakter yang ada pada memori komputer.

Gambar-gambar yang berada pada majalah atau televisi tersebut ada beberapa yang terlihat

sangat natural, sehingga kita para pembaca akan sulit membedakan mereka buatan atau hasil dari

fotografi asli.

Selain itu grafik komputer juga digunakan untuk membuat design dari background

ataupun objek-objek dalam game di komputer. Gambar-gambar yang ada pada game itu adalah

gabungan antara kenyataan dan imajinasi dari programmer-nya. Dalam bidang lain, grafik

komputer digunakan dalam dunia seni, entertainment, dan publikasi. Khususnya dipakai dalam

produksi film, animasi, dan spesial efek. Animasi dibuat dengan membuat sebuah gambar yang

berkelanjutan di film atau videotape. Gambar satu dan yang selanjutnya hanya mempunyai

perbedaan yang tipis ( slightly different ). Bidang-bidang lain yang menggunakan grafika

komputer adalah untuk browsing di World Wide Web, untuk pengawasan proses, dan banyak

lagi.

Dari penjelasan diatas penulis mencoba untuk membuat animasi yang berupa objek 3D, adapun

animasi yang akan dibangun yaitu Pemandangan 3D. Objek-objek yang akan dibangun yaitu :

1. Pegunungan2. Pohon3. Air yang menggenangi kaki gunung dan mengelilingi pegunungan tersebut.

1.2 Maksud dan Tujuan

Maksud

Maksud dari penulisan ini adalah untuk membuat animasi pemandangan 3D dengan

menggunakan OpenGL.

1.3 Tujuan

Adapun tujuan yang akan dicapai dari penulisan laporan ini adalah sebagai berikut :

1. Menampilkan simulasi keadaan pemandangan dari segala sisi.

2. Mengetahui fungsi-fungsi pada openGL.

1.4 Batasan Masalah

Adapun batasan masalah dalam pembuatan animasi 3D ini adalah sebagai berikut :

1. Bahasa yang digunakan bahasa pemrograman C++

2. IDE yang digunakan Visual C++ dengan openGL

3. Program ini hanya menampilkan objek pemandangan 3Di.

BAB II

LANDASAN TEORI

2.1 Pengertian Grafika Komputer

Grafika komputer (Computer graphics) adalah bagian dari ilmu komputer yang berkaitan

dengan pembuatan dan manipulasi gambar 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

komputer sering dikenal juga dengan istilah visualisasi data.

Bagian dari grafika komputer meliputi:

1. Geometri: mempelajari cara menggambarkan permukaan bidang

2. Animasi: mempelajari cara menggambarkan dan memanipulasi gerakan

3. Rendering: mempelajari algoritma untuk menampilkan efek cahaya

4. Citra (Imaging): mempelajari cara pengambilan dan penyuntingan gambar.

Teknik-teknik yang dipelajari dalam grafika komputer adalah teknik-teknik bagaimana

membuat atau menciptakan gambar menggunakan komputer. Ada perbedaan yang sangat

mendasar antara foto dan gambar, yaitu pada foto semua detail obyek terlihat sedangkan pada

gambar (baik itu gambar manusia atau gambar komputer) tidak dapat memperlihatkan semua

detail yang ada tetapi hanya detail-detail yang dianggap penting dalam menunjukkan pola suatu

gambar.

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

2.2.1. PointPoint adalah sebuah titik yang digunakan untuk membangun obyek. Setiap titik dalam

obyek 3 dimensi memiliki nilai dalam x, y dan z.

2.2.2. Polyline Polyline adalah sebuah fungsi yang dibentuk dari beberapa garis yang saling

berhubungan dan membentuk sebuh kurva yang terbuka.

2.2.3 Polygon Polygon adalah suatu fungsi yang mirip dengan polyline hanya saja hasilnya adalah

kurva tertutup, sedangkan polyline hasilnya kurva terbuka.

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

2.2.5. Gradate Polygon Gradate polygon adalah sebuah polygon yang bagian dalamnya memiliki warna – warna

yang bergradasi dari satu warna ke warna yang lainnya.

2.3 Grafik Komputer 2D

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.4 Grafik komputer 3D

Grafik komputer 3D merupakan representasi dari data geometrik 3 dimensi sebagai hasil

dari pemrosesan dan pemberian efek cahaya terhadap grafik komputer 2D. hasilnya dapat

ditampilkan secara real time untuk keperluan simulasi. Prinsip yang dipakai mirip dengan grafik

komputer 2D dalam penggunaan algoritma, grafika vektor, model frame kawat (wire frame

model), dan grafik rasternya.

Grafik komputer 3D sering disebut sebagai model 3D. Namun, model 3D ini lebih

menekankan pada representasi matematis untuk objek 3 dimensi. Obyek pada grafik 3D adalah

sekumpulan titik-titik 3D (x,y,z) yang membentuk suatu face (bidang) yang digabungkan

menjadi satu kesatuan. Face sendiri adalah gabungan titik-titik yang membentuk bidang tertentu.

Data matematis ini belum bisa dikatakan sebagai gambar grafis hingga saat ditampilkan secara

visual pada layar komputer atau printer. Proses penampilan suatu model matematis ke bentuk

citra 2 D biasanya dikenal dengan proses 3D rendering.

2.5 Perbedaan Grafik 2D dan 3D

Perbedaan yang paling mendasar dan terlihat dengan sangat jelas adalah tampilan gambarnya.

Gambar 2D tampil flat adn frame tampilannya cenderung terbatas karena objek gambarnya

disajikan hanya dengan sumbu x dan y. Sedangkan pada grafik 3D, gambar yang ditampilkan

lebih hidup, membentuk ruang, tidak flat, serta framenya lebih luas yang dikarenakan gambar 3D

disajikan dengan 3 sumbu, yaitu x, y, dan z.

2.6 Transformasi

Transformasi dasar pada objek dua dimensi yang pertama adalah translasi (translation).

Translasi berarti memindahkan suatu objek sepanjang garis lurus dari suatu lokasi koordinat

tertentu ke lokasi yang lain. Transformasi skala (scaling) digunakan untuk mengubah ukuran

suatu objek, sedangkan rotasi (rotation) adalah pemindahan objek menurut garis melingkar.

Jenis jenis dari transformasi dasar:

1. Translasi

Translasi dilakukan dengan penambahan translasi pada suatu titik koordinat dengan

translasi vektor atau shift vektor, yaitu (tx,ty), dimana tx adalah translation vektor menurut

sumbu x, sedangkan ty adalah translation vektor menurut sumbu y. koordinat baru titik

yang ditranslasi dapat diperoleh dengan

X’= x + tx

Y’= y + ty

Dimana (x,y) adalah koordinat asal suatu objek dan (x’ , y’) adalah koordinat baru objek

tersebut setelah ditranslasi.

Kadang-kadang transformasi dinyatakan dalam bentuk matriks, sehingga matriks

tranformasi untuk translasi dapat dinyatakan sebagai berikut :

Dengan demikian translasi dua dimensi dapat ditulis dalam bentuk matriks :

P’ = P + T

Disamping dinyatakan dalam vektor kolom, matriks transformasi dapat dituliskan dalam

bentuk vektor baris, sehingga menjadi P = [ x y ] dan T = [ tx ty ]. Bentuk vektor kolom

adalah standar dari symbol matematik, yang juga berlaku bagi notasi grafik seperti GKS

dan PHIGS.

2. Skala

Transformasi skala adalah perubahan ukuran suatu objek. Koordinat baru dapat

diperoleh dengan melakukan perkalian nilai koordinat dengan scaling factor, yaitu (sx ,

sy) ,dimana sx adalah scaling factor menurut sumbu x, sedangkan sy adalah scaling factor

menurut sumbu y. koordinat baru titik yang diskala dapat diperoleh dengan

X’ = x + sx

Y’ = y + sy

Dimana (x , y) adalah koordinat asal suatu objek dan (x’,y’) adalah koordinat setelah

diskala. Matriks transformasi untuk skala dapat dinyatakan sebagai berikut:

Dengan demikian skala dapat juga dituliskan

P’ = S . P

Scaling factor sx dan sy dapat diberikan sembarang nilai positif. Nilai lebih dari 1

menyebabkan objek diperbesar, sebaliknya bila nilai lebih kecil dari 1, maka objek akan

diperkecil. Bila sx dan sy mempunyai nilai yang sama, maka skala disebut uniform

scaling. Nilai yang tidak sama dari sx dan sy menghasilkan differential scaling, yang

biasa digunakan pada program aplikasi.

3. Rotasi

Rotasi dua dimensi pada suatu objek kan memindahkan objek tersebut menurut garis

melingkar. Pada bidang xy. Untuk melakukan rotasi diperlukan sudut rotasi θ dan pivot

point (xp’ yp ) atau rotasi point dimana objek di rotasi, seperti pada gambar 5-3 nilai

positif dari sudut rotasi menentukan arah rotasi berlawanan dengan jarum jam, dan

sebaliknya nilai negative akan memutar objek searah jarum jam.

Rotasi dapat dilakukan dengan pivot point yaitu titik pusat koordinat, seperti pada

gambar 5-4. Pada betuk ini, r adalah jarak konstan dari titik pusat, sudut φ adalah sudut

posisi suatu titik dengan sumbu horizontal, sedangkan θ adalah sudut rotasi.

Menggunakan trigonometri, transformasi dapat dinyatakan dengan sudut θ dan φ

sebagai berikut:

X’= r cos (φ + θ) = r cos φ cos θ – r sin φ sin θ

y’ = r sin (φ + θ) = r cos φ sin θ + r sin φ cos θ

sedangkan dengan koordinat polar diketahui bahwa

x = r cos φ, y = r sin φ

dengan melakukan substitusi, diperoleh rumus transformasi untuk rotasi suatu titik (x,

y) dengan sudut rotasi θ sebagai berikut:

x’ = x cos θ – y sin θ

y’ = x sin θ – y cos θ

matriks transformasi untuk rotasi dapat dinyatakan sebagai berikut:

P’ = R . P

Rotasi dapat dinyatakan dalam bentuk lain, yaitu matriks. Matriks rotasi dapat

dituliskan dengan

Rotasi suatu titik terhadap pivot point (xp’ yp ) seperti pada gambar 5-5, menggunakan

bentuk trigonometri, secara umum dapat dituliskan sebagai berikut:

X’ = xp +(x - xp) cos θ – (y - yp) sin θ

Y’ = yp + (x – xp) sin θ + (y – yp) cos θ

2.7 Color (Warna)

Bentuk gelombang elektromagnetik yang terkandung dalam cahaya yang berasal dari

sumber cahaya. Spectrum warna memiliki panjang gelombang elektomagnetik antara 350-750

nanometer .

Pembagian Warna

RGB (Red-Green-Blue) : warna dasar yang dijadikan patokan warna secara universal

(primary colors)

CMYK (Cyan-Magenta-Yellow-Black) : Sistem representasi pada warna tinta yang

diterapkan dalam dunia fotografi dan produksi grafika

Sistem Warna Lingkaran (the color wheel) : Digunakan untuk mengkombinasikan dan

mengharmonikan warna pada karya seni dan design

Gambar 1 Pembagian warna

Warna dapat didefinisikan secara obyektif/fisik sebagai sifat cahaya yang dipancarkan,

atau secara subyektif/psikologis sebagai bagian dari pengalaman indera pengelihatan. Secara

obyektif atau fisik, warna dapat diberikan oleh panajang gelombang. Dilihat dari panjang

gelombang, cahaya yang tampak oleh mata merupakan salah satu bentuk pancaran energi yang

merupakan bagian yang sempit dari gelombang elektromagnetik.

Dari sekian banyak warna, dapat dibagi dalam beberapa bagian yang sering dinamakan

dengan sistem warna Prang System yang ditemukan oleh Louis Prang pada 1876 meliputi :

1. Hue, adalah istilah yang digunakan untuk menunjukkan nama dari suatu warna, seperti

merah, biru, hijau dsb.

2. Value, adalah dimensi kedua atau mengenai terang gelapnya warna. Contohnya adalah

tingkatan warna dari putih hingga hitam.

3. Intensity, seringkali disebut dengan chroma, adalah dimensi yang berhubungan dengan

cerah atau suramnya warna.

2.8 Lighting (pencahayaan)

Lighting merupakan proses menghitung intensitas cahaya terutama pada 3-Dimensi point,

biasanya diatas suatu permukaan.

Beberapa cara mengatasi masalah pencahayaan, antara lain :

• Mengerti persepsi dari cahaya (warna)

• Membuat sebuah solusi untuk merepresentasikan dan menghasilkan warna menggunakan

komputer.

• Mengerti akan pengaruh cahaya dan objek

` Bayangan

Bayangan akan muncul saat cahaya jatuh menyinari suatu objek.

Pada dunia maya, layaknya cahaya, terdapat beberapa jenis bayangan yang dapat

dihasilkan oleh komputer.

Bayangan bekerja sama dengan cahaya untuk memberi kesan natural atau realistic pada

scene yang ada. Bayangan dapat membantu mendefinisikan posisi objek-objek, apakah

berada di lantai atau melayang di udara. Bayangan yang dihasilkan bisa tajam dan solid

namun bisa juga lembut dan buram (blurry). Keberadaan bayangan atau ketiadaannya

dapat digunakan untuk memberi keseimbangan dan kontras pada objek-objek di dalam

scene.

2.9 Blending (Pencampuran)

Pencampuran merupakan fungsi yang menggabungkan nilai warna dari sumber dan

tujuan. Operasi campuran yaitu cara yang paling alami untuk mengetahui bahwa komponen RGB

adalah suatu fragmen yang mewakili warna dan komponen alfa adalah suatu fragmen yang

mewakili sifat tidak tembus cahaya.

Faktor sumber dan tujuan

Pada proses pencampuran, nilai cairan warna yang masuk fragmen (sumber) digabungkan

dengan warna yang sesuai dengan nilai saat ini yang disimpan pada piksel (tujuan) dalam dua

tahap proses. Yang pertama menghitung faktor sumber dan tujuan, factor-faktor tersebut adalah

RGBA quadruplets yang masing-masing dikalian dengan komponen-komponen R, G, B dan

nilai-nilai dari sumber dan tujuan. Kemudian komponen yang sesuai dalam dua set RGBA

quadruplets. Secara sistematis, faktor sumber dan tujuan pencampuran (SR, Sg, Sb, Sa) dan (Dr,

Dg, dB, Da) dan nilai RGBA ditandai dengan s atau d dan terakhir nilai RGBA dicampurkan

yang diperoleh dengan (RsSr + RdDr, GsSg + GdDg, BsSb + BdDb, AsSa + Adda) dimana

setiap komponen adalah quadruplets is eventually clamped to [0,1].

Dengan menggunakan glBlendFunc () untuk persediaan pada dua hal utama, yang

pertama menentukan bagaimana faktor sumber dan tujuan harus dihitung dan yang kedua

menunjukan bagaimana faktor sumber dan tujuan dihitung. Dan untuk proses pencampurannya

harus ada faktor pengaktifannya menggunakan : glEnable (GL_BLEND). Menggunakan

glDisable () dengan GL_BLEND untuk menonaktifkan Pencampuran dan menggunakan konstan

GL_ONE (sumber) dan GL_ZERO (tujuan) memberikan hasil yang sama seperti ketika

Pencampuran dinonaktifkan. Nilai-nilai ini bersifat default dengan void glBlendFunc (GLenum

sfactor, GLenum dfactor).

Mengontrol bagaimana nilai warna dalam fragmen yang diproses digabungkan dengan

yang sudah disimpan dalam framebuffer (tujuan). Pendapat sfactor menunjukkan bagaimana

untuk menghitung faktor sumber Pencampuran dan dfactor menunjukkan bagaimana untuk

menghitung faktor tujuan Pencampuran. Campuran faktor yang diasumsikan terletak pada

rentang [0,1]; setelah nilai warna dalam sumber dan tujuan digabungkan, setelah dihitung kisaran

[0,1].

2.10 Texture Mapping

Texture mapping merupakan teknik pemetaan sebuah tekstur pada pola gambar

wireframe, dimana wireframe yang telah dibuat akan ditampilkan memiliki kulit luar seperti

tekstur yang diinginkan. Dalam pemberian tekstur, perlu diperhatikan dasarnya seperti:

1. Menentukan tekstur

1) Membaca atau membangkitkan tekstur

2) Menandai tekstur

3) Mengenablekan tekstur

2. Menandai koordinat tekstur pada vertek

3. Menentukan parameter tekstur

1) Wrapping , filtering, dsb.

Langkah-langkah dalam memulai mapping sebuah tekstur yakni dengan spesifikasi

dibawah ini :

2.10.1 Menentukan Tekstur Image :

1. Mendefinisikan tekstur image dari sebuah array teksel (element tekstur ) ke dalam

memory cpu : Glubyte my_texels[512][512];

2. Mendefinisikan seperti semua peta piksel yang lain

1) Gambar yang didefinisikan (baik secara manual maupun dengn suatu fungsi

matematik tertentu).

2) Membangkitkan dengan kode aplikasi

3. Mengenablekan tekstur mapping

1) glEnable(GL_TEXTURE_2D)

2) OpenGL mendukung 1 sampai 4 dimensional tekstur mapping

2.10.2. Mendefinisikan gambar sebagai sebuah teksture glTexImage2D(target,level,components,w,h,border,format,type, texels );

Keterangan :

1. target: tipe dari teksture, e.g. GL_TEXTURE_2D

2. level: digunakan untuk mipmapping

3. components: element per texel

4. w, h: lebar dan tinggi dari texels pada pixels

5. border: digunakan untuk smoothing

6. format and type: menjelaskan texels

7. texels: pointer ke array texel

8. glTexImage2D(GL_TEXTURE_2D, 0, 3, 512, 512, 0,GL_RGB,

GL_UNSIGNED_BYTE, my_texels);

2.10.3. Mengubah gambar tekstur :1. OpenGL meminta dimensi tekstur untuk menjadi dasar dari 2

2. Jika dimensi dari image bukan power ke 2, gluScaleImage

(format,w_in,h_in,type_in,*data_in,w_out,h_out,type_out,*data_out);

3. data_in adalah gambar inputan.

4. data_out adalah gambar hasil

2.10.4. Mapping Tekstur :1. Didasarkan pada koordinat tekstur parametric

2. glTexCoord*() ditetapkan pada masing – masing vertex

2.11 Fog

Fog adalah suatu istilah umum yang menggambarkan bentuk yang sama dari pengaruh

atmosfer, yang digunakan untuk menirukan kabut, kabut tipis, asap, atau polusi. fog sangat

penting di dalam aplikasi-aplikasi simulasi yang visual, yang dibatasi oleh jarak penglihatan

untuk itu perlu lebih mendekati objek. Juga sering disatukan ke dalam tampilan simulator

penerbangan.

Ketika fog memungkinkan, sudut pandang objek bersifat lebih jauh untuk memudarkan

warna fog. Anda dapat mengendalikan kepadatan fog, yang mana menentukan tingkat objek

memudar dengan jarak meningkat, seperti juga warna fog. Fog terdapat di dalam kedua gaya

yaitu gaya RGBA dan indeks warna, meski perhitungannya sedikit berbeda di kedua gaya

2.12 Pengertian OpenGl

OpenGL(Open Graphic Library) adalah sebuah library terdiri dari berbagai macam fungsi

dan biasanya digunakan untuk menggambar sebuah objek 2D ata 3D.

Selain OpenGL ada juga Graphic Library lainnya, yaitu directX (microsoft) memiliki

fungsi yang hampir sama, namun DirectX lebih banyak digunakan oleh sebagian besar game

developer karena beberapa fungsi DirectX nampaknya lebih memudahkan game developer untuk

membuat game.

OpenGL biasanya digunakan dengan bahasa pemrograman C/C++, tapi bisa juga

menggunakan java. OpenGL merupakan sebuah library untuk pemrograman grafik (Graphics

Programming / GP). Dasar untuk mempelajari GP adalah terletak pada fungsi matematikanya,

terutama operasi matriks. Pada GP yang perlu dipelajari adalah mengenai shading, shape,

transform (rotate, translation, scala).

2.13 Sejarah OpenGL

Tahun 1980-an, mengembangkan perangkat lunak yang dapat berfungsi dengan berbagai

hardware grafis adalah tantangan nyata. Pengembang perangkat lunak antarmuka dan kebiasaan

menulis driver untuk setiap perangkat keras. Ini mahal dan mengakibatkan banyak duplikasi

usaha.

Pada awal 1990-an, Silicon Graphics (SGI) adalah seorang pemimpin dalam grafis 3D

untuk workstation. Mereka IRIS GL API dianggap keadaan seni dan menjadi standar industri de

facto, membayangi terbuka berbasis standar PHIGS. Ini karena GL IRIS dianggap lebih mudah

digunakan, dan karena itu mendukung modus langsung rendering. By contrast, Sebaliknya,

PHIGS dianggap sulit untuk digunakan dan ketinggalan zaman dalam hal fungsionalitas.

SGI's pesaing (termasuk Sun Microsystems, Hewlett-Packard dan IBM) juga dapat

membawa ke pasar 3D hardware, didukung oleh ekstensi yang dibuat pada PHIGS standar. Hal

ini pada gilirannya menyebabkan pangsa pasar SGI untuk melemahkan karena lebih banyak

hardware grafis 3D pemasok memasuki pasar. Dalam upaya untuk mempengaruhi pasar, SGI

memutuskan untuk mengubah IrisGL API menjadi standar terbuka.

SGI menganggap bahwa IrisGL API itu sendiri tidak cocok untuk membuka karena

masalah lisensi dan paten. Juga, IrisGL memiliki fungsi-fungsi API yang tidak relevan dengan

grafis 3D. Sebagai contoh, termasuk windowing, keyboard dan mouse API, sebagian karena

dikembangkan sebelum Sistem X Window dan Sun's NEWS sistem dikembangkan.

Selain itu, SGI memiliki sejumlah besar pelanggan perangkat lunak; dengan mengubah

ke OpenGL API mereka berencana untuk mempertahankan pelanggan mereka terkunci ke SGI

(dan IBM) hardware untuk beberapa tahun sementara pasar dukungan untuk OpenGL matang.

Sementara itu, SGI akan terus berusaha untuk mempertahankan pelanggan mereka terikat pada

hardware SGI dengan mengembangkan maju dan kepemilikan Iris Inventor dan Iris Performer

pemrograman API. Akibatnya, SGI merilis standar OpenGL.

Akses standar yang OpenGL hardware, dan mendorong tanggung jawab pengembangan

program antarmuka perangkat keras, kadang-kadang disebut device driver, hardware produsen

dan windowing didelegasikan fungsinya kepada sistem operasi. Dengan begitu banyak jenis

perangkat keras grafis, membuat mereka semua berbicara dengan bahasa yang sama dengan cara

ini mempunyai dampak luar biasa dengan memberikan pengembang perangkat lunak tingkat

yang lebih tinggi 3D-platform untuk pengembangan perangkat lunak.

SGI memimpin pembentukan dewan peninjau arsitektur OpenGL (OpenGL ARB),

kelompok perusahaan yang akan memelihara dan memperluas spesifikasi OpenGL selama

bertahun-tahun yang akan datang. Salah satu batasan dari IrisGL adalah bahwa ia hanya

memberikan akses ke fitur yang didukung oleh hardware yang mendasarinya. Jika hardware

grafis tidak mendukung fitur, maka aplikasi tidak bisa menggunakannya. OpenGL mengatasi

masalah ini dengan menyediakan dukungan perangkat lunak untuk fitur yang tidak didukung

oleh hardware, memungkinkan aplikasi untuk menggunakan gambar pada lanjutan relatif rendah

sistem bertenaga.

Tahun 1994 SGI bermain-main dengan gagasan untuk melepaskan sesuatu yang disebut

"OpenGL + +" yang mencakup unsur-unsur seperti grafik adegan-API (mungkin berbasis di

sekitar mereka Performer teknologi). Spesifikasi itu beredar di kalangan beberapa pihak yang

berkepentingan - tetapi tidak pernah berubah menjadi sebuah produk pada tahun 1995, yang akan

menjadi pesaing utama dari OpenGL. Pada tanggal 17 Desember 1997 Microsoft dan SGI

memprakarsai Fahrenheit proyek, yang merupakan upaya bersama dengan tujuan

mempersatukan OpenGL dan Direct3D antarmuka (dan menambahkan adegan-API grafik juga).

Pada tahun 1998 Hewlett-Packard bergabung dengan proyek ini. Ini awalnya menunjukkan

beberapa janji untuk membawa dunia komputer grafis 3D interaktif API, melainkan karena

kendala keuangan di SGI, alasan strategis di Microsoft, dan kurangnya dukungan industri , itu

ditinggalkan pada tahun 1999.

3. 1. Konfigurasi OpenGL pada Ms. Visual C++ 2010 Express

Setelah melakukan instalasi Ms. Visual C++ 2010 Express, maka langkah

berikutnya yaitu konfigurasi OpenGL yang dibutuhkan komputer agar bisa membuat

program grafis pada Ms. Visual C++ 2010 Express. File penting yang dibutuhkan untuk

instalasi OpenGL adalah sebagai berikut:

1. glut.h

2. glut32.lib

3. glut32.dll

Berikut langkah-langkah konfigurasi OpenGL pada Ms.Visual C++ 2010 Express:

1. Ektrak file glut-3.7.6 ini adalah komponen opengl sendiri

2. Copylah atau tambahkan file glut32.dll pada directory C:\WINDOWS\system.

Seperti gambar berikut:

3. Copylah atau tambahkan file header glut.h pada directory C:\Program Files\

Microsoft Visual Studio 10.0/VC\Include. Seperti gambar berikut:

4. Copylah atau tambahkan file library glut32.lib pada directory C:\Program Files\

Microsoft Visual Studio 10.0\VC\Lib. Seperti gambar berikut:

5. Selesailah konfigurasi OpenGL, dan anda sudah siap membuat program grafis pada

Ms.Visual C++ 2010 Express.

BAB III

IMPLEMENTASI PROGRAM

Sourcecode Program OpenGL

#define WIN32_LEAN_AND_MEAN

#define WIN32_EXTRA_LEAN

#define GLX_GLXEXT_LEGACY

#ifdef _WIN32

#include <windows.h>

#include "glwindow.h"

#else

#include "glxwindow.h"

#endif

#include "projek.h"

#ifdef _WIN32

int WINAPI WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPSTR cmdLine,

int cmdShow)

{

#else

int main(int argc, char** argv)

{

#endif

//Mengatur Tampilan Window

const int windowWidth = 1024;

const int windowHeight = 768;

const int windowBPP = 16;

const int windowFullscreen = false;

#ifdef _WIN32

GLWindow programWindow(hInstance);

#else

SimpleGLXWindow programWindow;

#endif

//Contoh Kode OpenGL

Example example;

//Menyertakan Contoh Proyek ke window

programWindow.attachExample(&example);

if (!programWindow.create(windowWidth, windowHeight, windowBPP, windowFullscreen))

{

#ifdef _WIN32

MessageBox(NULL, "Unable to create the OpenGL Window", "An error occurred", MB_ICONERROR |

MB_OK);

#endif

programWindow.destroy();

return 1;

}

if (!example.init())

{

#ifdef _WIN32

MessageBox(NULL, "Could not initialize the application", "An error occurred", MB_ICONERROR |

MB_OK);

#endif


return 1;

}

while(programWindow.isRunning())

{

programWindow.processEvents(); //Proses Semua Aktifitas Window

float elapsedTime = programWindow.getElapsedSeconds();

example.prepare(elapsedTime);

example.render();

programWindow.swapBuffers();

}

example.shutdown();


return 0;

}

#include <ctime>

#include <iostream>


#include "glee/GLee.h"

#include "glwindow.h"

#include "projek.h"

GLWindow::GLWindow(HINSTANCE hInstance):

m_isRunning(false),

m_example(NULL),

m_hinstance(hInstance),

m_lastTime(0)

{

}

bool GLWindow::create(int width, int height, int bpp, bool fullscreen)

{

DWORD dwExStyle;

DWORD dwStyle;

m_isFullscreen = fullscreen;

m_windowRect.left = (long)0;

m_windowRect.right = (long)width;

m_windowRect.top = (long)0;

m_windowRect.bottom = (long)height;

// mengisi struktur class window

m_windowClass.cbSize = sizeof(WNDCLASSEX);

m_windowClass.style = CS_HREDRAW | CS_VREDRAW;

m_windowClass.lpfnWndProc = GLWindow::StaticWndProc;

m_windowClass.cbClsExtra = 0;

m_windowClass.cbWndExtra = 0;

m_windowClass.hInstance = m_hinstance;

m_windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

m_windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);

m_windowClass.hbrBackground = NULL;

m_windowClass.lpszMenuName = NULL;

m_windowClass.lpszClassName = "GLClass";

m_windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);

if (!RegisterClassEx(&m_windowClass))

{

return false;

}

if (m_isFullscreen)

{

DEVMODE dmScreenSettings;

memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));

dmScreenSettings.dmSize = sizeof(dmScreenSettings);

dmScreenSettings.dmPelsWidth = width;

dmScreenSettings.dmPelsHeight = height;

dmScreenSettings.dmBitsPerPel = bpp;

dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)

{

MessageBox(NULL, "Display mode failed", NULL, MB_OK);

m_isFullscreen = false;

}

}

if (m_isFullscreen)

{

dwExStyle = WS_EX_APPWINDOW;

dwStyle = WS_POPUP;

ShowCursor(false);

}

else

{

dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;

dwStyle = WS_OVERLAPPEDWINDOW;

}

AdjustWindowRectEx(&m_windowRect, dwStyle, false, dwExStyle);

m_hwnd = CreateWindowEx(NULL,

"GLClass",

"KELOMPOK 2 - GRAFIKA KOMPUTER",

dwStyle | WS_CLIPCHILDREN |

WS_CLIPSIBLINGS,

0, 0, // kordinat x,y

m_windowRect.right - m_windowRect.left,

m_windowRect.bottom - m_windowRect.top,

NULL,

NULL,

m_hinstance,

this);

if (!m_hwnd)

return 0;

m_hdc = GetDC(m_hwnd);

ShowWindow(m_hwnd, SW_SHOW);

UpdateWindow(m_hwnd);

m_lastTime = GetTickCount() / 1000.0f;

return true;

}

void GLWindow::destroy()

{

if (m_isFullscreen)

{

ChangeDisplaySettings(NULL, 0);

ShowCursor(true);

}

}

void GLWindow::attachExample(Example* example)

{

m_example = example;

}

bool GLWindow::isRunning()

{

return m_isRunning;

}

void GLWindow::processEvents()

{

MSG msg;

while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

}

void GLWindow::setupPixelFormat(void)

{

int pixelFormat;

PIXELFORMATDESCRIPTOR pfd =

{

sizeof(PIXELFORMATDESCRIPTOR), // size

1, // version

PFD_SUPPORT_OPENGL | // OpenGL window

PFD_DRAW_TO_WINDOW | // render to window

PFD_DOUBLEBUFFER, // support double-buffering

PFD_TYPE_RGBA, // color type

32, // prefered color depth

0, 0, 0, 0, 0, 0, // color bits (ignored)

0, // no alpha buffer

0, // alpha bits (ignored)

0, // no accumulation buffer

0, 0, 0, 0, // accum bits (ignored)

16, // depth buffer

0, // no stencil buffer

0, // no auxiliary buffers

PFD_MAIN_PLANE, // main layer

0, // reserved

0, 0, 0, // no layer, visible, damage masks

};

pixelFormat = ChoosePixelFormat(m_hdc, &pfd);

SetPixelFormat(m_hdc, pixelFormat, &pfd);

}

LRESULT GLWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

switch(uMsg)

{

case WM_CREATE:

{

m_hdc = GetDC(hWnd);

setupPixelFormat();

int attribs[] = {

WGL_CONTEXT_MAJOR_VERSION_ARB, 3,

WGL_CONTEXT_MINOR_VERSION_ARB, 0,

0};

HGLRC tmpContext = wglCreateContext(m_hdc);

wglMakeCurrent(m_hdc, tmpContext);

if (!GLEE_WGL_ARB_create_context)

{

std::cerr << "OpenGL 3.0 tidak mendukung, kembali ke GL 2.1" << std::endl;

m_hglrc = tmpContext;

}

else

{

m_hglrc = wglCreateContextAttribsARB(m_hdc, 0, attribs);

wglDeleteContext(tmpContext);

}

wglMakeCurrent(m_hdc, m_hglrc);

m_isRunning = true;

}

break;

case WM_DESTROY:

case WM_CLOSE:

wglMakeCurrent(m_hdc, NULL);

wglDeleteContext(m_hglrc);

m_isRunning = false;

PostQuitMessage(0);

return 0;

break;

case WM_SIZE:

{

int height = HIWORD(lParam);

int width = LOWORD(lParam);

getAttachedExample()->onResize(width, height);

}

break;

case WM_KEYDOWN:

if (wParam == VK_ESCAPE)

{

DestroyWindow(m_hwnd);

}

break;

default:

break;

}

return DefWindowProc(hWnd, uMsg, wParam, lParam);

}

LRESULT CALLBACK GLWindow::StaticWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM

lParam)

{

GLWindow* window = NULL;

if(uMsg == WM_CREATE)

{

window = (GLWindow*)((LPCREATESTRUCT)lParam)->lpCreateParams;

SetWindowLongPtr(hWnd, GWL_USERDATA, (LONG_PTR)window);

}

else

{

window = (GLWindow*)GetWindowLongPtr(hWnd, GWL_USERDATA);

if(!window)

{

return DefWindowProc(hWnd, uMsg, wParam, lParam);

}

}

return window->WndProc(hWnd, uMsg, wParam, lParam);

}

float GLWindow::getElapsedSeconds()

{

float currentTime = float(GetTickCount()) / 1000.0f;

float seconds = float(currentTime - m_lastTime);

m_lastTime = currentTime;

return seconds;

}

#ifndef _GLWINDOW_H

#define _GLWINDOW_H


#include <ctime>

class Example; //Declare our Example class

class GLWindow

{

public:

GLWindow(HINSTANCE hInstance); //default constructor

bool create(int width, int height, int bpp, bool fullscreen);

void destroy();

void processEvents();

void attachExample(Example* example);

bool isRunning(); //Is the window running?

void swapBuffers() { SwapBuffers(m_hdc); }

static LRESULT CALLBACK StaticWndProc(HWND wnd, UINT msg, WPARAM wParam, LPARAM

lParam);

LRESULT CALLBACK WndProc(HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam);

float getElapsedSeconds();

private:

Example* m_example; //A link to the example program

bool m_isRunning; //Is the window still running?

bool m_isFullscreen;

HWND m_hwnd; //Window handle

HGLRC m_hglrc; //Rendering context

HDC m_hdc; //Device context

RECT m_windowRect; //Window bounds

HINSTANCE m_hinstance; //Application instance

WNDCLASSEX m_windowClass;

void setupPixelFormat(void);

Example* getAttachedExample() { return m_example; }

float m_lastTime;

};

#endif

#ifndef GLSL_SHADER_H_INCLUDED

#define GLSL_SHADER_H_INCLUDED

#ifdef _WIN32


#endif

#include <map>

#include <fstream>

#include <iostream>

#include <string>

#include <vector>


using std::string;

using std::ifstream;

using std::map;

using std::vector;

class GLSLProgram

{

public:

struct GLSLShader

{

unsigned int id;

string filename;

string source;

};

GLSLProgram(const string& vertexShader, const string& fragmentShader)

{

m_vertexShader.filename = vertexShader;

m_fragmentShader.filename = fragmentShader;

}

virtual ~GLSLProgram()

{

}

void unload()

{

glDetachShader(m_programID, m_vertexShader.id);

glDetachShader(m_programID, m_fragmentShader.id);

glDeleteShader(m_vertexShader.id);

glDeleteShader(m_fragmentShader.id);

glDeleteShader(m_programID);

}

bool initialize()

{

m_programID = glCreateProgram();

m_vertexShader.id = glCreateShader(GL_VERTEX_SHADER);

m_fragmentShader.id = glCreateShader(GL_FRAGMENT_SHADER);

m_vertexShader.source = readFile(m_vertexShader.filename);

m_fragmentShader.source = readFile(m_fragmentShader.filename);

if (m_vertexShader.source.empty() || m_fragmentShader.source.empty())

{

return false;

}

const GLchar* tmp = static_cast<const GLchar*>(m_vertexShader.source.c_str());

glShaderSource(m_vertexShader.id, 1, (const GLchar**)&tmp, NULL);

tmp = static_cast<const GLchar*>(m_fragmentShader.source.c_str());

glShaderSource(m_fragmentShader.id, 1, (const GLchar**)&tmp, NULL);

if (!compileShader(m_vertexShader) || !compileShader(m_fragmentShader))

{

std::cerr << "Could not compile the shaders, they are invalid" << std::endl;

return false;

}

glAttachShader(m_programID, m_vertexShader.id);

glAttachShader(m_programID, m_fragmentShader.id);

glLinkProgram(m_programID);

return true;

}

void linkProgram()

{

glLinkProgram(m_programID);

}

GLuint getUniformLocation(const string& name)

{

map<string, GLuint>::iterator i = m_uniformMap.find(name);

if (i == m_uniformMap.end())

{

GLuint location = glGetUniformLocation(m_programID, name.c_str());

m_uniformMap.insert(std::make_pair(name, location));

return location;

}

return (*i).second;

}

GLuint getAttribLocation(const string& name)

{

map<string, GLuint>::iterator i = m_attribMap.find(name);

if (i == m_attribMap.end())

{

GLuint location = glGetAttribLocation(m_programID, name.c_str());

m_attribMap.insert(std::make_pair(name, location));

return location;

}

return (*i).second;

}

void sendUniform(const string& name, const int id)

{

GLuint location = getUniformLocation(name);

glUniform1i(location, id);

}

void sendUniform4x4(const string& name, const float* matrix, bool transpose=false)

{


glUniformMatrix4fv(location, 1, transpose, matrix);

}

void sendUniform3x3(const string& name, const float* matrix, bool transpose=false)

{


glUniformMatrix3fv(location, 1, transpose, matrix);

}

void sendUniform(const string& name, const float red, const float green,

const float blue, const float alpha)

{


glUniform4f(location, red, green, blue, alpha);

}

void sendUniform(const string& name, const float x, const float y,

const float z)

{


glUniform3f(location, x, y, z);

}

void sendUniform(const string& name, const float scalar)

{


glUniform1f(location, scalar);

}

void bindAttrib(unsigned int index, const string& attribName)

{

glBindAttribLocation(m_programID, index, attribName.c_str());

}

void bindShader()

{

glUseProgram(m_programID);

}

private:

string readFile(const string& filename)

{

ifstream fileIn(filename.c_str());

if (!fileIn.good())

{

std::cerr << "Could not load shader: " << filename << std::endl;

return string();

}

string stringBuffer(std::istreambuf_iterator<char>(fileIn), (std::istreambuf_iterator<char>()));

return stringBuffer;

}

bool compileShader(const GLSLShader& shader)

{

glCompileShader(shader.id);

GLint result = 0xDEADBEEF;

glGetShaderiv(shader.id, GL_COMPILE_STATUS, &result);

if (!result)

{

std::cout << "Could not compile shader: " << shader.id << std::endl;

outputShaderLog(shader.id);

return false;

}

return true;

}

void outputShaderLog(unsigned int shaderID)

{

vector<char> infoLog;

GLint infoLen;

glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &infoLen);

infoLog.resize(infoLen);

std::cerr << "GLSL Shader: Shader contains errors, please validate this shader!" << std::endl;

glGetShaderInfoLog(shaderID, sizeof(infoLog), &infoLen, &infoLog[0]);

std::cerr << string(infoLog.begin(), infoLog.end()) << std::endl;

#ifdef _WIN32

MessageBox(NULL, string(infoLog.begin(), infoLog.end()).c_str(), "Error", MB_OK);

#endif

}

GLSLShader m_vertexShader;

GLSLShader m_fragmentShader;

unsigned int m_programID;

map<string, GLuint> m_uniformMap;

map<string, GLuint> m_attribMap;

};

#endif // GLSL_SHADER_H_INCLUDED

#ifdef _WIN32


#endif

#include <cstdlib>

#include <iostream>

#include <fstream>

#include <ctime>


#include <GL/glu.h>

#include "projek.h"

#include "glslshader.h"

Example::Example()

{

m_GLSLProgram = new GLSLProgram("data/basic-fixed.vert", "data/basic-fixed.frag");

m_waterProgram = new GLSLProgram("data/water.vert", "data/water.frag");

m_rotationAngle = 0.0f;

}

Example::~Example()

{

delete m_GLSLProgram;

delete m_waterProgram;

}

bool Example::init()

{

if (!m_GLSLProgram->initialize() || !m_waterProgram->initialize())

{

std::cerr << "Could not initialize the shaders" << std::endl;

return false;

}

glEnable(GL_DEPTH_TEST);

glClearColor(0.0f, 0.5f, 0.9f, 0.5f);

if (!m_terrain.loadHeightmap("data/heightmap.raw", 65))

{

std::cerr << "Could not load the terrain" << std::endl;

return false;

}

//Lokasi Pengikat Atribut

m_GLSLProgram->bindAttrib(0, "a_Vertex");

m_GLSLProgram->bindAttrib(1, "a_TexCoord");

m_GLSLProgram->bindAttrib(2, "a_Normal");

m_waterProgram->bindAttrib(0, "a_Vertex");

m_waterProgram->bindAttrib(1, "a_TexCoord");

//Pemanggilan Link Program

m_GLSLProgram->linkProgram();

m_GLSLProgram->bindShader(); //Pengaktifan shader

m_waterProgram->linkProgram();

m_waterProgram->bindShader();

if (!m_grassTexture.load("data/warnagunung.tga"))

{

std::cerr << "Could not load the warnagunung texture" << std::endl;

return false;

}

if (!m_waterTexture.load("data/air.tga"))

{

std::cerr << "Could not load the air texture" << std::endl;

return false;

}

glGenTextures(1, &m_grassTexID);

glActiveTexture(GL_TEXTURE0);

glBindTexture(GL_TEXTURE_2D, m_grassTexID);

//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, m_grassTexture.getWidth(),

m_grassTexture.getHeight(), GL_RGB, GL_UNSIGNED_BYTE,

m_grassTexture.getImageData());

glGenTextures(1, &m_waterTexID);


glBindTexture(GL_TEXTURE_2D, m_waterTexID);

//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, m_waterTexture.getWidth(),

m_waterTexture.getHeight(), GL_RGB, GL_UNSIGNED_BYTE,

m_waterTexture.getImageData());

glEnable(GL_DEPTH_TEST);

glEnable(GL_CULL_FACE);

glDepthFunc(GL_LEQUAL);

if (!Tree::initialize())

{

return false;

}

positionTrees(5.0f, 0.94f);

//Pengembalian Sukses

return true;

}

void Example::positionTrees(float heightThreshold, float percentage)

{

srand((unsigned) time(NULL));

for (int z = 0; z < 65; ++z)

{

for (int x = 0; x < 65; ++x)

{

Vertex v = m_terrain.getPositionAt(x, z);

if (v.y > heightThreshold)

{

if (rand()/((double)RAND_MAX + 1) > percentage) {

m_trees.push_back(Tree(v.x, v.y, v.z));

}

}

}

}

}

void Example::prepare(float dt)

{

m_rotationAngle += 10.0f * dt;

if (m_rotationAngle > 360.0f) {

m_rotationAngle -= 360.0f;

}

}

vector<float> Example::calculateNormalMatrix(const float* modelviewMatrix)

{

/*

0 1 2

0 0 3 6

1 1 4 7

2 2 5 8

*/

vector<float> M(3 * 3);

M[0] = modelviewMatrix[0];









float determinate = M[0] * M[4] * M[8] + M[1] * M[5] * M[6] + M[2] * M[3] * M[7];

determinate -= M[2] * M[4] * M[6] + M[0] * M[5] * M[7] + M[1] * M[3] * M[8];

float oneOverDet = 1.0f / determinate;

vector<float> N(3 * 3);

//Kalkulasi dan Mengubah Posisi Matrix

N[0] = (M[4] * M[8] - M[5] * M[7]) * oneOverDet;









return N;

}

void Example::render()

{

float modelviewMatrix[16];

float projectionMatrix[16];

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//Load identitas matrix

glLoadIdentity();

//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

glTranslatef(5.0f, -14.0f, 1.0f);

glRotatef(25.0f, 1.0f, 0.0f, 0.0f);

//Translate Menggunakan Posisi Variable z

glTranslatef(0.0, 0.0, -30.0f);

glRotatef(m_rotationAngle, 0, 1, 0);

glGetFloatv(GL_MODELVIEW_MATRIX, modelviewMatrix);

glGetFloatv(GL_PROJECTION_MATRIX, projectionMatrix);

vector<float> normalMatrix = calculateNormalMatrix(modelviewMatrix);

m_GLSLProgram->bindShader();

//Mengirim Modelview dan Proyek Matrix ke shaders

m_GLSLProgram->sendUniform4x4("modelview_matrix", modelviewMatrix);

m_GLSLProgram->sendUniform4x4("projection_matrix", projectionMatrix);

m_GLSLProgram->sendUniform3x3("normal_matrix", &normalMatrix[0]);

m_GLSLProgram->sendUniform("texture0", 0);

m_GLSLProgram->sendUniform("material_ambient", 0.2f, 0.2f, 0.2f, 1.0f);

m_GLSLProgram->sendUniform("material_diffuse", 0.8f, 0.8f, 0.8f, 1.0f);

m_GLSLProgram->sendUniform("material_specular", 0.6f, 0.6f, 0.6f, 1.0f);

m_GLSLProgram->sendUniform("material_emissive", 0.0f, 0.0f, 0.0f, 1.0f);

m_GLSLProgram->sendUniform("material_shininess", 10.0f);

m_GLSLProgram->sendUniform("light0.ambient", 0.0f, 0.0f, 0.0f, 1.0f);

m_GLSLProgram->sendUniform("light0.diffuse", 1.0f, 1.0f, 1.0f, 1.0f);

m_GLSLProgram->sendUniform("light0.specular", 0.3f, 0.3f, 0.3f, 1.0f);

m_GLSLProgram->sendUniform("light0.position", 0.0f, 0.4f, 1.0f, 0.0f);

glBindTexture(GL_TEXTURE_2D, m_grassTexID);

m_terrain.render();

for (vector<Tree>::iterator tree = m_trees.begin(); tree != m_trees.end(); ++tree)

{

(*tree).render();

}

m_waterProgram->bindShader();

m_waterProgram->sendUniform4x4("modelview_matrix", modelviewMatrix);

m_waterProgram->sendUniform4x4("projection_matrix", projectionMatrix);

m_waterProgram->sendUniform3x3("normal_matrix", &normalMatrix[0]);

glBindTexture(GL_TEXTURE_2D, m_waterTexID);

m_terrain.renderWater();

}

void Example::shutdown()

{

}

void Example::onResize(int width, int height)

{

glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(52.0f, float(width) / float(height), 1.0f, 100.0f);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

}

#ifndef _EXAMPLE_H

#define _EXAMPLE_H

#ifdef _WIN32


#endif

#include <vector>

#include <string>

#include "terrain.h"

#include "targa.h"

#include "pohon.h"

class GLSLProgram;

using std::vector;

using std::string;

class Example

{

public:

Example();

virtual ~Example();

bool init();

void prepare(float dt);

void render();

void shutdown();

void onResize(int width, int height);

static vector<float> calculateNormalMatrix(const float* modelviewMatrix);

void positionTrees(float heightThreshold, float percentage);

private:

Terrain m_terrain;

GLSLProgram* m_GLSLProgram;

GLSLProgram* m_waterProgram;

TargaImage m_grassTexture;

TargaImage m_waterTexture;

GLuint m_grassTexID;

GLuint m_waterTexID;

vector<Tree> m_trees;

float m_rotationAngle;

};

#endif

#include <iostream>

#include <string>

#ifdef __unix__

#include <sys/time.h>

#endif

#include "projek.h"

#include "glxwindow.h"

using std::string;

typedef GLXContext ( * PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display *dpy, GLXFBConfig

config, GLXContext share_context, Bool direct, const int *attrib_list);

unsigned int GetTickCount() {

struct timeval t;

gettimeofday(&t, NULL);

unsigned long secs = t.tv_sec * 1000;

secs += (t.tv_usec / 1000);

return secs;

}

SimpleGLXWindow::SimpleGLXWindow():

m_example(NULL),

m_isRunning(true),

m_lastTime(0),

m_display(NULL),

m_XWindow(0),

m_glContext(0),

m_screenID(0),

m_isFullscreen(false),

m_width(0),

m_height(0),

m_bpp(0),

m_GL3Supported(false)

{

}

SimpleGLXWindow::~SimpleGLXWindow()

{

}

bool SimpleGLXWindow::create(int width, int height, int bpp, bool fullscreen)

{

m_display = XOpenDisplay(0);

if (m_display == NULL)

{

std::cerr << "Could not open the display" << std::endl;

return false;

}

m_screenID = DefaultScreen(m_display);

int n = 0, modeNum = 0;

GLXFBConfig framebufferConfig = (*glXChooseFBConfig(m_display, DefaultScreen(m_display), 0, &n));

XF86VidModeModeInfo **modes;

if (!XF86VidModeGetAllModeLines(m_display, m_screenID, &modeNum, &modes))

{

std::cerr << "Could not query the video modes" << std::endl;

return false;

}

m_XF86DeskMode = *modes[0];

int bestMode = -1;

for (int i = 0; i < modeNum; i++)

{

if ((modes[i]->hdisplay == width) &&

(modes[i]->vdisplay == height))

{

bestMode = i;

}

}

if (bestMode == -1)

{

std::cerr << "Could not find a suitable graphics mode" << std::endl;

return false;

}

int doubleBufferedAttribList [] = {

GLX_RGBA, GLX_DOUBLEBUFFER,

GLX_RED_SIZE, 4,

GLX_GREEN_SIZE, 4,

GLX_BLUE_SIZE, 4,

GLX_DEPTH_SIZE, 16,

None

};

XVisualInfo* vi = NULL;

vi = glXChooseVisual(m_display, m_screenID, doubleBufferedAttribList);

if (vi == NULL)

{

std::cerr << "Could not create a double buffered window" << std::endl;

return false;

}

GLXContext m_glContext = glXCreateContext(m_display, vi, 0, GL_TRUE);

if (m_glContext == NULL)

{

std::cerr << "Could not create a GL 2.1 context, please check your graphics drivers" << std::endl;

return false;

}

m_GL3Supported = false;

Colormap cmap = XCreateColormap(m_display, RootWindow(m_display, vi->screen),vi->visual, AllocNone);

m_XSetAttr.colormap = cmap;

m_XSetAttr.border_pixel = 0;

m_XSetAttr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask |

StructureNotifyMask;

m_XSetAttr.override_redirect = False;

unsigned long windowAttributes = CWBorderPixel | CWColormap | CWEventMask;

if (fullscreen)

{

windowAttributes = CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect;

XF86VidModeSwitchToMode(m_display, m_screenID, modes[bestMode]);

XF86VidModeSetViewPort(m_display, m_screenID, 0, 0);

m_XSetAttr.override_redirect = True;

}

m_XWindow = XCreateWindow(m_display, RootWindow(m_display, vi->screen),

0, 0, width, height, 0, vi->depth, InputOutput, vi->visual,

CWBorderPixel | CWColormap | CWEventMask, &m_XSetAttr);

string title = "KELOMPOK 2 - GRAFIKA KOMPUTER";

if (fullscreen)

{

XWarpPointer(m_display, None, m_XWindow, 0, 0, 0, 0, 0, 0);

XMapRaised(m_display, m_XWindow);

XGrabKeyboard(m_display, m_XWindow, True, GrabModeAsync, GrabModeAsync, CurrentTime);

XGrabPointer(m_display, m_XWindow, True, ButtonPressMask,

GrabModeAsync, GrabModeAsync, m_XWindow, None, CurrentTime);

m_isFullscreen = true;

}

else

{

Atom wmDelete = XInternAtom(m_display, "WM_DELETE_WINDOW", True);

XSetWMProtocols(m_display, m_XWindow, &wmDelete, 1);

XSetStandardProperties(m_display, m_XWindow, title.c_str(), None, NULL, NULL, 0, NULL);

XMapRaised(m_display, m_XWindow);

}

XFree(modes);

glXMakeCurrent(m_display, m_XWindow, m_glContext);

int posx = 0;

int posy = 0;

Window winDummy;

unsigned int borderDummy;

m_width = (unsigned) width;

m_height = (unsigned) height;

m_bpp = (unsigned) bpp;

XGetGeometry(m_display, m_XWindow, &winDummy,

&posx, &posy, &m_width, &m_height,

&borderDummy, &m_bpp);

m_lastTime = GetTickCount();

return true;

}

void SimpleGLXWindow::destroy()

{

if (m_glContext)

{

glXMakeCurrent(m_display, None, NULL);

glXDestroyContext(m_display, m_glContext);

m_glContext = NULL;

}

if (m_isFullscreen)

{

XF86VidModeSwitchToMode(m_display, m_screenID, &m_XF86DeskMode);

XF86VidModeSetViewPort(m_display, m_screenID, 0, 0);

}

XCloseDisplay(m_display);

}

void SimpleGLXWindow::processEvents()

{

XEvent event;

while (XPending(m_display) > 0)

{

XNextEvent(m_display, &event);

switch (event.type)

{

case Expose:

if (event.xexpose.count != 0)

break;

break;

case ConfigureNotify:

{

int width = event.xconfigure.width;

int height = event.xconfigure.height;

getAttachedExample()->onResize(width, height);

}

break;

case KeyPress:

{

if (XLookupKeysym(&event.xkey,0) == XK_Escape) {


}

//Register the key press with the keyboard interface

}

break;

case KeyRelease:

{

}

break;

case ClientMessage:

if (string(XGetAtomName(m_display, event.xclient.message_type)) == string("WM_PROTOCOLS"))

{


}

break;

default:

break;

}

}

}

bool SimpleGLXWindow::isRunning()

{

return m_isRunning;

}

void SimpleGLXWindow::attachExample(Example* example)

{

m_example = example;

}

float SimpleGLXWindow::getElapsedSeconds()

{

unsigned int currentTime = GetTickCount();

unsigned int diff = currentTime - m_lastTime;

m_lastTime = currentTime;

return float(diff) / 1000.0f;

}

#ifndef GLXWINDOW_H_INCLUDED

#define GLXWINDOW_H_INCLUDED

#define GLX_GLXEXT_LEGACY //Must be declared so that our local glxext.h is picked up, rather than the system

one


#include <GL/glx.h>

#include "glx/glxext.h"

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/extensions/xf86vmode.h>

#include <X11/keysym.h>

#include <ctime>

class Example; //Declare our Example class

class SimpleGLXWindow

{

public:

SimpleGLXWindow(); //default constructor

virtual ~SimpleGLXWindow();

bool create(int width, int height, int bpp, bool fullscreen);

void destroy();

void processEvents();

void attachExample(Example* example);

bool isRunning(); //Is the window running?

void swapBuffers() { glXSwapBuffers(m_display, m_XWindow); }

float getElapsedSeconds();

private:

Example* m_example; //A link to the example program

bool m_isRunning; //Is the window still running?

Example* getAttachedExample() { return m_example; }

unsigned int m_lastTime;

Display* m_display;

Window m_XWindow;

GLXContext m_glContext;

XF86VidModeModeInfo m_XF86DeskMode;

XSetWindowAttributes m_XSetAttr;

int m_screenID;

bool m_isFullscreen;

unsigned int m_width;

unsigned int m_height;

unsigned int m_bpp;

bool m_GL3Supported;

};

#endif // GLXWINDOW_H_INCLUDED

#include <fstream>

#include <cmath>

#include <iostream>

#include <cassert>

#include "terrain.h"

#include "projek.h"

Terrain::Terrain()

{

m_vertexBuffer = m_indexBuffer = m_colorBuffer = 0;

}

void Terrain::generateVertices(const vector<float> heights, int width)

{

int i = 0;

for (float z = float(-width / 2); z <= (width/2); ++z)

{

for (float x = float(-width / 2); x <= (width/2); ++x)

{

m_vertices.push_back(Vertex(x, heights[i++], z));

}

}

glGenBuffers(1, &m_vertexBuffer);

glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * m_vertices.size() * 3, &m_vertices[0],

GL_STATIC_DRAW); //Mengirim Data ke OpenGL

}

void Terrain::generateWaterVertices(int width)

{

int i = 0;

for (float z = float(-width / 2); z <= (width/2); z++)

{

for (float x = float(-width / 2); x <= (width/2); x++)

{

m_waterVertices.push_back(Vertex(x, 4.0f, z));

}

}

glGenBuffers(1, &m_waterVertexBuffer);

glBindBuffer(GL_ARRAY_BUFFER, m_waterVertexBuffer);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * m_waterVertices.size() * 3, &m_waterVertices[0],

GL_STATIC_DRAW);

}

void Terrain::generateIndices(int width)

{

/*

Pengulangan Untuk Membangun Segitiga yang Disusun

Berdasarkan Masing-masing Bujur Sangkar.

(z*w+x) *----* (z*w+x+1)

| /|

| / |

| / |

((z+1)*w+x)*----* ((z+1)*w+x+1)

*/

for (int z = 0; z < width - 1; ++z) //Melewati Baris - 1

{

for (int x = 0; x < width - 1; ++x) //Dan Kolom - 1

{

m_indices.push_back((z * width) + x);

m_indices.push_back(((z + 1) * width) + x);

m_indices.push_back((z * width) + x + 1);

m_indices.push_back(((z + 1) * width) + x);

m_indices.push_back(((z + 1) * width) + x + 1);

m_indices.push_back((z * width) + x + 1);

}

}

glGenBuffers(1, &m_indexBuffer);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * m_indices.size(), &m_indices[0],

GL_STATIC_DRAW);

}

void Terrain::generateWaterIndices(int width)

{

for (int z = 0; z < width - 1; ++z) //Melewati Baris - 1

{

for (int x = 0; x < width - 1; ++x) //Dan Kolom - 1

{

m_waterIndices.push_back((z * width) + x);

m_waterIndices.push_back(((z + 1) * width) + x);

m_waterIndices.push_back((z * width) + x + 1);

m_waterIndices.push_back(((z + 1) * width) + x);

m_waterIndices.push_back(((z + 1) * width) + x + 1);

m_waterIndices.push_back((z * width) + x + 1);

}

}

glGenBuffers(1, &m_waterIndexBuffer);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_waterIndexBuffer);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * m_waterIndices.size(), &m_waterIndices[0],

GL_STATIC_DRAW);

}

Vertex* crossProduct(Vertex* out, Vertex* v1, Vertex* v2)

{

Vertex v;

v.x = (v1->y * v2->z) - (v1->z * v2->y);

v.y = (v1->z * v2->x) - (v1->x * v2->z);

v.z = (v1->x * v2->y) - (v1->y * v2->x);

out->x = v.x;

out->y = v.y;

out->z = v.z;

return out;

}

Vertex* normalize(Vertex* in)

{

float l = sqrtf(in->x * in->x + in->y * in->y + in->z * in->z);

in->x = in->x / l;

in->y = in->y / l;

in->z = in->z / l;

return in;

}

void Terrain::generateNormals()

{

vector<Vertex> faceNormals;

vector<int> shareCount;

m_normals.resize(m_vertices.size());

shareCount.resize(m_vertices.size());

for (unsigned int i = 0; i < shareCount.size(); ++i)

{

shareCount[i] = 0;

}

unsigned int numTriangles = m_indices.size() / 3;

faceNormals.resize(numTriangles);

for (unsigned int i = 0; i < numTriangles; ++i)

{

Vertex* v1 = &m_vertices[m_indices[i*3]];

Vertex* v2 = &m_vertices[m_indices[(i*3)+1]];

Vertex* v3 = &m_vertices[m_indices[(i*3)+2]];

Vertex vec1, vec2;

vec1.x = v2->x - v1->x;

vec1.y = v2->y - v1->y;

vec1.z = v2->z - v1->z;

vec2.x = v3->x - v1->x;

vec2.y = v3->y - v1->y;

vec2.z = v3->z - v1->z;

Vertex* normal = &faceNormals[i];

crossProduct(normal, &vec1, &vec2);

normalize(normal);

for (int j = 0; j < 3; ++j)

{

int index = m_indices[(i*3)+j];

m_normals[index].x += normal->x;

m_normals[index].y += normal->y;

m_normals[index].z += normal->z;

shareCount[index]++;

}

}

for (unsigned int i = 0; i < m_vertices.size(); ++i)

{

m_normals[i].x = m_normals[i].x / shareCount[i];

m_normals[i].y = m_normals[i].y / shareCount[i];

m_normals[i].z = m_normals[i].z / shareCount[i];

normalize(&m_normals[i]);

}

glGenBuffers(1, &m_normalBuffer);

glBindBuffer(GL_ARRAY_BUFFER, m_normalBuffer);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * m_normals.size() * 3, &m_normals[0],


}

void Terrain::generateTexCoords(int width)

{

for (int z = 0; z < width; ++z)

{

for (int x = 0; x < width; ++x)

{

float s = (float(x) / float(width)) * 8.0f;

float t = (float(z) / float(width)) * 8.0f;

m_texCoords.push_back(TexCoord(s, t));

}

}

glGenBuffers(1, &m_texCoordBuffer);

glBindBuffer(GL_ARRAY_BUFFER, m_texCoordBuffer);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * m_texCoords.size() * 2, &m_texCoords[0],


}

void Terrain::generateWaterTexCoords(int width)

{

for (int z = 0; z < width; ++z)

{

for (int x = 0; x < width; ++x)

{

float s = (float(x) / float(width)) * 8.0f;

float t = (float(z) / float(width)) * 8.0f;

m_waterTexCoords.push_back(TexCoord(s, t));

}

}

glGenBuffers(1, &m_waterTexCoordsBuffer);

glBindBuffer(GL_ARRAY_BUFFER, m_waterTexCoordsBuffer);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * m_waterTexCoords.size() * 2, &m_waterTexCoords[0],


}

bool Terrain::loadHeightmap(const string& rawFile, int width)

{

const float HEIGHT_SCALE = 10.0f;

std::ifstream fileIn(rawFile.c_str(), std::ios::binary);

if (!fileIn.good())

{

std::cout << "File does not exist" << std::endl;

return false;

}

string stringBuffer(std::istreambuf_iterator<char>(fileIn), (std::istreambuf_iterator<char>()));

fileIn.close();

if (stringBuffer.size() != (width * width))

{

std::cout << "Image size does not match passed width" << std::endl;

return false;

}

vector<float> heights;

heights.reserve(width * width);

for (int i = 0; i < (width * width); ++i)

{

float value = (float)(unsigned char)stringBuffer[i] / 256.0f;

heights.push_back(value * HEIGHT_SCALE);

m_colors.push_back(Color(value, value, value));

}

glGenBuffers(1, &m_colorBuffer);

glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * m_colors.size() * 3, &m_colors[0],

GL_STATIC_DRAW);

generateVertices(heights, width);

generateIndices(width);

generateTexCoords(width);

generateNormals();

generateWaterVertices(width);

generateWaterIndices(width);

generateWaterTexCoords(width);

m_width = width;

return true;

}

Vertex Terrain::getPositionAt(int x, int z)

{

assert((z * m_width) + x < (int)m_vertices.size());

return m_vertices[(z * m_width) + x];

}

void Terrain::renderWater()

{

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA, GL_ONE);

glEnableVertexAttribArray(0);


glBindBuffer(GL_ARRAY_BUFFER, m_waterVertexBuffer);

glVertexAttribPointer((GLint)0, 3, GL_FLOAT, GL_FALSE, 0, 0);

glBindBuffer(GL_ARRAY_BUFFER, m_waterTexCoordsBuffer);


glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_waterIndexBuffer);

glDrawElements(GL_TRIANGLES, m_waterIndices.size(), GL_UNSIGNED_INT, 0);

glDisableVertexAttribArray(0);


glDisable(GL_BLEND);

}

void Terrain::render()

{








glBindBuffer(GL_ARRAY_BUFFER, m_normalBuffer);


glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);

glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, 0);




}

#ifndef BOGLGP_TERRAIN_H

#define BOGLGP_TERRAIN_H

#ifdef _WIN32


#endif

#include <string>

#include <vector>


using std::string;

using std::vector;

struct Vertex

{

float x, y, z;

Vertex()

{

x = y = z = 0.0f;

}

Vertex(float x, float y, float z)

{

this->x = x;

this->y = y;

this->z = z;

}

};

struct TexCoord

{

float s, t;

TexCoord(float s, float t)

{

this->s = s;

this->t = t;

}

};

struct Color

{

float r, g, b;

Color(float r, float g, float b)

{

this->r = r;

this->g = g;

this->b = b;

}

};

class Terrain

{

public:

Terrain();

bool loadHeightmap(const string& rawFile, int width);

void render();

void renderWater();

Vertex getPositionAt(int x, int z);

private:

void generateVertices(const vector<float> heights, int width);

void generateIndices(int width);

void generateTexCoords(int width);

void generateNormals();

void generateWaterVertices(int width);

void generateWaterIndices(int width);

void generateWaterTexCoords(int width);

GLuint m_vertexBuffer;

GLuint m_indexBuffer;

GLuint m_colorBuffer;

GLuint m_texCoordBuffer;

GLuint m_normalBuffer;

GLuint m_waterVertexBuffer;

GLuint m_waterIndexBuffer;

GLuint m_waterTexCoordsBuffer;

vector<Vertex> m_vertices;

vector<Color> m_colors;

vector<TexCoord> m_texCoords;

vector<GLuint> m_indices;

vector<Vertex> m_normals;

vector<Vertex> m_waterVertices;

vector<GLuint> m_waterIndices;

vector<TexCoord> m_waterTexCoords;

int m_width;

};

#endif


#include <GL/glu.h>

#include "glslshader.h"

#include "targa.h"

#include "pohon.h"

auto_ptr<GLSLProgram> Tree::m_alphaTestProgram = auto_ptr<GLSLProgram>();

GLuint Tree::m_treeTexID = 0;

GLuint Tree::m_vertexBuffer = 0;

GLuint Tree::m_texCoordBuffer = 0;

const string TreeTexturePath = "data/pohon.tga";

Tree::Tree(float x, float y, float z):

x(x),

y(y),

z(z)

{

}

void Tree::initializeVBOs()

{

GLfloat vertex [] = {

-1.0f, 0.0f, 0.0f,

1.0f, 0.0f, 0.0f,

-1.0f, 2.0f, 0.0f,

1.0f, 2.0f, 0.0f,

0.0f, 0.0f, 1.0f,

0.0f, 0.0f,-1.0f,

0.0f, 2.0f, 1.0f,

0.0f, 2.0f,-1.0f,

};

GLfloat texCoord [] = {

0.0f, 0.0f,

1.0f, 0.0f,

0.0f, 1.0f,

1.0f, 1.0f,

0.0f, 0.0f,

1.0f, 0.0f,

0.0f, 1.0f,

1.0f, 1.0f,

};

glGenBuffers(1, &m_vertexBuffer);


glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 8 * 3, &vertex[0], GL_STATIC_DRAW);

glGenBuffers(1, &m_texCoordBuffer);


glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 8 * 2, &texCoord[0], GL_STATIC_DRAW);

}

bool Tree::initialize()

{

if (m_treeTexID == 0) {

TargaImage treeTexture;

if (!treeTexture.load(TreeTexturePath)) {

return false;

}

glGenTextures(1, &m_treeTexID);


glBindTexture(GL_TEXTURE_2D, m_treeTexID);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8, treeTexture.getWidth(),

treeTexture.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE,

treeTexture.getImageData());

m_alphaTestProgram = auto_ptr<GLSLProgram>(

new GLSLProgram("data/alphaTest.vert",

"data/alphaTest.frag"));

if (!m_alphaTestProgram->initialize())

{

std::cerr << "Could not initialize the shaders" << std::endl;

return false;

}

m_alphaTestProgram->bindAttrib(0, "a_Vertex");

m_alphaTestProgram->bindAttrib(1, "a_TexCoord0");

m_alphaTestProgram->linkProgram();

initializeVBOs();

}

return true;

}

void Tree::render()

{

glPushMatrix();

glTranslatef(x, y, z);

glGetFloatv(GL_MODELVIEW_MATRIX, modelviewMatrix);

glGetFloatv(GL_PROJECTION_MATRIX, projectionMatrix);

m_alphaTestProgram->bindShader();

m_alphaTestProgram->sendUniform4x4("modelview_matrix", modelviewMatrix);

m_alphaTestProgram->sendUniform4x4("projection_matrix", projectionMatrix);

glBindTexture(GL_TEXTURE_2D, m_treeTexID);

glDisable(GL_CULL_FACE);







glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);



glEnable(GL_CULL_FACE);

glPopMatrix();

}

#ifndef BOGLGP_TREE_H

#define BOGLGP_TREE_H

#include <string>

#include <vector>

#include <memory>


using std::string;

using std::vector;

using std::auto_ptr;

class GLSLProgram;

class Tree {

private:

static auto_ptr<GLSLProgram> m_alphaTestProgram;

static GLuint m_treeTexID;

static GLuint m_vertexBuffer;

static GLuint m_texCoordBuffer;

float modelviewMatrix[16];

float projectionMatrix[16];

vector<float> normalMatrix;

static void initializeVBOs();

float x, y, z;

public:

Tree(float x, float y, float z);

Tree(const Tree& t) {

x = t.x;

y = t.y;

z = t.z;

}

Tree& operator=(const Tree& t) {

x = t.x;

y = t.y;

z = t.z;

return *this;

}

static bool initialize();

void render();

};

#endif

#include <fstream>

#include <cassert>

#include <iostream>

#include "targa.h"

using std::ifstream;

TargaImage::TargaImage():

m_width(0),

m_height(0),

m_bitsPerPixel(0),

m_bytesPerPixel(0)

{

}

TargaImage::~TargaImage()

{

}

bool TargaImage::isImageTypeSupported(const TargaHeader& header)

{

if (((header.imageTypeCode != TFT_RGB) &&

(header.imageTypeCode != TFT_RLE_RGB)) ||

(header.colorMapType != 0))

{

return false;

}

return true;

}

bool TargaImage::isCompressedTarga(const TargaHeader& header)

{

return (header.imageTypeCode == TFT_RLE_RGB ||

header.imageTypeCode == TFT_RLE_GRAYSCALE);

}

bool TargaImage::isUncompressedTarga(const TargaHeader& header)

{

return (header.imageTypeCode == TFT_RGB ||

header.imageTypeCode == TFT_GRAYSCALE);

}

bool TargaImage::load(const string& filename)

{

ifstream fileIn(filename.c_str(), std::ios::binary);

if (!fileIn.good())

{

std::cerr << "Could not open the targa image file for reading" << std::endl;

return false;

}

fileIn.read(reinterpret_cast<char*>(&m_header), sizeof(TargaHeader));

if (!isImageTypeSupported(m_header))

{

std::cerr << "This is not a supported image type" << std::endl;

return false;

}

m_width = m_header.width;

m_height = m_header.height;

m_bitsPerPixel = m_header.bpp;

m_bytesPerPixel = m_header.bpp / 8;

// RGB = 3, RGBA = 4

if (m_bytesPerPixel < 3)

{

std::cerr << "Color depth not supported: " << m_bytesPerPixel << std::endl;

return false;

}

unsigned int imageSize = m_width * m_height * m_bytesPerPixel;

m_imageData.resize(imageSize);

if (m_header.idLength > 0)

{

fileIn.ignore(m_header.idLength);

}

bool result = false;

if (isUncompressedTarga(m_header))

{

result = loadUncompressedTarga(fileIn);

}

else

{

result = loadCompressedTarga(fileIn);

}

if ((m_header.imageDesc & TOP_LEFT) == TOP_LEFT)

{

flipImageVertically();

}

return result;

}

void TargaImage::unload()

{

m_imageData.clear();

}

bool TargaImage::loadCompressedTarga(istream& fileIn)

{

unsigned int pixelcount = m_height * m_width;

unsigned int currentpixel = 0;

unsigned int currentbyte= 0;

vector<unsigned char> colorBuffer(m_bytesPerPixel);

do {

unsigned char chunkheader = 0;

fileIn.read(reinterpret_cast<char*>(&chunkheader), sizeof(unsigned char));

if(chunkheader < 128)

{

chunkheader++;

for(short counter = 0; counter < chunkheader; counter++)

{

fileIn.read(reinterpret_cast<char*>(&colorBuffer[0]), m_bytesPerPixel);

m_imageData[currentbyte] = colorBuffer[2];

m_imageData[currentbyte + 1] = colorBuffer[1];


if(m_bytesPerPixel == 4)

{


}

currentbyte += m_bytesPerPixel;

currentpixel++;

if(currentpixel > pixelcount)

{

return false;

}

}

}

else

{

chunkheader -= 127;

fileIn.read(reinterpret_cast<char*>(&colorBuffer[0]), m_bytesPerPixel);

for(short counter = 0; counter < chunkheader; counter++)

{

m_imageData[currentbyte] = colorBuffer[2];



if(m_bytesPerPixel == 4)

{


}

currentbyte += m_bytesPerPixel;

currentpixel++;

if(currentpixel > pixelcount)

{

return false;

}

}

}

} while(currentpixel < pixelcount);

return true;

}

bool TargaImage::loadUncompressedTarga(istream& fileIn)

{

unsigned int imageSize = m_imageData.size();

fileIn.read(reinterpret_cast<char*>(&m_imageData[0]), imageSize);

for (unsigned int swap = 0; swap < imageSize; swap += m_bytesPerPixel)

{

char cswap = m_imageData[swap];

m_imageData[swap] = m_imageData[swap + 2];

m_imageData[swap + 2] = cswap;

}

return true;

}

unsigned int TargaImage::getWidth() const

{

return m_width;

}

unsigned int TargaImage::getHeight() const

{

return m_height;

}

unsigned int TargaImage::getBitsPerPixel() const

{

return m_bitsPerPixel;

}

const unsigned char* TargaImage::getImageData() const

{

return &m_imageData[0];

}

void TargaImage::flipImageVertically()

{

vector<unsigned char> flippedData;

flippedData.reserve(m_imageData.size());

int step = m_bytesPerPixel;

for (int row = m_height - 1; row >= 0; row--) {

unsigned char* rowData = &m_imageData[row * m_width * step];

for (unsigned int i = 0; i < m_width * step; ++i) {

flippedData.push_back(*rowData);

rowData++;

}

}

m_imageData.assign(flippedData.begin(), flippedData.end());

}

#ifndef TARGA_HEADER_H

#define TARGA_HEADER_H

#include <vector>

#include <string>

#include <fstream>

using std::vector;

using std::string;

using std::istream;

// These masks are AND'd with the imageDesc in the TGA header,

// bit 4 is left-to-right ordering

// bit 5 is top-to-bottom

enum IMAGE_ORIENTATIONS {

BOTTOM_LEFT = 0x00, // first pixel is bottom left corner

BOTTOM_RIGHT = 0x10, // first pixel is bottom right corner

TOP_LEFT = 0x20, // first pixel is top left corner

TOP_RIGHT = 0x30 // first pixel is top right corner

};

struct TargaHeader

{

unsigned char idLength;

unsigned char colorMapType;

unsigned char imageTypeCode;

unsigned char colorMapSpec[5];

unsigned short xOrigin;

unsigned short yOrigin;

unsigned short width;

unsigned short height;

unsigned char bpp;

unsigned char imageDesc;

};

enum TargaFileTypes

{

TFT_NO_DATA = 0,

TFT_INDEXED = 1,

TFT_RGB = 2,

TFT_GRAYSCALE = 3,

TFT_RLE_INDEXED = 9,

TFT_RLE_RGB = 10,

TFT_RLE_GRAYSCALE = 11

};

class TargaImage

{

public:

TargaImage();

virtual ~TargaImage();

bool load(const string& filename);

void unload();

unsigned int getWidth() const;

unsigned int getHeight() const;

unsigned int getBitsPerPixel() const;

const unsigned char* getImageData() const;

private:

TargaHeader m_header;

unsigned int m_width;

unsigned int m_height;

unsigned int m_bitsPerPixel;

unsigned int m_bytesPerPixel;

vector<unsigned char> m_imageData;

bool loadUncompressedTarga(istream& fileIn);

bool loadCompressedTarga(istream& fileIn);

bool isImageTypeSupported(const TargaHeader& header);

bool isCompressedTarga(const TargaHeader& header);

bool isUncompressedTarga(const TargaHeader& header);

void flipImageVertically();

};

#endif

Setelah dicompile dan run, maka hasilnya seperti screenshoot dibawah ini :

Bab IV

Kesimpulan dan saran

Grafika komputer akhir-akhir ini mulai dirasa sangat penting dan mencakup hampir semua

bidang kehidupan seiring dengan semakin pentingnya sistem komputer dalam berbagai

kegiatan. Grafika komputer merupakan gambar atau grafik yang dihasilkan oleh komputer.

Teknik-teknik yang dipelajari dalam grafika komputer adalah teknik-teknik bagaimana membuat

atau manciptakan gambar dengan menggunakan komputer, salah satunya adalah Teknik

Transformasi tiga dimensi yaitu suatu model atau bentuk atau teknik memindahkan atau

mengubah nilai posisi objek dalam sistem koordinat tiga dimensi. Pemindahan objek ini dapat

diartikan sebagai pemindahan titik. Transformasi tiga dimensi ini mencakup proses translasi,

penskalaan, rotasi, dll.

Dari laporan tugas ini diketahui cara-cara memindahkan polygon dengan GL Translatef,

memutar objek dengan GL Rotatef, membuat polygon tersebut lebih besar atau lebih kecil

dengan menggunakan GL Scalef. Di samping perintah-perintah yang kami sebutkan di atas,

masih banyak lagi objek-objek yang dapat dihasilkan dengan menggunkan transformasi tiga

dimensi.

Atas terselesainya laporan tugas ini semoga dapat memberi manfaat bagi yang membaca.

Namun, kami juga menyadari bahwa isi laporan tugas ini masih jauh dari sempurna.

Untuk waktu dan kesempatan yang diberikan oleh dosen pengajar tidak lupa kami ucapkan

banyak terima kasih.

if13unikom2008.files.wordpress.com · Web viewGambar 3D (3 dimensi) seringkali kita dengar sewaktu kita masih kecil dulu, namun tidak sedikit orang yang tidak tahu bagaimana mengimplementasikan

Documents