Isi Bangun Ruang Jam Gadang2

TUGAS BESAR GRAFIKA KOMPUTER
BANGUN RUANG JAM GADANG 3D

Diajukan untuk memenuhi
Tugas Mata Kuliah Grafika Komputer
Program Strata Satu Jurusan Teknik Informatika
Fakultas Teknik dan Ilmu Komputer
Universitas Komputer Indonesia
Dosen : Hendri Karisma, S. Kom
OLEH :
IMAM ZAINUDIN
DIMAS RICKY FIRMANSYAH
SANI SURYA
HAMDI JAMIN
KURNIAWAN
10108380
10108401
10108416
10109701
10106268
Kelas : IF8/VIII
JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNIK DAN ILMU KOMPUTER
UNIVERSITAS KOMPUTER INDONESIA
BANDUNG
2012
KATA PENGANTAR
1
Assalaamualaikum wr. wb,

Puji dan syukur penulis panjatkan kepada Allah SWT atas rahmat dan
karunia-Nya yang telah dilimpahkan, shalawat dan salam tidak lupa dicurahkan
kepada Nabi Muhammad SAW, sehingga penulis dapat menyelesaikan penyusunan
Tugas Besar ini tepat pada waktunya dengan judul BANGUN RUANG JAM
GADANG 3D.
Penyusunan Tugas Besar ini diajukan untuk memenuhi mata kuliah Grafika
Komputer Program Strata Satu Jurusan Teknik Informatika Fakultas Teknik dan Ilmu
Komputer, Universitas Komputer Indonesia Bandung.
Sebagai manusia biasa penulis menyadari masih terdapat banyak kekurangan
di dalam penulisan laporan Tugas Besar ini karena keterbatasan pengetahuan penulis.
Oleh karena itu, saran dan kritik sangat penulis harapkan. Semoga laporan ini dapat
bermanfaat bagi semua pihak yang memerlukan.
Wassalaamualaikum wr. wb.
Bandung, Juli 2012

Penulis
BAB I
PENDAHULUAN
1.1.
Latar Belakang
Jam Gadang adalah nama untuk menara jam mirip Big Ben yang terletak di
pusat kota Bukittinggi, Sumatera Barat, Indonesia. Menara jam ini memiliki jam
dengan ukuran besar di empat sisinya sehingga dinamakan Jam Gadang, dimana bila
diterjemahkan dari bahasa Minang ke dalam bahasa Indonesia maka berarti "jam
besar".
Jam Gadang memiliki denah dasar seluas 13 x 4 meter dan tinggi 26 meter ini
terdiri dari beberapa tingkat. Di bagian atas menaraterdapat 4 (empat) jam dengan
diameter masing-masing 80 cm.
Dalam pemanfaatan komputer grafik untuk manipulasi objek 2D/3D, ada dua
jenis obyek yang bisa dimodelkan yaitu obyek sederhana dan obyek kompleks.obyek
sederhana biasanya memiliki bentuk yang kurang bervariasi. Biasanya untuk
mendapatkan obyek yang lebih bervariasi adalah dengan menggabungkan obyek
sederhana dan obyek kompleks.
Dalam kegiatan komputer grafik yang termasuk kedalam mata kuliah, kami
membuat bangun ruang Jam Gadang yang terdiri dari obyek sederhana di bagian luar
obyek dan memiliki obyek kompleks dalam setiap bangunan nya. Seperti bentuk
gonjong atau atap pada rumah adat Minangkabau, Rumah Gadang. Bentuk jam ini-lah
yang menjadi ciri utama dari bangun ruang 3D, jam gadang ini nantinyadapat
berputar layaknya jam jam pada umumnya. Dan sedikit sentuhan taman kecil yang
mengelilingi ornamen 3D jam gadang.
Ekspetasi yang kami berikan adalah pegambaran langsung dari lokasi Jam
Gadang yang nantinya dituangkan dalam bentuk 3D. Dimana di sekitar jam gadang
akan terdapat jalan jalan dengan angkutan kota yang berlalu lalang, Jam Gadang
sendiri yang dapat berputar layaknya jam pada umumnya dan efek cahaya lampu
pada taman kecil yang berada di sekitar Jam Gadang yang menyinari ke arah Jam
Gadang yang menjadi fokus utama tugas dalam objek 3D kami.
Kami juga akan menerapkan key keyboard untuk mengatur cahaya,
perputaran jam, laju jalannya angkutan angkutan kota serta efek kamera yang bisa
di atur arah melihatnya dan juga adanya efek siang serta malam yang dapat
menjadikan suasana Jam Gadang 3D ini berasa seperti aslinya sehingga kita dapat
merasa berada langsung di kota Bukittinggi, Sumatra Barat.
1.2.
Perumusan Masalah
Dalam melaksanakan perancangan bangun ruang 3D ini, permasalah yang ada
adalah sebagai berikut :

1.
2.
Bagaimana membuat bangun ruang 3D Jam Gadang.

Bagaimana menggerakkan detik, menit, dan jam pada setiap jam secara
3.
bersamaan.
Bagaimana mengimplementasikan bahan ajar mata kuliah Komputer
Grafika dalam membuat bangun ruang dengan menggunakan OpenGL.
1.3.
Maksud dan Tujuan
1.3.1. Maksud
Maksud dari penulisan ini adalah untuk Membuat aplikasi suasana Bangun
Ruang Jam Gadang dengan menggunakan OpenGL yang menampilkan objek-objek
seperti Jam Gadang, Taman, Jalan Lalu Lintas, Sungai, Kincir angin dan Bus.
1.3.2. Tujuan
Adapun tujuan yang akan dicapai dari penulisan tugas besar ini adalah
sebagai berikut :
1. Menampilkan bangunan Jam Gadang beserta taman yang berada disekitarannya
yang dikelilingi oleh pohon-pohon disertai juga adanya kincir angin dan simulasi
pergerakan bus saat melintasi bangunan jam gadang.
2. Mengetahui fungsi-fungsi pada openGL dengan menggunakan empat unsur yaitu
coloring, lighting, blending, dan mapping.
2.1.
Batasan Masalah
Agar pembahasan masalah tidak menyimpang dari pokok bahasan, maka
batasan masalah dalam pembuatan perangkat lunak ini adalah sebagai berikut :
1. Hanya menampilkan Bangunan Jam Gadang 3D, taman, bus, pohon-pohon,
kincir angin dan jalan lalu lintas
2. Menampilkan pergerakan bus saat melintas.
3. Menampilkan pergerakan kincir angin.
4. Objek ditampilkan dalam 3 Dimensi
5. Menggunakan tools Code::Blocks 10.05.
BAB II
LANDASAN TEORI DAN IMPLEMENTASI PROGRAM
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.
Gambar 1Teapot hasil rendering
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 detaildetail yang dianggap penting dalam menunjukkan pola suatu gambar.
2.2
Elemen Dasar Grafika

Ada beberapa elemen dasar dari grafika komputer antara lain:
a) Point
Point adalah sebuah titik yang digunakan untuk membangun obyek. Setiap
titik dalam obyek 3 dimensi memiliki nilai dalam x, y dan z.
b) Polyline
Polyline adalah sebuah fungsi yang dibentuk dari beberapa garis yang saling
berhubungan dan membentuk sebuh kurva yang terbuka.
c) Polygon
Polygon adalah suatu fungsi yang mirip dengan polyline hanya saja hasilnya
adalah kurva tertutup, sedangkan polyline hasilnya kurva terbuka.
d) 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 obyekobyek 3 Dimensi.
e) 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 sebagai berikut :
a) Translasi
Translasi dilakukan dengan penambahan translasi pada suatu titik koordinat
dengan translasi vektor atau shift vektor, yaitu (t x,ty), dimana tx adalah translation
vektor menurut sumbu x, sedangkan t y 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 = [ t x ty
]. Bentuk vektor kolom adalah standar dari symbol matematik, yang juga berlaku
bagi notasi grafik seperti GKS dan PHIGS.
b) 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 s x dan sy menghasilkan
differential scaling, yang biasa digunakan pada program aplikasi.
c) 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 (x p 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 2 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.
2.
3.
Menentukan tekstur
a) Membaca atau membangkitkan tekstur.
b) Menandai tekstur.
c) Mengenablekan tekstur.
Menandai koordinat tekstur pada vertek.
Menentukan parameter tekstur seperti : Wrapping , filtering, dsb.
Langkah-langkah dalam memulai mapping sebuah tekstur yakni dengan

spesifikasi dibawah ini :
a) Menentukan Tekstur Image :
1.
Mendefinisikan tekstur image dari sebuah array teksel (element tekstur )
2.
ke dalam memory cpu : Glubyte my_texels[512][512];

Mendefinisikan seperti semua peta piksel yang lain :
a) Gambar yang didefinisikan (baik secara manual maupun dengn suatu
3.
fungsi matematik tertentu).

b) Membangkitkan dengan kode aplikasi.
Mengenablekan tekstur mapping
a) glEnable(GL_TEXTURE_2D)
b) OpenGL mendukung 1 sampai 4 dimensional tekstur mapping
b) Mendefinisikan gambar sebagai sebuah tekstur

glTexImage2D(target,level,components,w,h,border,format,type, texels );
Keterangan :
1.
2.
3.
4.
5.
6.
target: tipe dari teksture, e.g. GL_TEXTURE_2D

level: digunakan untuk mipmapping
components: element per texel
w, h: lebar dan tinggi dari texels pada pixels
border: digunakan untuk smoothing
format and type: menjelaskan texels
7.
8.
texels: pointer ke array texel

glTexImage2D(GL_TEXTURE_2D, 0, 3, 512, 512, 0,GL_RGB,
GL_UNSIGNED_BYTE, my_texels).
c) Mengubah gambar tekstur :

1.
2.
OpenGL meminta dimensi tekstur untuk menjadi dasar dari 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_ou
t);
data_in adalah gambar inputan.
data_out adalah gambar hasil.
3.
4.
d) 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 adalah API (Application Programing Interface) yang dikenalkan oleh
SGI (Silicon Graphics Inc) kali pertama pada tahun 1980-an. Awalnya OpenGL
diciptakan untuk mendukung proses rendering, pada saat itu hanya digunakan untuk
mendukung proses redering yang dilakukan oleh komputer graphic produksi SGI.
Namun akhirnya, OpenGL dijadikan standar oleh berbagai perusahaan software dan
hardware.
open GL (program java for openGL).
adalah bahasa yang dapat dijalankan
dimanapun dan di sembarang platform apapun, diberagam lingkungan : internet,

intranets, consumer electronic products, dan computer applications. Bahasa
pemrograman berorientasi objek telah menjadi aliran utama (mainstream), java benarbenar berorientasi objek sejati, melebihi C++.Segala sesuatu dijava kecuali sedikit
type dasar (int, float, double, char) adalah objek.
2.13
Visual C++
Visual C++ adalah sebuah produk Integrated Development Environment
(IDE) untuk bahasa pemrogramanC dan C++ yang dikembangkan Microsoft. Visual
C++ merupakan salah satu bagian dari paket MicrosoftVisual Studio.Bahasa C atau
C++ adalah suatu bahasa pemrograman.Bahasa C termasuk sebagai bahasa
pemrograman tingkat menengah, maksudnya bahasa C bisa dipelajari dengan lebih
mudah karena mudah dimengerti tetapi mempunyai kemampuan yang tinggi.
Bahasa C bisa digunakan untuk merekayasa program untuk segala kebutuhan,
baik untuk aplikasi bisnis, matematis atau bahkan game.Semua bahasa mempunyai
kelemahan atau kelebihan sendiri-sendiri. Begitu juga dengan bahasa C. Adapun
sebagian kelebihan dari bahasa C adalah sebagai
berikut :
Banyak memiliki operator untuk mengolah / memanipulasi data.
Bahasa C termasuk sebagai bahasa yang terstruktur sehingga program dapat
lebih mudah dipahami atau dikembangkan.
Bahasa C lebih mudah dimengerti karena lebih mirip kepada bahasa manusia.
Kecepatan eksekusi tinggi.
Mengenal data pointer.
Sedangkan kelemahan dari bahasa C adalah :
Banyaknya operator atau cara penulisan program kadang menimbulkan
kebingungan para pemakainya.
Perlunya ketelitian dalam penulisan program karena perintah (statement)
dalam bahasa C bersifat case sensitiv (huruf kapital dan huruf kecil dibedakan
2.14
Implementasi
Pembuatan objek yang kami lakukan dilakukan dengan pemanggilan fungsi-
fungsi umum yang sudah tersedia di library OpenGL itu sendiri. Berikut objek-objek
yang kami panggil :
2.14.1 Rincian Program
1. Terrain yang dibuat terdiri dari terrain tanah, terrain air dan terrain jalan raya.
2. Bangun jam gadang dibuat dengan menggabungkan kubus-kubus baik yang
solid maupun yang berbentuk wire sebagai jendela dan relif-relief. Jam dibuat
menggunakan gabungan lingkaran dan jarum jam dengan kubus. Bagian atas
dari jam gadang dibuat menggunakan vertex.
3. Kincir dibangun menggunakan gabungan kubus dan bangun torrus yang
terdapat pada openGl. Sedangkan untuk memutar kincir menggunakan fungsi
TimeFunc yang dirotasikan.
4. Bus dibangun menggunakan gabungan kubus dan lingkaran (sphere). Bus bisa
melakukan aksi maju mundur dengan menekan keyboard n dan untuk
mundur menggunakan keyboard m.
5. Taman dibuat dengan menggabungkan kubus yang dibentuk sedemikian rupa
agar bisa menjadi lampu hiasan, bangku dan dasar taman.
6. Pohon-pohonan menggabungkan kubus dengan kerucut (cone) yang di
transformasikan dan di rotasi sedemikian rupa sehingga terlihat seperti pohon
cemara.
7. Pagar dibangun dengan menggunakan gabungan kubus-kubus (cube), begitu
pula dengan lampu hanya ditambah dengan lingkaran (sphere) sebgai
lampunya.
8. Pencahayaan menggunakan tiga sumber cahaya sehingga tingkat kecerahan

pada saat menyentuh benda diatur maksimal agar kelihatan perbedaannya.
2.14.2 Capture Program
Capture Program ini terdapat beberapa tampilan yang ada dalam bangun
ruang Jam Gadang 3D.
1.
Tampilan Awal Program Bangun Ruang Jam Gadang
Gambar
2.
Tampilan Gedung Jam Gadang (Sumatera Barat)
Gambar
3.
Tampilan Taman
Gambar
4.
Tampilan Jalan Lalu Lintas beserta bus
Gambar
5.
Tampilan Kincir angin
Gambar
BAB III
KESIMPULAN DAN SARAN
5.1 Kesimpulan
Kesimpulan merupakan proses terakhir yang berisi hasil dari penelitian yang telah
dilakukan. Berikut adalah kesimpulan yang dapat di ambil dari tugas ini :
1. Mengetahui fungsi-fungsi pencampuran lighting, color, blending, fog.
2. Dapat melihat secara langsung perubahan yang terjadi pada objek.
5.2 Saran
Kami sangat mengharapkan saran dan kritik dari pembaca yang sifatnya membangun
bagi kami untuk memperbaiki segala kekurangan, maka kami dapat menghasilkan makalah yang
lebih baik lagi.
DAFTAR PUSTAKA
1.
2.
3.
4.
5.
http://dhanstar.blogspot.com/2010/10/grafik-komputer-2d-dan-3d.html.
http://aflah7.wordpress.com/2010/10/14/konsep-pemodelan-grafik-2d-dan-3d/
http://www.ilhamsk.com/desain-pemodelan-grafik/
http://id.wikipedia.org/wiki/Grafika_komputer_3D
http://id.wikipedia.org/wiki/Grafika_komputer.
LAMPIRAN
SOURCE KODE
//Tugas Besar Grafika Komputer "Pembuatan Jam
Gadang"
//Imam Zainudin
10108380
//Dimas Ricky
10108401
//Sani Surya S
10108416
//Hamdi Jamin
10109701
//Kurniawan
10106268
computedNormals = false;
}
~Terrain() {
for (int i = 0; i < l; i++) {
delete[] hs[i];
}
delete[] hs;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#ifdef __APPLE__
#include <OpenGL/OpenGL.h>
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#include <GL/glu.h>
#include <GL/gl.h>
#include "imageloader.h"
#include "vec3f.h"
#endif
for (int i = 0; i < l; i++) {

delete[] normals[i];
}
delete[] normals;
}
int width() {
return w;
}
int length() {
return l;
}
//static GLfloat spin, spin2 = 0.0;

float angle = 0;
float sudutk = 30.0f;
using namespace std;
float lastx, lasty;
GLint stencilBits;
static int viewx = 50;
static int viewy = 24;
static int viewz = 80;
int a=0, b=0, c=0, d=0;
float rot = 0;
//train 2D
//class untuk terain 2D
class Terrain {
private:
int w; //Width
int l; //Length
float** hs; //Heights
Vec3f** normals;
bool computedNormals; //Whether normals
is up-to-date
public:
Terrain(int w2, int l2) {
w = w2;
l = l2;
hs = new float*[l];
for (int i = 0; i < l; i++) {
hs[i] = new float[w];
}
normals = new Vec3f*[l];
for (int i = 0; i < l; i++) {
normals[i] = new
Vec3f[w];
//Sets the height at (x, z) to y

void setHeight(int x, int z, float y) {
hs[z][x] = y;
computedNormals = false;
}
//Returns the height at (x, z)
float getHeight(int x, int z) {
return hs[z][x];
}
//Computes the normals, if they haven't
been computed yet
void computeNormals() {
if (computedNormals) {
return;
}
normals
Vec3f[w];
//Compute the rough version of the

Vec3f** normals2 = new Vec3f*[l];
for (int i = 0; i < l; i++) {
normals2[i] = new
}
for (int z = 0; z < l; z++) {
for (int x = 0; x < w; x++)
Vec3f sum(0.0f,
0.0f, 0.0f);
Vec3f out;
if (z > 0) {
out =
Vec3f(0.0f, hs[z - 1][x] - hs[z][x], -1.0f);
}
Vec3f in;
if (z < l - 1) {
in =
Vec3f(0.0f, hs[z + 1][x] - hs[z][x], 1.0f);
}
Vec3f left;
if (x > 0) {
left =
Vec3f(-1.0f, hs[z][x - 1] - hs[z][x], 0.0f);
}
Vec3f right;
if (x < w - 1) {
right =
Vec3f(1.0f, hs[z][x + 1] - hs[z][x], 0.0f);
}
}
normals[z][x] =
sum;
for (int i = 0; i < l; i++) {

delete[] normals2[i];
}
delete[] normals2;
computedNormals = true;
}
}
if (x > 0 && z < l
- 1) {
sum +=
left.cross(in).normalize();
}
if (x < w - 1 && z
< l - 1) {
sum +=
in.cross(right).normalize();
}
if (x < w - 1 && z
> 0) {
sum +=
right.cross(out).normalize();
}
normals2[z][x] =
sum;
}
//Returns the normal at (x, z)

Vec3f getNormal(int x, int z) {
if (!computedNormals) {
computeNormals();
}
return normals[z][x];
}
sum +=
out.cross(left).normalize();
//Smooth out the normals

const float FALLOUT_RATIO = 0.5f;
for (int z = 0; z < l; z++) {
for (int x = 0; x < w; x++)
normals2[z][x];
Vec3f sum =
if (x > 0) {
sum +=
normals2[z][x - 1] * FALLOUT_RATIO;
}
if (x < w - 1) {
sum +=
normals2[z][x + 1] * FALLOUT_RATIO;
}
if (z > 0) {
sum +=
normals2[z - 1][x] * FALLOUT_RATIO;
}
if (z < l - 1) {
sum +=
normals2[z + 1][x] * FALLOUT_RATIO;
}
(sum.magnitude() == 0) {
if
}
}
if (x > 0 && z >

0) {
sum =
Vec3f(0.0f, 1.0f, 0.0f);
};
//end class
void initRendering() {
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
glShadeModel(GL_SMOOTH);
}
//Loads a terrain from a heightmap. The heights of
the terrain range from
//-height / 2 to height / 2.
//load terain di procedure inisialisasi
Terrain* loadTerrain(const char* filename, float
height) {
Image* image = loadBMP(filename);
Terrain* t = new Terrain(image->width,
image->height);
for (int y = 0; y < image->height; y++) {
for (int x = 0; x < image->width;
x++) {
unsigned char color =
(unsigned char) image->pixels[3 * (y
* image>width + x)];
float h = height * ((color /
255.0f) - 0.5f);
t->setHeight(x, y, h);
}
}
delete image;
t->computeNormals();
return t;
float _angle = 60.0f;

//buat tipe data terain
Terrain* _terrain;
Terrain* _terrainTanah;
Terrain* _terrainAir;
const GLfloat
1.0f };
const GLfloat
1.0f };
const GLfloat
};
const GLfloat
1.0f };
light_ambient[] = { 0.3f, 0.3f, 0.3f,

light_diffuse[] = { 0.7f, 0.7f, 0.7f,
light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f
light_position[] = { 1.0f, 1.0f, 1.0f,
const GLfloat light_ambient2[] = { 0.3f, 0.3f, 0.3f,

0.0f };
const GLfloat light_diffuse2[] = { 0.3f, 0.3f, 0.3f,
0.0f };
const GLfloat
1.0f };
const GLfloat
const GLfloat
1.0f };
const GLfloat
mat_ambient[] = { 0.8f, 0.8f, 0.8f,

mat_diffuse[] = { 0.8f, 0.8f, 0.8f, 1.0f };
mat_specular[] = { 1.0f, 1.0f, 1.0f,
high_shininess[] = { 100.0f };
void cleanup() {
delete _terrain;
delete _terrainTanah;
}
//untuk di display
void drawSceneTanah(Terrain *terrain, GLfloat r,
GLfloat g, GLfloat b) {
//
glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT);
/*
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -10.0f);
glRotatef(30.0f, 1.0f, 0.0f, 0.0f);
glRotatef(-_angle, 0.0f, 1.0f, 0.0f);
1.0f};
>getNormal(x, z);
normal[1], normal[2]);
>getHeight(x, z), z);
>getNormal(x, z + 1);
normal[1], normal[2]);
GLfloat lightPos0[] = {-0.5f, 0.8f, 0.1f,
//Makes OpenGL draw a triangle at

every three consecutive vertices
glBegin(GL_TRIANGLE_STRIP);
for (int x = 0; x < terrain->width();
x++) {
glNormal3f(normal[0],
//Tiang Atas
glPushMatrix();
glColor3f(0.5f, 0.5f, 0.5f);
glTranslatef(0.0,5.3,-2.0);
glScaled(0.5, 1.0 , 7.5);
glutSolidCube(0.5f);
glPopMatrix();
//Lampu
glPushMatrix();
glTranslatef(0.0, 4.7, -3.7);
glColor3f(1, 1, 1);
glScalef(0.8,0.8,1.5);
glutSolidSphere(0.5,70,20);
glPopMatrix();
0.0f};
normal = terrain-
//MARKA JALAN
void marka()
{
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f);
glScaled(10.5, 0.1 , 2.5);
glPopMatrix();
}
//LAMPU
void lampuJalan()
{
//Tiang Tegak
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glScalef(0.04,1.7,0.05);
glPopMatrix();
GLfloat lightColor0[] = {0.6f, 0.6f, 0.6f,
glColor3f(r, g, b);
for (int z = 0; z < terrain->length() - 1; z++)
glVertex3f(x, terrain-
GLfloat ambientColor[] = {0.4f, 0.4f, 0.4f,
glLightfv(GL_LIGHT0, GL_DIFFUSE,
lightColor0);
glLightfv(GL_LIGHT0, GL_POSITION,
lightPos0);
*/
float scale = 150.0f / max(terrain->width() 1, terrain->length() - 1);
glScalef(scale, scale, scale);
glTranslatef(-(float) (terrain->width() - 1) / 2,
0.0f,
-(float) (terrain->length() 1) / 2);
glNormal3f(normal[0],
glVertex3f(x, terrain>getHeight(x, z + 1), z + 1);

}
glEnd();
}
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,
ambientColor);
1.0f};
Vec3f normal = terrain-
}
void lampuJalan2()
{
//Tiang Tegak
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glScalef(0.04,1.7,0.05);
glPopMatrix();
//Tiang Atas
glPushMatrix();
glColor3f(0.5f, 0.5f, 0.5f);
glTranslatef(0.0,5.3,2.0);
glScaled(0.5, 1.0 , 7.5);
glPopMatrix();
glPopMatrix();
//Lampu
glPushMatrix();
glTranslatef(0.0, 4.7, 3.7);
glColor3f(1, 1, 1);
glScalef(0.8,0.8,1.5);
glPopMatrix();
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glTranslatef(-26.0f, 0.0f, 0.0f);
glScaled(1.5, 10.0 , 0.5);
glPopMatrix();
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(1.5, 10.0 , 0.5);
glPopMatrix();
}
void lampu()
{
//Tiang
glPushMatrix();
glColor4f(0.5, 0.5, 0.5, 0.0);
glScalef(0.02,0.3,0.04);
glPopMatrix();
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(1.5, 10.0 , 0.5);
glPopMatrix();
//Lampu
glPushMatrix();
glTranslatef(0.0f, 2.0f, 0.0f);
glColor3f(1, 1, 1);
glScalef(2.0,2.0,3.0);
glPopMatrix();
//PAGAR
void pagar()
{
//Pagar Atas
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(297.0, 1.0 , 0.5);
glPopMatrix();
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(1.5, 10.0 , 0.5);
glPopMatrix();
}
//LANTAI BANGUNAN
void bangunan()
{
//Dasar
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScalef(4.0,0.02,4.5);
glPopMatrix();
//Pagar Bawah
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(297.0, 1.0 , 0.5);
glPopMatrix();
//Dasar2
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glScalef(1.5,0.02,1.9);
glPopMatrix();
//Pagar Tegak
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(1.5, 10.0 , 0.5);
glPopMatrix();
//Trotoar kanan
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glScalef(0.05,0.1,1.9);
glPopMatrix();
//Trotoar Kiri
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glTranslatef(-7.0, 0.0, 28.5);
glScalef(0.05,0.1,1.9);
glPopMatrix();
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(1.5, 10.0 , 0.5);
glPopMatrix();
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(1.5, 10.0 , 0.5);
//Plang
//Tiang kanan
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);

glScaled(1.0, 20.0 , 0.5);
glPopMatrix();
//Tiang kiri
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScaled(1.0, 20.0 , 0.5);
glPopMatrix();
//Plang
glPushMatrix();
glColor4f(0.8f, 0.5f, 0.0f, 1.0f);
glScaled(30.0, 5.0 , 0.5);
glPopMatrix();
}
//BANGUN JAM GADANG
void lantai1()
{
glPushMatrix();
glTranslatef(0.0f, -3.3f, 0.0f);
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(1.8,1.4,1.8);
glPopMatrix();
}
void jendelalantai1()
{
glPushMatrix();
glTranslatef(-1.5f, -3.6f, 0.0f);
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.8,1.3,3.7);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.8,1.3,3.7);
glPopMatrix();
}
void tangga()
{
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(1.795,0.09,1.795);
glPopMatrix();
//tangga1
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.7,0.08,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);

glScalef(0.5,0.08,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.3,0.08,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.3,0.08,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.3,0.08,1.795);
glPopMatrix();
//tangga kiri & kanan
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.55,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.3,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.1,0.8,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.55,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.45,0.1,1.795);
glPopMatrix();
}
void pagartangga()
{
//tiang pagar bawah
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
//tiang pagar tengah
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);

glScalef(0.2,0.2,7.6);
glPopMatrix();
glPushMatrix();
glRotatef(32,1,0,0);
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,0.2,7.6);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,0.2,7.6);
glPopMatrix();
//tiang pagar atas

glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
//pegangan pagar atas

glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,0.2,4.5);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,0.2,4.5);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
//pegangan tangga tengah

glPushMatrix();
glRotatef(-23,0,0,1);
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(2.8,0.2,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,1.85,0.2);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(1.5,1.85,0.2);
glPopMatrix();
//pegangan pagar
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.2,0.2,7.6);
glPopMatrix();
glPushMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(2.8,0.2,0.2);
glPopMatrix();
}
void lantai2()
{
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(1.2,1.8,1.2);
glPopMatrix();
}
{
//depan belakang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.4,1.85,2.47);
glPopMatrix();
glPopMatrix();
}
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.4,1.85,2.47);
glPopMatrix();
void pagarlantai2()
{
//depan kiri kanan
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.4,1.85,2.47);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
//relief tiang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.18,1.9,2.45);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.18,1.9,2.45);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.45,1.9,0.18);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.45,1.9,0.18);
glutWireCube(3.0f);
glPopMatrix();
//kiri kanan
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.47,1.85,0.4);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.47,1.85,0.4);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.47,1.85,0.4);
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(4.3,0.3,0.4);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(4.3,0.3,0.4);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
//kiri
glPushMatrix();
glTranslatef(-5.2f, 1.3f, -5.2f);
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.4,0.3,10.5);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
//kanan
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);

glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.4,0.3,10.5);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(10.5,0.3,0.4);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
//belakang
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.3,1.85,0.3);
glPopMatrix();
}
void lantai3()
{
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(1.1,1.5,1.1);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(1.28,0.08,1.28);
glPopMatrix();
}
//depan belakang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.35,1.8,2.25);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.35,1.8,2.25);
glPopMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);

glScalef(2.25,1.8,0.35);
glPopMatrix();
}
void lantai4()
{
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(1.0,1.2,1.0);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(1.17,0.08,1.17);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.35,1.8,2.25);
glPopMatrix();
//relief tiang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.19,2.0,2.25);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.19,2.0,2.25);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.25,2.0,0.19);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.25,2.0,0.19);
glutWireCube(3.0f);
glPopMatrix();
//kiri kanan
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.25,1.8,0.35);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.25,1.8,0.35);
glPopMatrix();
glPushMatrix();
}
{
//depan belakang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.5,1.4,2.08);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.5,1.4,2.08);
glPopMatrix();
//relief tiang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.18,1.9,2.08);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.18,1.9,2.08);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.08,1.9,0.18);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.08,1.9,0.18);
glutWireCube(3.0f);
glPopMatrix();
//kiri kanan
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.08,1.4,0.5);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.38,0.5,1.8);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(1.8,0.5,0.38);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(2.08,1.4,0.5);
glPopMatrix();
void lantai5()
{
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.89,1.0,0.89);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(1.07,0.08,1.07);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(1.8,0.5,0.38);
glutWireCube(3.0f);
glPopMatrix();
void jam()
{
//depan belakang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(1.4,1.4,27.4);
glutWireTorus(0.1f, 0.8f, 12.0f, 12.0f);
glPopMatrix();
//relief tiang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.1,1.5,1.8);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glRotatef(90, 5, 260, 0);
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(1.4,1.4,27.4);
glutWireTorus(0.1f, 0.8f, 12.0f, 12.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.1,1.5,1.8);
glutWireCube(3.0f);
glPopMatrix();
//jarum jam depan

glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.01,0.3,0.1);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(1.8,1.5,0.1);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(1.8,1.5,0.1);
glutWireCube(3.0f);
glPopMatrix();
//relief dinding
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.38,0.5,1.8);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.3,0.01,0.1);
glutWireCube(3.0f);
glPopMatrix();
//jarum jam belakang
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.01,0.3,0.1);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.3,0.01,0.1);
glutWireCube(3.0f);
glPopMatrix();
//jarum jam kanan
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.1,0.3,0.01);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.1,0.01,0.3);
glutWireCube(3.0f);
glPopMatrix();
//jarum jam kiri
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.1,0.3,0.01);
glutWireCube(3.0f);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 0.0);
glScalef(0.1,0.01,0.3);
glutWireCube(3.0f);
glPopMatrix();
}
//
void lantaiatas()
{
glPushMatrix();
glColor4f(2.0, 2.0, 2.0, 2.0);
glScalef(0.7,0.8,0.7);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(1.2,0.08,1.2);
glPopMatrix();
//pagar depan
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(2.4,0.05,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(2.4,0.05,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
//pagar belakang
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(2.4,0.05,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(2.4,0.05,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
//pagar kanan
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glVertex3f(0.0f, 1.0f, 0.0f);
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.05,2.4);
glPopMatrix();
glVertex3f(-3.5f, -1.0f, 3.5f);

glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.05,2.4);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
//pagar kiri
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.05,2.4);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.05,2.4);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.05,0.5,0.05);
glPopMatrix();
}
void atap()
{
glPushMatrix();
//glRotatef(-60.0f,1.0f,10.0f,10.0f);
glColor4f(0.8, 0.8, 0.8, 0.8);
//glScalef(1.0,1.0,3.0);
glBegin(GL_QUADS);
glVertex3f(-3.5f, -1.0f, -3.5f);
glVertex3f(0.0f, 6.0f, -3.3f);
glVertex3f(0.0f, 1.8f, -2.3f);
glVertex3f(3.5f,
glVertex3f(0.0f,
glVertex3f(0.0f,
glVertex3f(0.0f,
-1.0f, -3.5f);
6.0f, -3.3f);
1.8f, -2.3f);
1.0f, 0.0f);
glVertex3f(3.5f,
glVertex3f(0.0f,
glVertex3f(0.0f,
glVertex3f(0.0f,
-1.0f, 3.5f);
6.0f, 3.3f);
1.8f, 2.3f);
1.0f, 0.0f);
glVertex3f(3.5f,
glVertex3f(3.3f,
glVertex3f(2.3f,
glVertex3f(0.0f,
-1.0f, -3.5f);
6.0f, 0.0f);
1.8f, 0.0f);
1.0f, 0.0f);
glVertex3f(3.5f,
glVertex3f(3.3f,
glVertex3f(2.3f,
glVertex3f(0.0f,
-1.0f, 3.5f);
6.0f, 0.0f);
1.8f, 0.0f);
1.0f, 0.0f);
glVertex3f(-3.5f, -1.0f, 3.5f);

glVertex3f(-3.3f, 6.0f, 0.0f);
glVertex3f(-3.5f, -1.0f, -3.5f);
glEnd();
glPopMatrix();
}
//===============================
============BATAS JAM
GADANG==========================
===========================//
//POHON
void pohon()
{
//Batang Cemara
glPushMatrix();
glColor3f(0.8f, 0.4f, 0.1f);
glScaled(1.1,7,1);
glPopMatrix();
//Daun Bawah
glPushMatrix();
glColor3f(0.5f, 0.7f, 0.1f);
glRotatef(230, 1.5, 2, 2);
glScaled(2,2,3);
glutSolidCone(1.6,1,20,30);
glPopMatrix();
//Daun Tengah
glPushMatrix();
glColor3f(0.5f, 0.7f, 0.1f);
glRotatef(230, 1.5, 2, 2);
glScaled(2,2,3);
glPopMatrix();
glColor3f(0.0f, 0.4f, 0.4f);

glRotatef(90, -2.0, 0.0, 0.0);
glScaled(0.15 ,5 ,0.15);
glPopMatrix();
//Daun Atas
glPushMatrix();
glColor3f(0.5f, 0.7f, 0.1f);
glRotatef(230, 1.5, 2, 2);
glScaled(2,2,3);
glPopMatrix();
}
//POHON TAMAN
void pohontaman()
{
//Batang Pohon Tengah
glPushMatrix();
glColor3f(0.5f, 0.5f, 0.5f);
glScaled(0.3 , 7.5, 0.3);
glPopMatrix();
//Lantai
glPushMatrix();
glColor3f(1.0, 1.0, 1.0);
//glTranslatef(0.0, 3.6, 0.0);
glScaled(0.7, 0.09, 0.7);
glPopMatrix();
//Batang Pohon Kiri
glPushMatrix();
glColor3f(0.0f, 1.0f, 0.0f);
glRotatef(45, 0.0, 0.0, 2.0);
glScaled(0.15 ,5 ,0.15);
glPopMatrix();
//Batang Pohon Kanan
glPushMatrix();
glColor3f(0.8f, 0.8f, 0.0f);
glRotatef(45, 0.0, 0.0, -2.0);
glScaled(0.15 ,5 ,0.15);
glPopMatrix();
//Batang Pohon Depan
glPushMatrix();
glColor3f(1.0f, 0.0f, 0.0f);
glRotatef(45, 2.0, 0.0, 0.0);
glScaled(0.15 ,5 ,0.15);
glPopMatrix();
//Batang Pohon Belakang
glPushMatrix();
glColor3f(0.0f, 0.0f, 1.0f);
glRotatef(45, -2.0, 0.0, 0.0);
glScaled(0.15 ,5 ,0.15);
glPopMatrix();
//Batang Pohon Lurus
glPushMatrix();
//Batang Pohon Lurus

glPushMatrix();
glColor3f(0.8f, 0.0f, 0.8f);
glRotatef(90, 0.0, 0.0, 2.0);
glScaled(0.15 ,5 ,0.15);
glPopMatrix();
//BANGKU TAMAN
void bangkutaman1()
{
//bangku taman depan
glPushMatrix();
glColor3f(0.8f, 0.4f, 0.1f);
glScalef(7.3, 1.5, 2.3);
glPopMatrix();
glPushMatrix();
glColor3f(0.8f, 0.4f, 0.1f);
glScalef(7.3, 1.5, 0.3);
glPopMatrix();
}
void bangkutaman2()
{
//bangku taman belakang
glPushMatrix();
glTranslatef(-11.5, 0.0, -2.0);
glColor3f(0.8f, 0.4f, 0.1f);
glScalef(7.3, 1.5, 2.3);
glPopMatrix();
glPushMatrix();
glTranslatef(-11.5, 1.0, -3.2);
glColor3f(0.8f, 0.4f, 0.1f);
//glRotatef(-8.5f, 1.0f, 0.0f, 0.0f);
glScalef(7.3, 1.5, 0.3);
glPopMatrix();
void bangkutaman3()
{
glPushMatrix();
glTranslatef(-11.5, 0.0, -0.0);
glColor3f(0.8f, 0.4f, 0.1f);
glScalef(2.3, 1.5, 7.3);
glPopMatrix();
glPushMatrix();
glTranslatef(-10.5, 1.0, -0.0);
glColor3f(0.8f, 0.4f, 0.1f);
glScalef(0.3, 1.5, 7.3);
glPopMatrix();
}
void bangkutaman4()
{
glPushMatrix();
glTranslatef(-11.5, 0.0, -0.0);
glColor3f(0.8f, 0.4f, 0.1f);
glScalef(2.3, 1.5, 7.3);
glPopMatrix();
glPushMatrix();
glTranslatef(-12.5, 1.0, -0.0);
glColor3f(0.8f, 0.4f, 0.1f);
glScalef(0.3, 1.5, 7.3);
glPopMatrix();
}
//JALUR TAMAN
void jalur()
{
//Dasar
glPushMatrix();
glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glScalef(3.0,0.02,4.5);
glPopMatrix();
glPushMatrix();
glTranslatef(20.4, .0, -35.0);
//Dasar2
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glScalef(1.7, 0.02, 1.9);
glPopMatrix();
//Trotoar kanan
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glScalef(1.6,0.1, 0.05);
glPopMatrix();
//Trotoar Kiri
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glScalef(1.6,0.1, 0.05);
glPopMatrix();
glPopMatrix();
}
//KINCIR
void kincir()
{ /*//Lantai
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glTranslatef(0.0, -15.0, 0.0);
glScalef(4.0, 1.09, 2.5);

glPopMatrix();*/
//Atap1
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(3.0,0.09,1.5);
glPopMatrix();
//Atap2
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glTranslatef(0.0, -7.0, 0.0);
glScalef(3.0,0.09,1.5);
glPopMatrix();
//Atap3
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(3.0,0.09,1.5);
glPopMatrix();
//Atap4
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(3.0,0.09,1.5);
glPopMatrix();
//Atap5
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(3.0,0.09,1.5);
glPopMatrix();
//Generator
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(2.0,0.59,1.0);
glPopMatrix();
/*//Listrik Bawah
glPushMatrix();
glColor4f(1.8, 0.8, 0.8, 0.8);
glScalef(0.1,0.1,0.1);
glutSolidSphere(5, 20, 30);
glPopMatrix();
//Listrik Tengah
glPushMatrix();
glColor4f(1.8, 0.8, 0.8, 0.8);
glScalef(0.1,0.1,0.1);
glPopMatrix();
//Listrik Atas
glPushMatrix();
glColor4f(1.8, 0.8, 0.8, 0.8);
glScalef(0.1,0.1,0.1);
glPopMatrix();
*/
glScalef(0.15,7.0,0.25);
glPopMatrix();
//Kipas
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 1.0);
glScalef(2.15, 2.0, 0.55);
glRotatef(sudutk, 0.0f, 0.0f, 1.0f);
glutWireTorus(1, 5, 10, 15);
glPopMatrix();
//Pemutar Depan
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.2,0.09,1.0);
glPopMatrix();
//Bulatan
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.2,0.2,0.2);
glPopMatrix();
//Pemutar Belakang
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glTranslatef(0.0, 22.0, -10.0);
glScalef(0.2,0.59,0.5);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 1.0);
glScalef(1.15, 1.0, 0.55);
glPopMatrix();
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 1.0);
glScalef(0.55, 0.5, 0.55);
glPopMatrix();
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.2,0.19,1.7);
glPopMatrix();
glPushMatrix();
glColor4f(1.0, 1.8, 0.8, 0.8);
glTranslatef(0.0, 22.0, -10.0);
glScalef(0.8, 0.1, 0.5);
glPopMatrix();
//Tiang Kiri Depan
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.15,7.0,0.25);
glPopMatrix();
//Tiang Kiri Belakang
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glTranslatef(-7.5, 0.0, -2.5);
glScalef(0.15,7.0,0.25);
glPopMatrix();
//Tiang Kanan Depan
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glScalef(0.15,7.0,0.25);
glPopMatrix();
//Tiang Kanan Belakang
glPushMatrix();
glColor4f(0.8, 0.8, 0.8, 0.8);
glPushMatrix();
glColor4f(0.0, 0.0, 0.0, 1.0);
glScalef(3.15, 3.0, 0.55);
glPopMatrix();
}
//PUTAR KIPAS
void putar(int value)
{
sudutk += 5.0f;
if (sudutk > 360){
sudutk -= 360;
}
glutPostRedisplay();
glutTimerFunc(25, putar, 0);
//BUS
void bus()
{
//Bodi
glColor3f(1.0, 0.8, 0.0);
glPushMatrix();
//glRotatef(sudutk, 0.0, 0.0, 1.0);
glScalef(4.0, 1.0, 1.5);
glPopMatrix();
//Kaca Belakang
glColor3f(0.0, 0.0, 1.0);
glPushMatrix();
glScalef(0.05, 0.5, 1.2);
glPopMatrix();
//Lampu Rem
glColor3f(1.0, 0.0, 0.0);
glPushMatrix();
glTranslatef(-12.1, 2.0, -3.5);
glScalef(0.02, 0.19, 0.08);
glPopMatrix();
glColor3f(1.0, 0.0, 0.0);
glPushMatrix();
glScalef(0.02, 0.19, 0.08);
glPopMatrix();
//Lampu Depan
glColor3f(1.0, 1.0, 1.0);
glPushMatrix();
glScalef(0.05, 0.02, 0.1);
glPopMatrix();
glColor3f(1.0, 1.0, 1.0);
glPushMatrix();
glScalef(0.05, 0.02, 0.1);
glPopMatrix();
//Kaca Depan
glColor3f(0.0, 0.0, 1.0);
glPushMatrix();
glScalef(0.05, 0.5, 1.2);
glPopMatrix();
//Kaca pinggir
glColor3f(0.0, 0.0, 1.0);
glPushMatrix();
glScalef(3.3, 0.5, 0.2);
glPopMatrix();
glColor3f(0.0, 0.0, 1.0);
glPushMatrix();
glTranslatef(-1.5, 5.0, -4.0);
glScalef(3.3, 0.5, 0.2);
glPopMatrix();
//Pintu Kanan
glColor3f(0.5, 0.5, 0.5);
glPushMatrix();
glScalef(0.15, 0.8, 0.2);
glPopMatrix();
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glScalef(0.25, 0.4, 0.2);
glPopMatrix();
//Pintu Kiri
glColor3f(0.5, 0.5, 0.5);
glPushMatrix();
glScalef(0.15, 0.8, 0.2);
glPopMatrix();
glPushMatrix();
glColor3f(0.5, 0.5, 0.5);
glScalef(0.25, 0.4, 0.2);
glPopMatrix();
//Ban Belakang
glPushMatrix();
glColor3f(1.0, 1.0, 1.0);
glScalef(0.35, 0.35, 0.25);
glutSolidTorus(2, 3, 20, 30);
glPopMatrix();
//Velg
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glScalef(0.5, 0.5, 0.5);
glPopMatrix();
glPushMatrix();
glColor3f(1.0, 1.0, 1.0);
glScalef(0.35, 0.35, 0.25);
glTranslatef(25.0, 4.5, -19.3);
glPopMatrix();
//Velg
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glScalef(0.5, 0.5, 0.5);
glPopMatrix();
//Ban Depan
glPushMatrix();
glColor3f(1.0, 1.0, 1.0);
glScalef(0.35, 0.35, 0.25);
glTranslatef(-25.0, 4.5, -19.3);
glPopMatrix();
//Velg
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glScalef(0.5, 0.5, 0.5);
glPopMatrix();
glPushMatrix();
glColor3f(1.0, 1.0, 1.0);
glScalef(0.35, 0.35, 0.25);
glTranslatef(-25.0, 4.5, 19.3);
glPopMatrix();
//Velg
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glScalef(0.5, 0.5, 0.5);
glTranslatef(-17.5, 2.5, -8.0);

glPopMatrix();
}
unsigned int LoadTextureFromBmpFile(char
*filename);
void display(void) {
glClearStencil(0); //clear the stencil buffer
glClearDepth(1.0f);
glClearColor(0.0, 0.6, 0.8, 1);
glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT |
GL_STENCIL_BUFFER_BIT); //clear the buffers
glLoadIdentity();
gluLookAt(viewx-110, viewy+20, viewz+20,
0.0, 10.0, 5.0, 0.0, 1.0, 0.0);
glPushMatrix();
//glBindTexture(GL_TEXTURE_3D,
texture[0]);
drawSceneTanah(_terrain, 0.0f, 0.5f, 0.0f);
glPopMatrix();
glPushMatrix();
texture[0]);
drawSceneTanah(_terrainTanah, 0.0f, 0.0f,
0.0f);
glPopMatrix();
glPushMatrix();
texture[0]);
drawSceneTanah(_terrainAir, 0.0f, 0.2f,
0.5f);
glPopMatrix();
//===============================
================================
==========================//
//===============================
=====MULAI
OBJEK============================
===============//
//===============================
================================
==========================//
//LAMPU
//kiri depan
glPushMatrix();
lampu();
glPopMatrix();
//kiri belakang
glPushMatrix();
lampu();
glPopMatrix();
//kanan depan
glPushMatrix();
lampu();
glPopMatrix();
//kanan belakang
glPushMatrix();
lampu();
glPopMatrix();
//LAMPU JALAN
for (int i = -2; i < 3; i++)
{
glPushMatrix();
glTranslatef(i*35, 5, 38);
lampuJalan();
glPopMatrix();
}
for (int i = -2; i < 3; i++)
{
glPushMatrix();
lampuJalan2();
glPopMatrix();
}
//BANGUNAN
glPushMatrix();
glTranslatef(18.0,-0.5,-25.0);
bangunan();
glPopMatrix();
//JALUR TAMAN
glPushMatrix();
glTranslatef(-28.0,-0.5,-25.0);
jalur();
glPopMatrix();
//JAM GADANG
glPushMatrix();
glTranslatef(18.0, 9.0,-35.0);
glScaled(1.7, 1.7, 1.7);
lantai1();
jendelalantai1();
tangga();
pagartangga();
lantai2();
jendelalantai2();
pagarlantai2();
lantai3();
jendelalantai3();
lantai4();
jendelalantai4();
lantai5();
jam();
lantaiatas();
atap();
glPopMatrix();
//POHON
for (int i = -5; i < 5; i++)
{
glPushMatrix();
pohon();
glPopMatrix();
}
glPushMatrix();
glTranslatef(75.0,1,54.0);
pohon();
glPopMatrix();
//Pohon belakang
glPushMatrix();
glTranslatef(65.0,7,-35.0);
pohon();
glPopMatrix();
//Pohon Pinggir
glPushMatrix();
glTranslatef(-50, 1.2, -45);
pohon();
glPopMatrix();
//Pohon Pinggir
glPushMatrix();
glTranslatef(-55, 1.2, -15);
pohon();
glPopMatrix();
//Pohon Pinggir
glPushMatrix();
glTranslatef(-62, 1.2, 1.7);
pohon();
glPopMatrix();
//Pohon Taman Depan
glPushMatrix();
glColor4f(0.0f, 0.8f, 0.0f, 1.0f);
glScalef(3.0, 3.0, 3.0);
glTranslatef(-5.5, -0.1, -1.7);
pohontaman();
glPopMatrix();
//Pohon Taman Depan
glPushMatrix();
glColor4f(0.0f, 0.8f, 0.0f, 1.0f);
glScalef(3.0, 3.0, 3.0);
glTranslatef(-13.9, -0.1, -1.7);
pohontaman();
glPopMatrix();
//Pohon Taman Belakang
glPushMatrix();
glColor4f(0.0f, 0.8f, 0.0f, 1.0f);
glScalef(3.0, 3.0, 3.0);
glTranslatef(-5.5, -0.1, -14.9);
pohontaman();
glPopMatrix();
//Pohon Taman Belakang
glPushMatrix();
glColor4f(0.0f, 0.8f, 0.0f, 1.0f);
glScalef(3.0, 3.0, 3.0);
glTranslatef(-13.9, -0.1, -14.9);
pohontaman();
glPopMatrix();
//Pohon Taman Tengah
glPushMatrix();
glColor4f(0.0f, 0.8f, 0.0f, 1.0f);
glScalef(3.0, 3.0, 3.0);
glTranslatef(-9.5, -0.1, -8.9);
pohontaman();
glPopMatrix();
//Bangku Taman depan kiri
glPushMatrix();
glScalef(1.0f,1.0f,1.0f);
glTranslatef(-27.0,-0.1,-8.9);
bangkutaman1();
glPopMatrix();
//Bangku Taman depan kanan
glPushMatrix();
bangkutaman1();
glPopMatrix();
//Bangku Taman belakang kiri
glPushMatrix();
glTranslatef(-27.0,-0.1,-41.0);
bangkutaman2();
glPopMatrix();
//Bangku Taman belakang kanan
glPushMatrix();
bangkutaman2();
glPopMatrix();
//Bangku Taman kanan belakang
glPushMatrix();
bangkutaman3();
glPopMatrix();
//Bangku Taman kanan depan
glPushMatrix();
bangkutaman3();
glPopMatrix();
//Bangku Taman kiri depan
glPushMatrix();
bangkutaman4();
glPopMatrix();
//Bangku Taman kiri belakang
glPushMatrix();
glTranslatef(-29.5,-0.1,-40.5);
bangkutaman4();
glPopMatrix();
//MARKA JALAN
for (int i = -3; i < 4; i++)
{
glPushMatrix();
glTranslatef(i*22, 0.0, 25);
marka();
glPopMatrix();
}
//PAGAR
glPushMatrix();
glTranslatef(27, 0.0, 42);
pagar();
glPopMatrix();
//BUS
glPushMatrix();
glTranslatef(a-27, b-0.0, c+18);

bus();
glPopMatrix();
//KINCIR
glPushMatrix();
glScalef(0.5, 0.5, 0.5);
glTranslatef(124.0, 20.0,-63.0);
glRotatef(45, 0.0, -1.0, 0.0);
glPushMatrix();
glTranslatef(-20.0,-0.5,-25.0);
kincir();
glPopMatrix();
glPopMatrix();
glutSwapBuffers();
glFlush();
rot++;
angle++;
}
void init(void) {
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
glDepthFunc(GL_LEQUAL);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,
GL_NICEST);
glEnable(GL_CULL_FACE);
_terrain = loadTerrain("Terrain.bmp", 20);
_terrainTanah = loadTerrain("Jalan.bmp",
20);
_terrainAir =
loadTerrain("heightmapAir.bmp", 20);
//binding texture
}
static void kibor(int key, int x, int y) {
switch (key) {
case GLUT_KEY_HOME:
viewy++;
break;
case GLUT_KEY_END:
viewy--;
break;
case GLUT_KEY_UP:
viewz--;
break;
case GLUT_KEY_DOWN:
viewz++;
break;
case GLUT_KEY_RIGHT:
viewx++;
break;
case GLUT_KEY_LEFT:
viewx--;
break;
/*case GLUT_KEY_F1: {
light_ambient);
light_diffuse);
glLightfv(GL_LIGHT0, GL_AMBIENT,
glMaterialfv(GL_FRONT,
GL_AMBIENT, mat_ambient);
GL_DIFFUSE, mat_diffuse);
}
;
break;
case GLUT_KEY_F2: {
glLightfv(GL_LIGHT0, GL_AMBIENT,
light_ambient2);
light_diffuse2);
GL_AMBIENT, mat_ambient);
GL_DIFFUSE, mat_diffuse);
}
;
break;*/
default:
break;
}
}
void newkeyboard(unsigned char key, int x, int y) {
/*if (key == 'd') {
spin = spin - 1;
if (spin > 360.0)
spin = spin - 360.0;
}
if (key == 'a') {
spin = spin + 1;
if (spin > 360.0)
spin = spin - 360.0;
}*/
if (key == 'q') {
viewz++;
}
if (key == 'e') {
viewz--;
}
if (key == 's') {
viewy--;
}
if (key == 'w') {
viewy++;
}
//UNTUK BUS
if (key == 'm'){
a+=-1;
d+=1;
b=0;
c=0;
}
else if (key=='n'){
d+=-1;
a+=1;
b=0;
c=0;
}
if (key == 27){ //ESC
exit(0);
}
}
void reshape(int w, int h) {

glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60, (GLfloat) w / (GLfloat) h,
0.1, 1000.0);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE |
GLUT_RGBA | GLUT_STENCIL | GLUT_DEPTH); //add a
stencil buffer to the window
glutInitWindowSize(800, 600);
glutInitWindowPosition(100, 100);
glutCreateWindow("Tugas Besar GrafkomJam Gadang");
init();
initRendering();
glutDisplayFunc(display);
glutIdleFunc(display);
glutReshapeFunc(reshape);
glutSpecialFunc(kibor);
glutKeyboardFunc(newkeyboard);
glLightfv(GL_LIGHT0, GL_SPECULAR,
light_specular);
glLightfv(GL_LIGHT0, GL_POSITION,
light_position);
glMaterialfv(GL_FRONT, GL_SPECULAR,
mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS,
high_shininess);
glColorMaterial(GL_FRONT, GL_DIFFUSE);
glutTimerFunc(25, putar, 0);

glutMainLoop();
return 0;

Isi Bangun Ruang Jam Gadang2

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Isi Bangun Ruang Jam Gadang2

Diunggah oleh

Hak Cipta:

Format Tersedia

TUGAS BESAR GRAFIKA KOMPUTER

BANGUN RUANG JAM GADANG 3D

JURUSAN TEKNIK INFORMATIKA

Assalaamualaikum wr. wb,

Bandung, Juli 2012

adalah sebagai berikut :

Bagaimana membuat bangun ruang 3D Jam Gadang.

Maksud dan Tujuan

Pengertian Grafika Komputer

Gambar 1Teapot hasil rendering

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

Elemen Dasar Grafika

Gradate polygon adalah sebuah polygon yang bagian dalamnya memiliki

Perbedaan Grafik 2D dan 3D

tampilan gambarnya. Gambar 2D tampil flat adn frame tampilannya cenderung

Disamping dinyatakan dalam vektor kolom, matriks transformasi dapat

Dengan demikian skala dapat juga dituliskan

dengan melakukan substitusi, diperoleh rumus transformasi untuk rotasi suatu

berasal dari sumber cahaya. Spectrum warna memiliki panjang gelombang

Gambar 2 Pembagian warna

Warna dapat didefinisikan secara obyektif/fisik sebagai sifat cahaya yang

Value, adalah dimensi kedua atau mengenai terang gelapnya warna.

berhubungan dengan cerah atau suramnya warna.

Dimensi point, biasanya diatas suatu permukaan.

Mengerti persepsi dari cahaya (warna)

Membuat sebuah solusi untuk merepresentasikan dan menghasilkan warna

Mengerti akan pengaruh cahaya dan objek

Bayangan akan muncul saat cahaya jatuh menyinari suatu objek.

menonaktifkan Pencampuran dan menggunakan konstan GL_ONE (sumber) dan

digabungkan dengan yang sudah disimpan dalam framebuffer (tujuan).Pendapat

Langkah-langkah dalam memulai mapping sebuah tekstur yakni dengan

Mendefinisikan tekstur image dari sebuah array teksel (element tekstur )

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

fungsi matematik tertentu).

b) Mendefinisikan gambar sebagai sebuah tekstur

target: tipe dari teksture, e.g. GL_TEXTURE_2D

texels: pointer ke array texel

c) Mengubah gambar tekstur :

OpenGL meminta dimensi tekstur untuk menjadi dasar dari 2

adalah bahasa yang dapat dijalankan

dimanapun dan di sembarang platform apapun, diberagam lingkungan : internet,

Banyak memiliki operator untuk mengolah / memanipulasi data.

Bahasa C termasuk sebagai bahasa yang terstruktur sehingga program dapat

lebih mudah dipahami atau dikembangkan.

Kecepatan eksekusi tinggi.

Mengenal data pointer.

Sedangkan kelemahan dari bahasa C adalah :

Banyaknya operator atau cara penulisan program kadang menimbulkan

kebingungan para pemakainya.

Perlunya ketelitian dalam penulisan program karena perintah (statement)

8. Pencahayaan menggunakan tiga sumber cahaya sehingga tingkat kecerahan

Tampilan Awal Program Bangun Ruang Jam Gadang

Tampilan Gedung Jam Gadang (Sumatera Barat)

Tampilan Jalan Lalu Lintas beserta bus

Tampilan Kincir angin

for (int i = 0; i < l; i++) {

//static GLfloat spin, spin2 = 0.0;

//Sets the height at (x, z) to y

//Compute the rough version of the

for (int i = 0; i < l; i++) {

//Returns the normal at (x, z)

//Smooth out the normals

if (x > 0 && z >

Vec3f(0.0f, 1.0f, 0.0f);