Friday 29 June 2012

Java merupakan bahasa pemrograman pertama yang tidak terikat pada sistem operasi tertentu. Aplikasi yang ditulis dalam bahasa Java akan dapat dijalankan di mana saja. hal ini telah menghilangkan masalah yang selama ini membuat sakit kepala bagi para pengguna komputer, dikarenakan ketidakcocokan antara sistem operasi, versi, dalam aplikasi dan sistem operasi.  

Pada awalnya, SUN Microsystem yang merupakan rumah dari Java, pada prinsipnya bergerak dibidang pengembangan bahasa yang digunakan dalam perangkat elektronik, pada tahun 1990. Namun, setiap produk memerlukan bahasanya sendiri. Dengan kata lain, untuk mengendalikan tiga perangkat, konsumen harus memiliki tiga remote kontrol dan memahami cara penggunaan untuk tiga perangkat itu. Hal ini menjadi tantangan bagi SUN microsystem untuk menjadikannya lebih maju yang merupakan latar belakang sebuah proyek baru yang bernama Java.  

Akhirnya pada musim semi di tahun 1992, terciptalah interaktif handheld tanpa tombol, tanpa keyboard, yang memiliki layar LCD seluas 5inc dan dikendalikan dengan sentuhan tangan. Gadget ini dinamakan Star7 (*7) dengan kemampuan sebagai remote conrtol, audio player, radio, TV guide dan berbagai hiburan lain. Produk ini dibuat menggunakan bahasa pemograman yang mereka namakan dengan OAK, dikarenakan di depan jendela mereka bekerja terdapat pohon OAK yang besar. Akan tetapi, produk ini tidak berkembang, dikarenakan chips yang digunakan sangat mahal untuk dibuat dan ini sangat berpengaruh pada biaya produksi.   

Betatapun bagusnya produk ini, Green team telah gagal dalam misinya karena mungkin produk tersebut tidak dapat dinikmati oleh berbagai kalangan. Walaupun begitu, Bill Joy seorang pendiri SUN melihat adanya kesempatan bagi Bahasa OAK untuk digunakan dalam penggunaan WEB agar lebih menjadi interaktif dan menarik. Dengan itu maka dibentuklah team dengan nama "The Live Oak" dan lahirlah dengan apa yang nantinya kita kenal dengan sebutan Java Applet.  Ketika nama OAK ingin dipatenkan, ternyata nama itu telah digunakan oleh produk lain (OAK Technology). Maka Pada bulan Januari di tahun 1995 nama oak resmi diganti menjadi Java.  

Kenapa bahasa ini dinamakan Java? Apa hubungannya dengan sebuah pulau di Indonesia yang bernama Jawa? Sehubungan dengan ini banyak rumor yang beredar di internet. diantaranya: Suatu saat James sedang bersantai di sebuah kedai kopi dan nama Java terlintas di fikirannya. Nama Java diambil dari beberapa orang yang berada dalam project itu: James gosling, Arthur Van hoff, Andy bechtolsheim. Namun bagaimanapun juga nama Java adalah tidak sama sekali menyangkut tentang Pulau Jawa nya Indonesia.   

Cerita yang benar atas Penamaan Java.  
Setelah diberitahu oleh pengacara bahwa nama OAK telah dipakai oleh produk lain, maka diadakan rapat untuk menentukan nama apa yang layak dipakai. Bahasa ini sangan unik, dinamis, mengasikan, revolusioner dan memiliki proses yang sangat cepat, lalu mereka bertanya-tanya nama apa yang pantas digunakan yang mencakup esensi dari berbagai kata tersebut. Salah seorang dari mereka lalu teriak "its Java". Java dalam bahasa inggris bukan hanya berarti sebagai kopi, tetapi Java memiliki makna seperti Kedai Kopi memiliki banyak jenis kopi dan semuanya nya enak. Sama seperti bahasa Java yang memiliki banyak rasa yang kesemua rasanya dapat diungkapkan dengan kata 'JAVA'

Posted on 13:21 by yusufruli

No comments

Wednesday 27 June 2012

1) Pesanlah tiket enam pekan sebelum berangkat. Calon penumpang akan mendapat tarif termurah, sekitar 6 persen di bawah tarif rata-rata, jika memesan enam pekan sebelum jadwal terbang, menurut penelitian Airline Reporting Corporation (ARC). Data dari seluruh agen perjalanan di AS pada empat tahun terakhir menunjukkan, banyak orang memesan tiket dengan tarif termurah pada 42 hari sebelum terbang. Tetapi aturan enam pekan tersebut tidak mutlak unutk mendapat tarif termurah. "Itu hanya tren," jelas Chuck Thackston, direktur manajer ARC untuk data dan analisis. “Tetapi, rata-rata, kami lihat pendekatan 42 hari sebelumnya ini berhasil." 

 2) Carilah penerbangan pagi Maskapai penerbangan hanya memberikan sedikit jatah kursi yang didiskon pada malam hari, jadi Thackston menyarankan untuk memesannya pada pagi buta. "Kalau pesan siang hari, kemungkinan kehabisan," katanya. 

 3) Waktu terbaik untuk membeli tiket: Selasa pukul 15.00 Jika Anda tidak menemukan tiket yang didiskon pada pagi hari, sebuah penelitian oleh Farecompare.com mengatakan bahwa waktu terbaik untuk membeli tiket pesawat untuk perjalanan (domestik) adalah pada Selasa pukul 15.00. Namun, George Hobia, pendiri AirfareWatchdog.com, berargumen bahwa waktu penawaran terbaik sering berubah-ubah, jadi tidak ada hari dan waktu yang spesifik untuk membeli. 

 4) Hari termurah untuk terbang: Rabu Menurut penelitian Farecompare.com baru-baru ini, hari termurah untuk terbang adalah Rabu, untuk perjalanan domestik. "Hari dengan kursi terbanyak mengindikasikan suplai yang lebih baik, lalu.... lebih banyak kursi kosong yang membutuhkan potongan harga supaya bisa terjual banyak," menurut website tersebut. Hari termurah lainnya untuk terbang adalah Selasa dan Sabtu, jelas Farecompare (Jumat dan Minggu adalah hari termahal untuk terbang). 

 5) Ambil penerbangan pertama Penerbangan paling murah adalah penerbangan pertama di pagi hari. "Ya, berarti Anda harus bangun pada jam 4 pagi," kata Rick Seaney, kepala eksekutif Farecompare.com. Penerbangan termurah selanjutnya adalah pada saat setelah makan siang dan pada saat jam makan malam. "Tentu saja, waktu termurah untuk terbang adalah penerbangan terbatas ketika mata Anda merah (masih mengantuk)," katanya. 

 6) Periksa sendiri maskapai termurah Website pembanding harga seperti Kayak.com tidak mutlak menyelesaikan tugas Anda. Beberapa maskapai bertarif murah, seperti Southwest di AS dan Ryanair di Eropa, tidak membolehkan tiket mereka dibandingkan di website pembanding harga, kata Seaney. Jadi silakan Anda memeriksanya sendiri. Dan periksa lebih teliti untuk memastikan bahwa maskapai "bertarif murah" tersebut tidak membebankan biaya ekstra yang jatuhnya akan lebih mahal, seperti biaya barang bawaan ekstra. Menurut Seaney, ini taktik yang digunakan beberapa maskapai bertarif murah. 

 7) Manfaatkan AirfareWatchdog.com AirfareWatchdog.com akan mengirimkan pemberitahuan ketika harga tiket jatuh. "Kami hanya mengirim update ketika kami rasa kami berhasil mendapat penawaran terbaik, namun website lain mungkin akan memberitahu Anda ketika tiket pesawat turun 2 dollar," kata George Hobia.  

8) Bangun jaringan dengan maskapai Jika Anda adalah anggota VIP dari program pelanggan dari maskapai atau jika Anda memiliki kartu kredit yang bekerja sama dengan maskapai tersebut, secara otomatis Anda lebih unggul dari calon pembeli lain. "Semakin maskapai mengenal Anda, semakin besar potongan harga yang akan Anda terima," jelas Barncatelli. Kartu kredit yang bekerja sama dengan maskapai menawarkan tawaran yang lebih, seperti bagasi gratis, menjadi prioritas untuk berangkat dan dalam pemilihan kursi, jadi mungkin akan sangat berguna untuk mendaftar jika Anda sering bepergian dengan satu maskapai tertentu.


Sumber: Yahoo Indonesia TRavel

Posted on 10:29 by yusufruli

No comments

Saturday 23 June 2012

Angka 7 Menurut Beberapa Negara dan Agama

Di China

Kembali ke angka 7, menurut cerita angka 7 telah mempesona sejak jaman dahulu kala. Di China angka 7 dihubungkan dengan kehidupan gadis, dimana gadis mempunyai gigi susu pada usia 7 bulan dan tanggal pada usia 7 tahun, dalam 2 x 7 tahun "roda yin" membuka ketika ia mencapai masa puber, dan pada 7 x 7 = 49 datanglah masa monopause.

Di Amerika Kuno

Kesakralan angka 7 tidak ditemui di Amerika pra-Columbian dimana bangsa Maya percaya bahwa pada 7 lapis langit dan menganggap 7 sebagai angka penjuru mata angin.

Di Agama Yahudi

Dalam agama Yahudi (agama sebelum nabi Ibrahim. AS, atau agama pada jaman sebelum Masehi) hari ke 7 menjadi hari libur suci, sehinga di sakralkan, pada hari ke 7 itu larangan bekerja di ubah menjadi perintah. Dalam kitab perjanjian lama penuh angka 7. Pada generasi ke 7 setelah Adam hiduplah Lamech (silsilah dari Adam ) selama 777 tahun dan harus membayar balas dendam selama 777 tahun (Kejadian : 4.24). Tujuh tahun langkah menuju kuil sulaiman berhubungan dengan 7 cerita tentang kuil kuil Babilonia. Lalu Merpati Nuh menghilang selama 7 hari, dan tanda tanda datangnya muncul selama 7 hari, sungai Eufrat terbagi menjadi 7 aliran.

Di Agama Kristiani

Pada abad ke -14, sejarawan Mesir al-Maqrizi mengatakan bahwa orang orang kristen di Mesir (Koptik) merayakan 7 pesta besar dan 7 pesta kecil di gereja mereka. Dimana pesta yang dilangsungkan adalah 7 untuk pesta kebahagiaan dan 7 untuk pesta kesedihan Ibu Maria yang selaras dengan irama heptadik. Oleh karena itu dalam musik renaisans terdapat sejumlah lagu dengan 7 suara, yang biasanya dipersembahkan kepada Perawan Maria, dan ada 7 karunia Roh Kudus.

Di India

Angka 7 juga banyak di jumpai di India, menurut cerita, angka 7 adalah angka penting terpenting di Weda selain angka 3. Angka 7 secara khusus berkaitan dengan Agni, dewa Api yang memiliki 7 istri, ibu atau adik serta 7 api, balok atau lidah, dan lagu lagu yang diperuntukkan baginya berjumlah 7. Dalam kepercayaan merea dewa matahari mempunyai 7 kuda penarik keretanya di langit.

Di Agama Budha

Dalam Budha (sidharta Gautama) yang baru lahir diyakini oleh pengikutnya, ketika lahir langsung menapak 7 langkah. Ia mencari keselamatan selama 7 tahun dan mengitari pohon bodhi selama 7 kali sebelum duduk bermeditasi dibawahnya. Masih menurut cerita, bahwa Syurga Budha mempunyai 7 teras, 7 karya keagamaan akan membawa manfaat bagi orang orang yang mempercayai kehidupan ini.

Di Ilmu Pengetahuan

Dalam Ilmu pengetahuan, angka 7 adalah dasar dari akumulasi angka yang tak terhitung jumlahnya, mulai dari 7 atom, 7 partikel terkecil dan seterusnya.

Di Agama Islam

Dalam islam, yang menarik dan untuk dicatat adalah, bahwa surah pertama dalam Al-Qur'an, Al-Fatihah mempunyai 7 ayat. Kalimah Syahadat dalam Laa Ilaaha ilaa Allaah, Muhammad rasul Allah terdiri dari 7 kata. Menurut Al-Qur'an Tuhan menciptakan langit dan bumi menjadi 7 lapis. Lalu Thawaf mengelilingi Ka'bah di Mekkah dilakukan sebanyak 7 kali, demikian juga dengan lari lari kecil (Sa'i) antara Shafa dan Marwah. Pada akhir haji, dekat Mina, syetan di lepar dalam 3 kali masing masing dengan 7 buah kerikil kecil yang lazim disebut (melempar jumroh).
Angka 7 juga disukai oleh kaum Sufi. Tasawuf memperbincangkan 7 Lathaaif, atau titik titik subtil pada tubuh tempat kaum Sufi memusatkan kekuatan spiritualnya.

Di Masarakat Jawa

Dalam tradisi Jawa, ada moment tertentu yang berhubungan dengan angka 7. Sebagai contoh ketika orang hamil sudah usia 7 bulan, maka diadakan selamatan dengan istilah yang disebut "Tingkepan". Lalu pada bayi yang telah berusia 7 bulan, maka ada prosesi yang dinamakan turun tanah. Persyaratan Upacara adat tertentu harus menggunakan kembang 7 rupa, mandi 7 sumur, Pesta kadang – kadang diadakan 7 hari 7 malam.. Juga tentang mitos kekayaan yang smapai 7 turunan... ( keturunan ke 8 jadi gembel… ^ _ ^ )

Benua ada 7 Allah menurunkan malaikat untuk membunuh pasukan gajah 70000 malaikat Allah menghias manusia dengan tujuh anggota badan, yaitu dua tangan, dua kaki, dua lutut, dan satu wajah. Kemudian Allah menghiasinya, dengan tujuh peribadatan, yaitu : dua tangan dengan doa, dua kaki dengan berkhidmat, dua lutut dengan duduk, dan wajah (muka) dengan sujud. 7 lapis langitrakaat shalat 17 Pintu surga dan neraka 7 Keajaiban dunia ada 727 pahala shalat berjamaah 7 lubang dalam tubuh kita1 minggu 7 hariAllah menghiasi Al-Qur'an (Kitab suci umat Islam) dengan Tujuh surat panjang, Yaitu Al-Baqarah, Ali Imran, Al-Maaidah, An-Nissa', Al 'Araaf, Al An'aam dan Al-Anfaal atau At-Taubah. Kemudian Allah menghiasinya pula dengan Tujuh ayat Ummul kitab (Al-Fatihah/Pembuka kitab). Sebagaimana Firman Allah dalam Surat AL Hijr ayat 87, "Dan Sesungguhnya Kami telah berikan kepadamu tujuh ayat yang dibaca berulang-ulang dan Al Quran yang agung."Allah menghias umur manusia dengan tujuh tingkatan / tahapan. Pada masa baru lahir dinamakan tahapan rodhi' (Menyusu), kemudian tahap fa thim (disapih), tahapan Shobiyyi (bayi), tahapan ghulam (masa kanak-kanak), kemudian tahapan syaab (pemuda/remaja), kemudian tahapan kuhul (yakni menginjak usia antara 30-50 tahun), dan menginjak tahapan Syaikh (masa tua).

Demikianlah Tuhan Yang Maha Kuasa dan Yang Maha Berkehendak telah menciptakan alam semsta dengan penuh misteri,
Seperti misteri nya angka 7.

7 pertumbuhan manusia dalam rahim:
1. Rambut
2. Kulit
3. Daging
4. Otot
5. Tulang
6. Sumsum
7. Darah

Semoga menjadi bermakna.
SALAM DAHSYAT!!!

Posted on 20:43 by yusufruli

No comments

Friday 22 June 2012




Ingin uang jutaan rupiah dengan modal Facebook? Ikuti kontes status FB yang diadakan Komisi Pemilihan Umum (KPU) Kota Pontianak berikut. Seperti apa?
       Dalam rangka sosialisasi dan Pemilihan Umum Kepada Daerah (Pilkada) Kalimantan Barat 2012, KPU Kota Pontianak menggelar lomba status Facebook.
     KPU Kota Pontianak menilai media sosial tumbuh subur dan berkembang dan memiliki manfaat yang sangat signifikan. Dan ini sangat bermanfaat bagi komunikasi.
“Facebook, Twitter, dan Youtube adalah tiga poros yang mengubah banyak model komunikasi sekaligus mengubah kehidupan,” ujar Viryan Azis, Ketua KPU Kota Pontianak, seperti dikutip dari gatra, Jumat (22/06/12).
Viryan Azis menambahkan, hanya dengan menggunakan perangkat telepon genggam maka setiap orang bisa dan mampu memaksimalkan komunikasi dengan tiga poros utama tersebut.
“Setiap orang bisa menjadi pewarta tanpa takut harus disensor serta mengespresikan dirinya sendiri meski tidak memiliki keahlian jurnalistik,” tambah Viryan Azis.
            Lantas bagaimanakan konsep dari Lomba Status Facebook Sosialisasi Pemilukada Kalbar 2012? Secara singkat lomba tersebut memanfaatkan status FB sebagai media sosialisasi pilkada.
Tema utama lomba ini adalah Menuju Pemilukada Kalbar 2012 Yang Berkualitas. Dan kontestan bisa menggunakan akun Facebook-nya masing-masing dalam keikutsertaan mereka dalam lomba ini.
Nantinya, tiga pemenang yang beruntung akan mendapatkan hadiah utama masing-masing Rp 1.000.000. Lomba ini dimulai sejak 17 Juni hingga 17 Juli 2012.
Untuk informasi lebih lengkap tentang tata cara pendaftaran dan sistematika perlombaaan, sila kunjungi laman Facebook KPU Kota Pontianak di tautan berikut.

sumber : sidomi.com

Posted on 19:29 by yusufruli

1 comment

Wednesday 20 June 2012

PRAKTIKUM 1

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <glut.h>

void mydisplay(){
glClear (GL_COLOR_BUFFER_BIT);
glBegin (GL_POLYGON);
glVertex2f(0, 0);
glVertex2f(0.5, 0.5);
glVertex2f(0, 1);
glVertex2f(-0.5, 0.5);
glVertex2f(0, 0);

glVertex2f(0.5, -0.5);
glVertex2f(0, -1);
glVertex2f(-0.5, -0.5);
glVertex2f(0, 0);

glEnd();
glFlush();
}
int main (int argc, char** argv)
{
printf ("contoh sederhana kotak");
glutCreateWindow("Praktikum 1");
glutDisplayFunc (mydisplay);
glutMainLoop();}







PRAKTIKUM 2

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <GL/glut.h>

#define drawOneLine(x1,y1,x2,y2) glBegin(GL_LINES);
glVertex2f ((x1),(y1)); glVertex2f ((x2),(y2)); glEnd();

using namespace std;

void init(void)
{
       glClearColor(0.0, 0.0, 0.0, 0.0);
       glShadeModel(GL_FLAT);
}

void display(void)
{
       int i;
       glClear (GL_COLOR_BUFFER_BIT);
       glColor3f (1.0, 1.0, 1.0);
       glEnable (GL_LINE_STIPPLE);
       glLineStipple (1, 0x0101);
       drawOneLine (50.0, 125.0, 150.0, 125.0);
       glLineStipple (1, 0x00FF);
       drawOneLine (150.0, 125.0, 250.0, 125.0);
       glLineStipple (1, 0x1C47);
       drawOneLine (250.0, 125.0, 350.0, 125.0);

       glLineWidth(5.0);
       glLineStipple(1, 0x0101);
       drawOneLine(50.0, 100.0, 150.0, 100.0);
       glLineStipple(1, 0x00FF);
       drawOneLine(150.0, 100.0, 250.0, 100.0);
       glLineStipple(1, 0x1C47);
       drawOneLine(250.0, 100.0, 350.0, 100.0);
       glLineWidth(1.0);
/*
       glLineWidth(1.0);
       glLineStipple (1, 0x0101);
       drawOneLine (48.0, 48.0, 50.0, 125.0);
       glLineWidth(1.0);
       glLineStipple (1, 0x0101);
       drawOneLine (248.0, 248.0, 50.0, 50.0);
*/
       glLineStipple(1, 0x0101);
       glBegin(GL_LINE_STRIP);
       for(i=0;i<7;i++)
       glVertex2f(50.0 + ((GLfloat) i * 50.0), 75.0);
       glEnd();

       for (i=0;i<6;i++) {
              drawOneLine(50.0 + ((GLfloat) i * 50.0),

50.0, 50.0 + ((GLfloat) (i+1) * 50.0), 50.0);
       }

       glLineStipple(5, 0x1C47);
       drawOneLine(50.0, 25.0, 350.0, 25.0);
       glDisable(GL_LINE_STIPPLE);
       glFlush();
}

void reshape (int w, int h)
{
       glViewport(0, 0, (GLsizei) w, (GLsizei) h);
       glMatrixMode(GL_PROJECTION);
       glLoadIdentity();
       gluOrtho2D(0.0, (GLdouble) w, 0.0, (GLdouble) h);
}

int main(intargc, char** argv)
{
       glutInit(&argc,argv);
       glutInitDisplayMode(GLUT_SINGLE |GLUT_RGB);
       glutInitWindowSize(400,150);
       glutInitWindowPosition(100,100);
       glutCreateWindow(argv[0]);
       init();
       glutDisplayFunc(display);
       glutReshapeFunc(reshape);
       glutMainLoop();
    system("PAUSE");
    return EXIT_SUCCESS;
}






PRAKTIKUM 3

#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdarg.h>
#include<glut.h>

void display(void)
{
GLubyte fly[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60,
0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20,
0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20,
0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC,
0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30,
0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0,
0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0,
0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30,
0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08,
0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08,
0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08};
GLubyte halftone[] = {
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55};

GLubyte S[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
0x00, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00,
0xC0, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,};

glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
/* draw one solid, unstippled rectangle, */
/* then two stippled rectangles */
glRectf (25.0, 25.0, 125.0, 125.0);
glEnable (GL_POLYGON_STIPPLE);
/*
glPolygonStipple (fly);
glRectf (125.0, 25.0, 225.0, 125.0);
glPolygonStipple (halftone);
glRectf (225.0, 25.0, 325.0, 125.0);
*/
glPolygonStipple (S);
glRectf (125.0, 25.0, 225.0, 125.0);

glDisable (GL_POLYGON_STIPPLE);
glFlush ();
}
void init (void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (350, 150);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();

return 0;
}












PRAKTIKUM 4

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <glut.h>
#include <math.h>

void display (void)
{
       glClearColor(1.0,1.0,1.0,0.0);
       glMatrixMode (GL_PROJECTION);
       gluOrtho2D(0.0,300.0,0.0,300.0);
}
void setPixel (GLint xCoordinate, GLint yCoordinate)
{
       glBegin (GL_POINTS);
       glVertex2i (xCoordinate, yCoordinate);
       glEnd();
       glFlush();
}
void lineBres (GLint x0, GLint y0, GLint xEnd, GLint yEnd)
{
       GLint dx = (float) fabs ((float) xEnd - x0);
       GLint dy = (float) fabs ((float) yEnd - y0);
       GLint p = 2 * dy - dx;
       GLint twoDy = 2 * dy;
       GLint twoDyMinusDx = 2 * (dy-dx);
       GLint x,y;
       if (x0 > xEnd){
              x = xEnd;
              y = yEnd;
              xEnd = x;
       }else{
              x = x0;
              y = y0;
       }
       setPixel (x,y);
       while (x<xEnd){
              x++;
              if(p<0)
                     p += twoDy;
              else{
                     y++;
                     p+= twoDyMinusDx;
              }
              setPixel (x, y);
       }
}
void drawMyLine(void)
{
       glClear(GL_COLOR_BUFFER_BIT);
       glColor3f (1.0,0.0,0.0);
       glPointSize(4.0);
       GLint x0 = 50;
       GLint y0 = 50;
       GLint xEnd = 125;
       GLint yEnd = 100;
       lineBres (x0, y0, xEnd, yEnd);

       glColor3f (0.0,1.0,0.0);
       glPointSize(4.0);
       GLint x1 = 75;
       GLint y1 = 50;
       GLint x1End = 125;
       GLint y1End = 150;
       lineBres (x1, y1, x1End, y1End);

       glColor3f (0.0,0.0,1.0);
       glPointSize(4.0);
       GLint x2 = 50;
       GLint y2 = 50;
       GLint x2End = 75;
       GLint y2End = 50;
       lineBres (x2, y2, x2End, y2End);

       }
int main (int argc, char** argv)
{
       glutInit(&argc, argv);
       glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
       glutInitWindowSize (400,400);
       glutInitWindowPosition (0,0);
       glutCreateWindow ("Digital Differential Analyzer Algorithm");
       display();
       glutDisplayFunc (drawMyLine);
       glutMainLoop();
       return 0;
}





PRAKTIKUM 5

#include <iostream>
#include <windows.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdarg.h> 
#include <glut.h> 
#include<math.h>
using namespace std;
typedef unsigned char uchar;
// number of line segments
static int num_lines = 20;
static int num_liness = 3;
// callback prototypes
void disp(void);
void keyb(uchar k, int x, int y);
void reshape(int x, int y);

// main

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

  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
  glutInitWindowSize(400,400);
  glutInitWindowPosition(100,100);
  glutCreateWindow("circle.cpp");
  glClearColor(0.0,0.0,0.0,0.0);
  glutDisplayFunc(disp);
  glutKeyboardFunc(keyb);
  glutReshapeFunc(reshape);
  glutMainLoop();
  return 0; }
// disp

void disp(void){
  double angle;
  glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_LINE_LOOP);
  glColor3f(1.0,1.0,0.0);
    for(int i =0;i<num_lines;i++)
            {
            angle = i*2*3.14/num_lines;
        glVertex2f(cos(angle),sin(angle));
    }
  glEnd();

  //  glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_LINE_LOOP);
  glColor3f(0.0,0.0,1.0);
    for(int i =0;i<3;i++)
            {
         angle = i*2*3.14/3;
       glVertex2f(cos(angle),sin(angle));
    }
  glEnd();

glBegin(GL_LINE_LOOP);
    for(int i =0;i<num_lines;i++){
            glColor3f(0.0,1.0,0.0);
            angle = i*2*3.14/num_lines;
        glVertex2f(cos(angle)/2,sin(angle)/2);
    }
  glEnd();
glBegin(GL_LINE_LOOP);
    for(int i =0;i<4;i++){
            glColor3f(1.0,0.0,0.0);
            angle = i*2*3.14/4;
        glVertex2f(cos(angle)/4,sin(angle)/4);
    }
  glEnd();

glBegin(GL_LINE_LOOP);
    for(int i =0;i<num_lines;i++){
            glColor3f(1.0,0.1,0.0);
            angle = i*2*3.14/num_lines;
        glVertex2f(cos(angle)/4,sin(angle)/4);
    }
  glEnd();
  glutSwapBuffers();
}

// keyb
void keyb(uchar k, int x, int y){
  switch (k){
  case 'q':
    exit(0);
    break;
  case '+':
    if(num_lines < 99){
      num_lines++;
      cout << "Circle consists of " << num_lines << " lines " << endl;
      glutPostRedisplay();
    }
    break;
  case '-':
    if(num_lines >3){
      num_lines--;
      cout << "Circle consists of " << num_lines << " lines " << endl;
      glutPostRedisplay();
    }
    break;   } }

// reshape
void reshape(int x,int y){
  if(x<y)
    glViewport(0,(y-x)/2,x,x);
  else
    glViewport((x-y)/2,0,y,y); }




PRAKTIKUM 6

#include <windows.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h>
#include <stdarg.h> 
#include <glut.h>
#include <glu.h>
#include <iostream>

float _angle = 45.0f;  //sudut saat melakukan rotasi
//Draws the 3D scene

void mydisplay()  //bentuk objek berupa kotak
{ 
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
       glMatrixMode(GL_MODELVIEW);//Switch to setting
       glLoadIdentity();//Reset the camera


       glPushMatrix();//Save the transformations
          //glTranslatef(0.0f, 0.0f, 0.0f);      //mentraslasikan kotak geser sesuai koor
          //glScalef(0.7f, 0.7f, 0.7f);          //merubah ukuran dari objek kotak
          glRotatef(_angle, 0.0f, 0.0f, 1.0f); //diputar sebesar angle
       //bentuk kotak
glBegin(GL_POLYGON); 
       glVertex3f(-0.1f, -0.1f,0.0f); 
       glVertex3f(-0.1f, 0.1f,0.0f); 
       glVertex3f(0.1f, 0.1f,0.0f); 
       glVertex3f(0.1f, -0.1f,0.0f); 
       glEnd();
       //glPopMatrix();//Undo the move to the center of

      

glPushMatrix();//Save the transformations
       glTranslatef(0.0f, 0.4f, 0.0f);      //mentraslasikan kotak geser sesuai koor
          glScalef(0.6f, 0.6f, 0.6f);          //merubah ukuran dari objek kotak
          glRotatef(_angle, 0.0f, 0.0f, -1.0f); //diputar sebesar angle
       //bentuk kotak
       glBegin(GL_POLYGON); 
       glVertex3f(-0.1f, -0.1f,0.0f); 
       glVertex3f(-0.1f, 0.1f,0.0f); 
       glVertex3f(0.1f, 0.1f,0.0f); 
       glVertex3f(0.1f, -0.1f,0.0f); 
       glEnd();
       //glPopMatrix();//Undo the move to the center of
        

       glTranslatef(0.0f, 0.6f, 0.0f);      //mentraslasikan kotak geser sesuai koor
          glScalef(0.5f, 0.5f, 0.5f);          //merubah ukuran dari objek kotak
          glRotatef(_angle, 0.0f, 0.0f, -1.0f); //diputar sebesar angle
          glPushMatrix();//Save the transformations
       //bentuk kotak
       glBegin(GL_POLYGON); 
       glVertex3f(-0.1f, -0.1f,0.0f); 
       glVertex3f(-0.1f, 0.1f,0.0f); 
       glVertex3f(0.1f, 0.1f,0.0f); 
       glVertex3f(0.1f, -0.1f,0.0f); 
       glEnd();



       glPopMatrix();//Undo the move to the center of
       glutSwapBuffers();//Send the 3D scene to the
       glFlush(); 
}

void update(int value) { //bantuan dari glrotate
       _angle += 9.0f;
       if (_angle > 360) {
              _angle -= 360;
       }
      
       glutPostRedisplay();
       glutTimerFunc(35, update, 0);//25:ukuran milisecond
}
    
int main(int argc, char** argv) 
{ 
glutInitWindowSize(400, 400);
printf("Contoh Sederhana Kotak "); 
glutCreateWindow("Praktikum06");
glutDisplayFunc(mydisplay);
glutTimerFunc(35, update, 0);
glutMainLoop(); 
return 0;
}







                                                                      

PRAKTIKUM 7

#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdarg.h>
#include<glut.h>
#include<glu.h>

void init(void)
{
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_FLAT);
}
void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT);
   glColor3f (1.0, 1.0, 1.0);
   glLoadIdentity ();/* clear the matrix */
/* viewing transformation  */
gluLookAt (0.5, 2.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
   glScalef (1.0, 1.0, 1.0);      /* modeling transformation 1*/
   glutWireCube(0.5);


   glTranslatef(-1.0,0.0,0.0);      /* modeling transformation 2*/
   glutWireCube(0.5);

   glTranslatef(2.0,0.0,0.0);      /* modeling transformation 3*/
   glutWireCube(0.5);
                                                     /* modeling transformation */
   glTranslatef(0.0,0.0,1.0);
   glutWireCube(0.5);

   glTranslatef(-2.0,0.0,0.0);      /* modeling transformation */
   glutWireCube(0.5);

    glTranslatef(1.0,0.0,0.0);      /* modeling transformation */
   glutWireCube(0.5);

   glColor3f(0.0,0.0,1.0);
   glTranslatef(0.5,0.5,-0.5);      /* modeling transformation */
   glutWireCube(0.5);

      glColor3f(1.0,0.0,0.0);
   glTranslatef(-1.0,0.0,0.0);      /* modeling transformation */
   glutWireCube(0.5);

    glColor3f(1.0,1.0,1.0);
   glTranslatef(0.5,0.5,0.0);      /* modeling transformation */
   glutWireCube(0.5);

   glFlush ();
}
void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, 2.0, 20.0);
   glMatrixMode (GL_MODELVIEW);
}
int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (500, 500);
   //glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display);
   glutReshapeFunc(reshape);
   glutMainLoop();
   return 0;
}






PRAKTIKUM 8

#include <windows.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h>
#include <stdarg.h> 
#include <glut.h>
#include <glu.h>


float _angle = 45.0f;

void initRendering() {
       glEnable(GL_DEPTH_TEST);
       glEnable(GL_COLOR_MATERIAL);
       glEnable(GL_LIGHTING);
       glEnable(GL_LIGHT0);
       glShadeModel(GL_SMOOTH);
}

void handleResize(int w, int h) {
       glViewport(0, 0, w, h);
       glMatrixMode(GL_PROJECTION);
       glLoadIdentity();
       gluPerspective(45.0, (double)w / (double)h,7.0, 100.0); //sdt pandang
       glMatrixMode (GL_MODELVIEW);
}

void drawScene() {
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
       glMatrixMode(GL_MODELVIEW);
       glLoadIdentity();

       glTranslatef(0.0f, 0.0f, -8.0f);//pindah posisi xyz

       GLfloat ambientColor[] = {0.0f, 0.0f, 0.0f, 1.0f};
       glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);

       GLfloat lightColor0[] = {0.0f, 1.0f, 1.0f, 2.0f};
       GLfloat lightPos0[] = {3.0f, 10.0f, 2.0f, 4.0f}; //

       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);
       glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);

       gluLookAt (2.0, 4.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
       //glScalef (2.0, 2.0, 2.0);  
       glTranslatef(0.0, 0.0,0.0);
       glutSolidCube(1.0);
//
       glTranslatef(1.0f, 0.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor1[] = {0.0f, 1.0f, 1.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor1);
       glutSolidCube(1.0);

       glTranslatef(1.0f, 0.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor2[] = {0.0f, 1.0f, 1.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor2);
       glutSolidCube(1.0);
//
       glTranslatef(0.0f, -1.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor3[] = {1.0f, 1.0f, 0.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor3);
       glutSolidCube(1.0);

       glTranslatef(0.0f, -1.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor4[] = {1.0f, 1.0f, 0.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor4);
       glutSolidCube(1.0);

      
       glTranslatef(0.0f, -1.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor5[] = {1.0f, 1.0f, 0.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor5);
       glutSolidCube(1.0);

       glTranslatef(-2.0f, 0.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor6[] = {0.0f, 0.0f, 2.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor6);
       glutSolidCube(1.0);

       glTranslatef(-1.0f, 0.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor7[] = {0.0f, 0.0f, 2.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor7);
       glutSolidCube(1.0);

       glTranslatef(-1.0f, 0.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor8[] = {0.0f, 0.0f, 2.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor8);
       glutSolidCube(1.0);

       glTranslatef(0.0f, 1.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor9[] = {0.0f, 1.0f, 0.0f, 0.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor9);
       glutSolidCube(1.0);

       glTranslatef(0.0f, 1.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor10[] = {0.0f, 1.0f, 0.0f, 0.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor10);
       glutSolidCube(1.0);

       glTranslatef(0.0f, 1.0f, 0.0f);//pindah posisi xyz
       GLfloat lightColor11[] = {0.0f, 1.0f, 0.0f, 0.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor11);
       glutSolidCube(1.0);

       glTranslatef(0.0f, 2.0f, 0.0f);//pindah posisi xyz
      
glRotatef(_angle, 0.0f, 1.0f, 0.0f);
       GLfloat lightColor12[] = {1.0f, 0.0f, 0.0f, 2.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor12);
       glutSolidCube(1.0);


       glFlush ();
       glEnd();
      
       glutSwapBuffers();
      
}

void update(int value) {
       _angle += 9.0f;
       if (_angle > 360) {
              _angle -= 360;
       }
      
       glutPostRedisplay();
       glutTimerFunc(25, update, 0);
}
    


int main(int argc, char** argv) {
       glutInit(&argc, argv);
       glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
       glutInitWindowSize(400, 400);
       glutCreateWindow("praktikum_8");
       initRendering();
       glutDisplayFunc(drawScene);
       glutReshapeFunc(handleResize);   
glutTimerFunc(25, update, 0);    
       glutMainLoop();
       return 0;
}












PRAKTIKUM 9

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <glut.h>
#include <glu.h>



void initRendering() {
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_NORMALIZE);
glShadeModel(GL_SMOOTH);
}

void handleResize(int w, int h) {
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, (double)w / (double)h, 1.0, 200.0);
}

float _angle = 60.0f;

void drawScene() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -8.0f);

GLfloat ambientColor[] = {0.2f, 0.2f, 0.2f, 1.0f};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);

GLfloat lightColor0[] = {0.5f, 0.5f, 0.5f, 1.0f};
GLfloat lightPos0[] = {4.0f, 0.0f, 8.0f, 1.0f};
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);

//radius
GLfloat lightColor1[] = {0.5f, 0.2f, 0.2f, 1.0f};
GLfloat lightPos1[] = {-1.0f, 0.5f, 0.5f, 0.0f};
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor1);
glLightfv(GL_LIGHT1, GL_POSITION, lightPos1);

glRotatef(_angle, 1.5f, 1.0f, 2.0f);

glBegin(GL_QUADS);

glColor3f(0.0f, 1.0f, 0.0f); //green
    glVertex3f(0, 3, 0);
glVertex3f(1, 0, -1);
glVertex3f(1, 0, 1);
glVertex3f(0, 3, 0);

glColor3f(0.0f, 0.0f, 1.0f); //blue
    glVertex3f(0, 3, 0);
glVertex3f(1, 0, 1);
glVertex3f(-1, 0, 1);
glVertex3f(0, 3, 0);

glColor3f(1.0f, 0.0f, 0.0f); //red
    glVertex3f(0, 3, 0);
glVertex3f(1, 0, -1);
glVertex3f(-1, 0, -1);
glVertex3f(0, 3, 0);

glColor3f(1.0f, 1.0f, 0.0f); //yellow
    glVertex3f(0, 3, 0);
glVertex3f(-1, 0, -1);
glVertex3f(-1, 0, 1);
glVertex3f(0, 3, 0);

glColor3f(1.0f, 1.0f, 1.0f); //alas
    glVertex3f(-1, 0, -1);
glVertex3f(-1, 0, 1);
glVertex3f(1, 0, 1);
glVertex3f(1, 0, -1);

  glEnd();
glutSwapBuffers();
}

void update(int value) {
_angle += 1.5f;
if (_angle > 360) {
_angle -= 360;
}

glutPostRedisplay();
glutTimerFunc(25, update, 0);
}

int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(400, 400);
glutCreateWindow("Lighting - videotutorialsrock.com");
initRendering();
glutDisplayFunc(drawScene);
glutReshapeFunc(handleResize);
glutTimerFunc(25, update, 0);

glutMainLoop();
return 0;
}









PRAKTIKUM 10
main

#include <windows.h> 
#include <iostream>
#include <stdlib.h>
#include <stdio.h> 
#include <string.h>
#include <stdarg.h> 
#include <glut.h>
#include <glu.h>
#include "imageloader.h"
using namespace std;

Image::Image(char* ps, int w, int h) : pixels(ps), width(w), height(h) {
      
}

Image::~Image() {
       delete[] pixels;
}

namespace {
       //Converts a four-character array to an integer, using little-endian form
       int toInt(const char* bytes) {
              return (int)(((unsigned char)bytes[3] << 24) |
                                   ((unsigned char)bytes[2] << 16) |
                                   ((unsigned char)bytes[1] << 8) |
                                   (unsigned char)bytes[0]);
       }
      
       //Converts a two-character array to a short, using little-endian form
       short toShort(const char* bytes) {
              return (short)(((unsigned char)bytes[1] << 8) |
                                     (unsigned char)bytes[0]);
       }
      
       //Reads the next four bytes as an integer, using little-endian form
       int readInt(ifstream &input) {
              char buffer[4];
              input.read(buffer, 4);
              return toInt(buffer);
       }
      
       //Reads the next two bytes as a short, using little-endian form
       short readShort(ifstream &input) {
              char buffer[2];
              input.read(buffer, 2);
              return toShort(buffer);
       }
      
       //Just like auto_ptr, but for arrays
       template<class T>
       class auto_array {
              private:
                     T* array;
                     mutable bool isReleased;
              public:
                     explicit auto_array(T* array_ = NULL) :
                           array(array_), isReleased(false) {
                     }
                    
                     auto_array(const auto_array<T> &aarray) {
                           array = aarray.array;
                           isReleased = aarray.isReleased;
                           aarray.isReleased = true;
                     }
                    
                     ~auto_array() {
                           if (!isReleased && array != NULL) {
                                  delete[] array;
                           }
                     }
                    
                     T* get() const {
                           return array;
                     }
                    
                     T &operator*() const {
                           return *array;
                     }
                    
                     void operator=(const auto_array<T> &aarray) {
                           if (!isReleased && array != NULL) {
                                  delete[] array;
                           }
                           array = aarray.array;
                           isReleased = aarray.isReleased;
                           aarray.isReleased = true;
                     }
                    
                     T* operator->() const {
                           return array;
                     }
                    
                     T* release() {
                           isReleased = true;
                           return array;
                     }
                    
                     void reset(T* array_ = NULL) {
                           if (!isReleased && array != NULL) {
                                  delete[] array;
                           }
                           array = array_;
                     }
                    
                     T* operator+(int i) {
                           return array + i;
                     }
                    
                     T &operator[](int i) {
                           return array[i];
                     }
       };
}

Image* loadBMP(const char* filename) {
       ifstream input;
       input.open(filename, ifstream::binary);
       assert(!input.fail() || !"Could not find file");
       char buffer[2];
       input.read(buffer, 2);
       assert(buffer[0] == 'B' && buffer[1] == 'M' || !"Not a bitmap file");
       input.ignore(8);
       int dataOffset = readInt(input);
      
       //Read the header
       int headerSize = readInt(input);
       int width;
       int height;
       switch(headerSize) {
              case 40:
                     //V3
                     width = readInt(input);
                     height = readInt(input);
                     input.ignore(2);
                     assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");
                     assert(readShort(input) == 0 || !"Image is compressed");
                     break;
              case 12:
                     //OS/2 V1
                     width = readShort(input);
                     height = readShort(input);
                     input.ignore(2);
                     assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");
                     break;
              case 64:
                     //OS/2 V2
                     assert(!"Can't load OS/2 V2 bitmaps");
                     break;
              case 108:
                     //Windows V4
                     assert(!"Can't load Windows V4 bitmaps");
                     break;
              case 124:
                     //Windows V5
                     assert(!"Can't load Windows V5 bitmaps");
                     break;
              default:
                     assert(!"Unknown bitmap format");
       }
      
       //Read the data
       int bytesPerRow = ((width * 3 + 3) / 4) * 4 - (width * 3 % 4);
       int size = bytesPerRow * height;
       auto_array<char> pixels(new char[size]);
       input.seekg(dataOffset, ios_base::beg);
       input.read(pixels.get(), size);
      
       //Get the data into the right format
       auto_array<char> pixels2(new char[width * height * 3]);
       for(int y = 0; y < height; y++) {
              for(int x = 0; x < width; x++) {
                     for(int c = 0; c < 3; c++) {
                           pixels2[3 * (width * y + x) + c] =
                                  pixels[bytesPerRow * y + 3 * x + (2 - c)];
                     }
              }
       }
      
       input.close();
       return new Image(pixels2.release(), width, height);
}


GLuint loadTexture(Image* image) {
       GLuint textureId;
       glGenTextures(1, &textureId); //Make room for our texture
       glBindTexture(GL_TEXTURE_2D, textureId); //Tell OpenGL which texture to edit
       //Map the image to the texture
       glTexImage2D(GL_TEXTURE_2D,                //Always GL_TEXTURE_2D
                            0,                            //0 for now
                            GL_RGB,                       //Format OpenGL uses for image
                            image->width, image->height,  //Width and height
                            0,                            //The border of the image
                            GL_RGB, //GL_RGB, because pixels are stored in RGB format
                            GL_UNSIGNED_BYTE, //GL_UNSIGNED_BYTE, because pixels are stored
                                              //as unsigned numbers
                            image->pixels);               //The actual pixel data
       return textureId; //Returns the id of the texture
}

GLuint _textureId; //The id of the texture


void initRendering() {
       glEnable(GL_DEPTH_TEST);
       glEnable(GL_COLOR_MATERIAL);
       glEnable(GL_LIGHTING);
       glEnable(GL_LIGHT0);
       glEnable(GL_LIGHT1);
       glEnable(GL_NORMALIZE);
       glShadeModel(GL_SMOOTH);

       Image* image = loadBMP("mu.bmp");
       _textureId = loadTexture(image);
       delete image;
}

void handleResize(int w, int h) {
       glViewport(0, 0, w, h);
       glMatrixMode(GL_PROJECTION);
       glLoadIdentity();
       gluPerspective(45.0, (double)w / (double)h, 1.0, 200.0);
}

float _angle = 60.0f;

void drawScene() {
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
       glMatrixMode(GL_MODELVIEW);
       glLoadIdentity();
       glTranslatef(0.0f, 0.0f, -8.0f);

       GLfloat ambientColor[] = {0.2f, 0.2f, 0.2f, 1.0f};
       glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);

       GLfloat lightColor0[] = {0.5f, 0.5f, 0.5f, 1.0f};
       GLfloat lightPos0[] = {4.0f, 0.0f, 8.0f, 1.0f};
       glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);
       glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);
//radius
       GLfloat lightColor1[] = {0.5f, 0.2f, 0.2f, 1.0f};

       GLfloat lightPos1[] = {-1.0f, 0.5f, 0.5f, 0.0f};
       glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor1);
       glLightfv(GL_LIGHT1, GL_POSITION, lightPos1);

glEnable(GL_TEXTURE_2D);
       glBindTexture(GL_TEXTURE_2D, _textureId);
       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

       glRotatef(_angle, 0.0f, 1.0f, 0.0f);
       glColor3f(1.0f, 1.0f, 0.0f);
       //glScalef(1.0f, 1.5f, 1.0f);
       glBegin(GL_QUADS);
      
       //Front

       glNormal3f(0.1f, 0.0f, 1.0f);
       //glNormal3f(-1.0f, 0.0f, 1.0f);
       glTexCoord2f(0.0f, 0.0f);
       glVertex3f(-1.5f, -1.0f, 1.5f);
       glNormal3f(1.0f, 0.0f, 1.0f);
       glTexCoord2f(1.0f, 0.0f);
       glVertex3f(1.5f, -1.0f, 1.5f);
       glNormal3f(1.0f, 0.0f, 1.0f);
       glTexCoord2f(1.0f, 1.0f);
       glVertex3f(1.5f, 1.0f, 1.5f);
       glNormal3f(-1.0f, 0.0f, 1.0f);
       glTexCoord2f(0.0f, 1.0f);
       glVertex3f(-1.5f, 1.0f, 1.5f);
      
       //Right
       glColor3f(0.0f, 1.0f, 2.0f);
       glNormal3f(1.0f, 0.0f, 0.0f);
       //glNormal3f(1.0f, 0.0f, -1.0f);
       glTexCoord2f(0.0f, 0.0f);
       glVertex3f(1.5f, -1.0f, -1.5f);
       glNormal3f(1.0f, 0.0f, -1.0f);
       //glTexCoord2f(1.0f, 0.0f);
       glVertex3f(1.5f, 1.0f, -1.5f);
       glNormal3f(1.0f, 0.0f, 1.0f);
       glVertex3f(1.5f, 1.0f, 1.5f);
       //glTexCoord2f(1.0f, 1.0f);
       glNormal3f(1.0f, 0.0f, 1.0f);
       //glTexCoord2f(0.0f, 1.0f);
       glVertex3f(1.5f, -1.0f, 1.5f);
      
       //Back
       glColor3f(0.0f, 1.0f, 1.0f);
       glNormal3f(0.0f, 0.0f, -1.0f);
       //glNormal3f(-1.0f, 0.0f, -1.0f);
       glVertex3f(-1.5f, -1.0f, -1.5f);
       glNormal3f(-1.0f, 0.0f, -1.0f);
       glVertex3f(-1.5f, 1.0f, -1.5f);
       glNormal3f(1.0f, 0.0f, -1.0f);
       glVertex3f(1.5f, 1.0f, -1.5f);
       glNormal3f(1.0f, 0.0f, -1.0f);
       glVertex3f(1.5f, -1.0f, -1.5f);
      
       //Left
       glColor3f(1.0f, 1.0f, 1.0f);
       glNormal3f(-1.0f, 0.0f, 0.0f);
       //glNormal3f(-1.0f, 0.0f, -1.0f);
       glVertex3f(-1.5f, -1.0f, -1.5f);
       glNormal3f(-1.0f, 0.0f, 1.0f);
       glVertex3f(-1.5f, -1.0f, 1.5f);
       glNormal3f(-1.0f, 0.0f, 1.0f);
       glVertex3f(-1.5f, 1.0f, 1.5f);
       glNormal3f(-1.0f, 0.0f, -1.0f);
       glVertex3f(-1.5f, 1.0f, -1.5f);
       glEnd();
       glDisable(GL_TEXTURE_2D);
      
       glutSwapBuffers();
}

void update(int value) {
       _angle += 1.5f;
       if (_angle > 360) {
              _angle -= 360;
       }
      
       glutPostRedisplay();
       glutTimerFunc(25, update, 0);
}

int main(int argc, char** argv) {
       glutInit(&argc, argv);
       glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
       glutInitWindowSize(400, 400);
       glutCreateWindow("Lighting");
       initRendering();
       glutDisplayFunc(drawScene);
       glutReshapeFunc(handleResize);   
       glutTimerFunc(25, update, 0);
      
       glutMainLoop();
       return 0;
}


header


#ifndef IMAGE_LOADER_H_INCLUDED
#define IMAGE_LOADER_H_INCLUDED

//Represents an image
class Image {
      public:
            Image(char* ps, int w, int h);
            ~Image();
           
            /* An array of the form (R1, G1, B1, R2, G2, B2, ...) indicating the
             * color of each pixel in image.  Color components range from 0 to 255.
             * The array starts the bottom-left pixel, then moves right to the end
             * of the row, then moves up to the next column, and so on.  This is the
             * format in which OpenGL likes images.
             */
            char* pixels;
            int width;
            int height;
};

//Reads a bitmap image from file.
Image* loadBMP(const char* filename);

#endif




Posted on 22:58 by yusufruli

No comments