Proyek Akhir Grafika Komputer Objek 2D

LAPORAN PROYEK AKHIR UTS

GRAFIKA KOMPUTER

“SUASANA KOTA DENGAN LONDON BRIDGE DAN LAUT”

OLEH :

KHOFI ANNISA ARIF

NRP. 2103131018

DOSEN PENGAMPU :

NANA RAMADIJANTI S.KOM.,M.KOM.

NIP. 197111091998022001

JURUSAN TEKNIK INFORMATIKA

DEPARTEMEN TEKNIK INFORMATIKA DAN KOMPUTER

POLITEKNIK ELEKTRONIKA NEGERI SURABAYA

2015

Khofi Annisa Arif - 2103131018

PengenalanPada projek grafika yang dibuat ini, diimplementasikan berbagai cara penggambaran obyek-obyek 2D seperti drawPolygon, fillPolygon, gradatePolygon, rotasi, sampai dengan morphing.

Garis Besar TugasProject ini menggambarkan suasana kota malam dengan adanya London bridge dan laut disana. Di lautnya juga terdapat kapal yang berlalu lalang. Bintang yang berkelap kelip, dan pancaran air laut yang berkilauan menjadi pilihan saya untuk menggunakan transisi 2D. banyak terdapat objek-objek 2D yang lain yang saya gunakan untk membuat semua yang saya gambarkan pada projek ini. Untuk lebih lengkapnya akan dibahas pada laporan ini.

Gambar jadi dari Projek ini adalah seperti berikut :


Berikut akan saya bahas satu per satu dari setiap fungsi dan objek yang saya buat dari gambar tersebut.

Fungsi Displayvoid display(void){ glClear(GL_COLOR_BUFFER_BIT); userdraw(); glutSwapBuffers();}

Fungsi Mainint main(int argc, char * argv[]){ glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); glutInitWindowPosition(10, 10); glutInitWindowSize(1000, 750); glutCreateWindow("Proyek Akhir UTS Grafkom - Khofi Annisa Arif (2103131018)"); glClearColor(1, 1, 1, 1); gluOrtho2D(0, 1000, 0, 750); glutIdleFunc(display); glutDisplayFunc(display);

glEnable (GL_BLEND);glBlendFunc

(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glutMainLoop(); return 0;}


Membuat Kota

Untuk membuat kota seperti gambar berikut :

Saya menggunakan corel draw untuk menentukan semua koordinat nya. Sehingga koordinat yang saya gunakan semuanya bernilai positif. Pada objek kota ini saya menggunakan primitive drawing sebagai bahan pengerjaannya yang meliputi, GL_POLYGON, GL_LINES, dll.Sedangkan untuk pembuatan jendela pada gedung-gedung kota yang bentuknya sama dan banyak, saya menggunakan looping. Berikut adalah cuplikan source code nya.//kota1

glBegin(GL_POLYGON);glColor3f(0.08235, 0.73725, 0.56471);

glVertex2f(0., 380); glVertex2f(0., 503); glVertex2f(47., 503); glVertex2f(47., 380);

glVertex2f(0., 380);glEnd();


point2D_t kotak_a1[4] = {{6,497},{19,497},{19,481},{6,481}};

point2D_t kotak_a2[4] = {{26,497},{39,497},{39,481},{26,481}};

point2D_t kotak_a3[4] = {{6,397},{39,397},{39,387},{6,387}};

for(int i=0;i<5;i++){point2D_t jendela_kiri[4];point2D_t jendela_kanan[4];for(int j=0;j<4;j++){

jendela_kiri[j].x = kotak_a1[j].x;jendela_kiri[j].y = kotak_a1[j].y-

20*i;jendela_kanan[j].x =

kotak_a2[j].x;jendela_kanan[j].y =

kotak_a2[j].y-20*i;}fillPolygon(jendela_kiri,4,putih);fillPolygon(jendela_kanan,4,putih);

}

//kota2glBegin(GL_POLYGON);glColor3f(0.98824, 0.46275, 0.24314);



point2D_t kotak_b1[4] = {{52,543},{120,543},{120,533},{52,533}};

point2D_t kotak_b2[4] = {{52,523},{120,523},{120,513},{52,513}};

for(int i=0;i<8;i++){point2D_t jendela[4];for(int j=0;j<4;j++){

jendela[j].x = kotak_b1[j].x;jendela[j].y = kotak_b1[j].y-20*i;

}fillPolygon(jendela,4,putih);

}



glVertex2f(126., 469); glVertex2f(170., 469); glVertex2f(170., 380);

glVertex2f(126., 380);glVertex2f(126., 469);

glEnd();

glBegin(GL_LINES);glColor3f(1, 1, 1);

glVertex2f(133., 457); glVertex2f(162., 457);






glVertex2f(133., 397); glVertex2f(162., 397); glEnd();//Kota4

glBegin(GL_POLYGON);glColor3f(1, 0.65098, 0.59608);



point2D_t kotak_d1[4] = {{175,531},{187,531},{187,516},{175,516}};


jendela[j].x = kotak_d1[j].x;jendela[j].y = kotak_d1[j].y-25*i;



}

point2D_t kotak_d2[4] = {{195,511},{207,511},{207,496},{195,496}};


jendela[j].x = kotak_d2[j].x;jendela[j].y = kotak_d2[j].y-25*i;


}




point2D_t kotak_e1[4] = {{218,517},{234,517},{234,500},{218,500}};

point2D_t kotak_e2[4] = {{249,516},{265,516},{265,499},{249,499}};


jendela_kiri[j].x = kotak_e1[j].x;jendela_kiri[j].y = kotak_e1[j].y-

30*i;jendela_kanan[j].x =

kotak_e2[j].x;jendela_kanan[j].y =

kotak_e2[j].y-30*i;}fillPolygon(jendela_kiri,4,putih);fillPolygon(jendela_kanan,4,putih);

}

point2D_t kotak_e3[4] = {{217,432},{266,432},{266,422},{217,422}};



jendela[j].x = kotak_e3[j].x;jendela[j].y = kotak_e3[j].y-18*i;


}

Dst.. sampai kota 16


Membuat Jembatan

Sama dengan membuat kota, untuk membuat jembatan saya masih menggunakan primitive drawing untuk pengerjaannya. Kebanyakan yang saya gunakan untuk membuat jembatan ini adalah GL_POLYGON dan GL_LINES. Dan ketika membuat motif segitiga kecil-kecil yang berada diantara dua tower jembatan, saya menggunakan looping, dikarenakan line yang dibutuhkan cukup banyak.

//kotak persegi panjang jembatan bawahglBegin(GL_POLYGON);glColor3f(0.6, 0.4, 0.2);



glEnd();


//tower1glBegin(GL_POLYGON);glColor3f(1, 0.8, 0.32941);



glEnd();

//segitiga besaarglBegin(GL_POLYGON);glColor3f(0.4, 0.4, 0.4);



//kotak persegi panjang berdiri 1glBegin(GL_POLYGON);glColor3f(1, 0.8, 0.32941);



glEnd();

//segitiga kecil 1glBegin(GL_POLYGON);glColor3f(0.4, 0.4, 0.4);



//kootak persegi panjang tidur 1glBegin(GL_POLYGON);glColor3f(0.6, 0.4, 0.2);



glEnd();





glEnd();

//segitiga kecil 2glBegin(GL_POLYGON);glColor3f(1, 0.8, 0.32941);



//kootak persegi panjang tidur 2glBegin(GL_POLYGON);glColor3f(0.6, 0.4, 0.2);



glEnd();




glEnd();

//segitiga kecil 3glBegin(GL_POLYGON);glColor3f(0.4, 0.4, 0.4);



//kootak persegi panjang tidur 3glBegin(GL_POLYGON);


glColor3f(0.6, 0.4, 0.2); glVertex2f(350., 588);

glVertex2f(382., 588); glVertex2f(382., 583); glVertex2f(350., 583);

glEnd();

//looping kotak tidur di towerpoint2D_t kotak_tow1[4] = {{284,550},{371,550},

{371,539},{284,539}};

for(int i=0;i<4;i++){point2D_t kayu[4];for(int j=0;j<4;j++){

kayu[j].x = kotak_tow1[j].x;kayu[j].y = kotak_tow1[j].y-38*i;

}fillPolygon(kayu,4,coklat);glColor3f(0.6, 0.4, 0.2);

}

//tower2glBegin(GL_POLYGON);glColor3f(1, 0.8, 0.32941);



glEnd();

Dst..


Membuat Laut yang Berkilau

void laut(){color_t c_laut={0.31373, 0.56863, 0.82353};point2D_t laut[] = {{0, 317}, {1000, 317}, {1000,

0}, {0, 0}};GradatePolygon(laut, 4, c_laut);float xp,xp1,yp,yp1,dx;setColor(putih);for(int i=1;i<20;i++){

xp=1000*(float)rand()/RAND_MAX;yp=317*(float)rand()/RAND_MAX+10;dx=10+20*(float)rand()/RAND_MAX;drawLine(xp,yp,xp+dx,yp);

}}

Pada fungsi Laut tersebut digunakan untuk membuat laut yang berkilau karena pancaran cahaya. Digunkan fungsi random untuk merandom posisi dari garis-garis efek kilauan. Variable i<20 digunakan untuk membuat banyaknya garis-garis yang akan dimunculkan.


Membuat Langit Bergradasi

//langit gradasipoint2D_t kotak[4]={{0,750},{1000,750},{1000,382},{0,382}};color_t col[4]={{0,0,0},{0,0,0},{0,0,0.19216},{0,0,0.19216}};gradatePolygon(kotak,col,4);

Pada objek langit bergradasi ini, saya hanya membuat objek 2d untuk koordinat langit, dan menginputkan dua kombinasi warna yang akan digunakan. Disini karena suasana langit malam, maka saya menggunakan kombinasi warna hitam dan biru tua.


Membuat Bintang Berkelip

void bintang(){static int tick=0;

static point2D_t bintang[200];int i;if(tick==0){

for(i=0;i<300;i++){bintang[i].x=rand()%1000;bintang[i].y=rand()%900;}

}setColor(putih);glPointSize(2);for(i=0;i<300;i++)

drawDot(bintang[i].x,500+bintang[i].y);int k=rand()%100;glPointSize(5.0);drawDot(bintang[k].x,500+bintang[k].y);tick++;

}


Pada fungsi bintang ini tidak jau beda dengan fungsi Laut yang berkilau. Disini kita membuat bintang berkelip dengan fungsi random, yang digunakan untuk merandom posisi bintang ketika berkelip. Pada fungsi bintang berkelip ini, memanggil method drawDot untuk menggambar setiap titik yang akan dijadikan bintang.

Membuat Bulan Bergradasi

void drawFillCircle(point2D_t p0, float r, int n, color_t col, color_t colp){

point2D_t p[360];float a=6.28/n;for(int i=0;i<n;i++){

p[i].x=p0.x+r*(float)cos((float)i*a);p[i].y=p0.y+r*(float)sin((float)i*a);

}centerPolygon(p, p0, col, colp, 360);

}

drawFillCircle(pusat, 63, 360, kuning, putih);drawFillCircle(pusat2, 63, 360, kuning, putih);


Untuk membuat bulan dengan warna yang bergradasi kita perlu membuat fungsi drawFillCircle yang berisi (pusat, jari-jari, 360, warna1, warna2) seperti di atas.

Membuat Kapal Berjalan

void kapal1(){static float tick=0;

if(tick>1600) tick = 0;

float inc=1;

color_t coklatt={0.49412,0.18824,0.0902};color_t ungu_tua={0.37647,0.14118,0.4549};color_t ungu_muda={0.71765,0.50588,0.78431};color_t abu={0.4,0.4,0.4};color_t putih={1,1,1};

point2D_t kotak_bawah1[4] = {{43., 28}, {180., 28}, {245., 79}, {19., 65}};

point2D_t kotak_tengah1[4] = {{35., 66}, {37., 104}, {195., 104}, {195., 75}};


point2D_t kotak_atas1[4] = {{47., 104}, {47., 123}, {146., 123}, {146., 104}};

point2D_t cerobong1[4] = {{56., 123}, {56., 152}, {74., 152}, {77., 123}};

point2D_t jendela_1a[4] = {{46., 94}, {60., 94}, {60., 82}, {46., 82}};

point2D_t jendela_1b[4] = {{65., 94}, {79., 94}, {79., 82}, {65., 82}};

point2D_t jendela_1c[4] = {{85., 94}, {100., 94}, {100., 82}, {85., 82}};

point2D_t jendela_1d[4] = {{106., 94}, {120., 94}, {120., 82}, {106., 82}};

point2D_t jendela_1e[4] = {{126., 94}, {140., 94}, {140., 82}, {126., 82}};

point2D_t jendela_1f[4] = {{145., 94}, {160., 94}, {160., 82}, {145., 82}};

point2D_t jendela_1g[4] = {{165., 94}, {179., 94}, {179., 82}, {165., 82}};







matrix2D_t mat;

vector2D_t vector_kotak_bawah1[4];vector2D_t vector_kotak_tengah1[4];vector2D_t vector_kotak_atas1[4];vector2D_t vector_cerobong1[4];vector2D_t vector_jendela_1a[4];vector2D_t vector_jendela_1b[4];vector2D_t vector_jendela_1c[4];vector2D_t vector_jendela_1d[4];vector2D_t vector_jendela_1e[4];vector2D_t vector_jendela_1f[4];vector2D_t vector_jendela_1g[4];vector2D_t vector_jendela_2a[4];vector2D_t vector_jendela_2b[4];vector2D_t vector_jendela_2c[4];vector2D_t vector_jendela_2d[4];


vector2D_t vector_jendela_2e[4];vector2D_t vector_jendela_2f[4];

float arahx=0.02+tick;float arahy=0.5;

mat=translationMTX(arahx,arahy);

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

vector_kotak_bawah1[i]=Point2Vector(kotak_bawah1[i]);

vector_kotak_bawah1[i]=multiply(mat,vector_kotak_bawah1[i]);

kotak_bawah1[i]=Vector2Point(vector_kotak_bawah1[i]);}


vector_kotak_tengah1[i]=Point2Vector(kotak_tengah1[i]);

vector_kotak_tengah1[i]=multiply(mat,vector_kotak_tengah1[i]);

kotak_tengah1[i]=Vector2Point(vector_kotak_tengah1[i]);}


vector_kotak_atas1[i]=Point2Vector(kotak_atas1[i]);

vector_kotak_atas1[i]=multiply(mat,vector_kotak_atas1[i]);


kotak_atas1[i]=Vector2Point(vector_kotak_atas1[i]);}


vector_cerobong1[i]=Point2Vector(cerobong1[i]);

vector_cerobong1[i]=multiply(mat,vector_cerobong1[i]);

cerobong1[i]=Vector2Point(vector_cerobong1[i]);}


vector_jendela_1a[i]=Point2Vector(jendela_1a[i]);

vector_jendela_1a[i]=multiply(mat,vector_jendela_1a[i]);

jendela_1a[i]=Vector2Point(vector_jendela_1a[i]);}


vector_jendela_1b[i]=Point2Vector(jendela_1b[i]);

vector_jendela_1b[i]=multiply(mat,vector_jendela_1b[i]);

jendela_1b[i]=Vector2Point(vector_jendela_1b[i]);}


vector_jendela_1c[i]=Point2Vector(jendela_1c[i]);

vector_jendela_1c[i]=multiply(mat,vector_jendela_1c[i]);

jendela_1c[i]=Vector2Point(vector_jendela_1c[i]);}



vector_jendela_1d[i]=Point2Vector(jendela_1d[i]);

vector_jendela_1d[i]=multiply(mat,vector_jendela_1d[i]);

jendela_1d[i]=Vector2Point(vector_jendela_1d[i]);}


vector_jendela_1e[i]=Point2Vector(jendela_1e[i]);

vector_jendela_1e[i]=multiply(mat,vector_jendela_1e[i]);

jendela_1e[i]=Vector2Point(vector_jendela_1e[i]);}


vector_jendela_1f[i]=Point2Vector(jendela_1f[i]);

vector_jendela_1f[i]=multiply(mat,vector_jendela_1f[i]);

jendela_1f[i]=Vector2Point(vector_jendela_1f[i]);}


vector_jendela_1g[i]=Point2Vector(jendela_1g[i]);

vector_jendela_1g[i]=multiply(mat,vector_jendela_1g[i]);

jendela_1g[i]=Vector2Point(vector_jendela_1g[i]);}









fillPolygon(kotak_bawah1,4,coklatt);fillPolygon(kotak_tengah1,4,ungu_tua);fillPolygon(kotak_atas1,4,ungu_muda);fillPolygon(cerobong1,4,abu);fillPolygon(jendela_1a,4,putih);fillPolygon(jendela_1b,4,putih);fillPolygon(jendela_1c,4,putih);fillPolygon(jendela_1d,4,putih);fillPolygon(jendela_1e,4,putih);fillPolygon(jendela_1f,4,putih);fillPolygon(jendela_1g,4,putih);fillPolygon(jendela_2a,4,putih);fillPolygon(jendela_2b,4,putih);fillPolygon(jendela_2c,4,putih);fillPolygon(jendela_2d,4,putih);fillPolygon(jendela_2e,4,putih);fillPolygon(jendela_2f,4,putih);

tick+=0.1;}

void kapal2(){static float tick=0;

if(tick>1600) tick = 0;

float inc=1;


color_t coklatt={0.49412,0.18824,0.0902};color_t hijau_tua={0.32941, 0.64314, 0.12157};color_t hijau_muda={0.6, 0.8549, 0.42353};color_t abu={0.4,0.4,0.4};color_t putih={1,1,1};

point2D_t kotak_tengah2[4] = {{809., 216}, {809., 250}, {936., 250}, {936., 216}};

point2D_t kotak_atas2[4] = {{849., 267}, {927., 267}, {927., 250}, {849., 250}};

point2D_t kotak_bawah2[4] = {{769., 220}, {950., 225}, {930., 182}, {821., 182}};

point2D_t cerobong2[4] = {{906., 268}, {906., 293}, {920., 293}, {920., 268}};







point2D_t jendela_3g[4] = {{917., 241}, {928., 241}, {928., 231}, {917., 231}};







matrix2D_t mat;

vector2D_t vector_kotak_bawah2[4];vector2D_t vector_kotak_tengah2[4];vector2D_t vector_kotak_atas2[4];


vector2D_t vector_cerobong2[4];vector2D_t vector_jendela_3a[4];vector2D_t vector_jendela_3b[4];vector2D_t vector_jendela_3c[4];vector2D_t vector_jendela_3d[4];vector2D_t vector_jendela_3e[4];vector2D_t vector_jendela_3f[4];vector2D_t vector_jendela_3g[4];vector2D_t vector_jendela_4a[4];vector2D_t vector_jendela_4b[4];vector2D_t vector_jendela_4c[4];vector2D_t vector_jendela_4d[4];vector2D_t vector_jendela_4e[4];vector2D_t vector_jendela_4f[4];

float arahx=0.02-tick;float arahy=0.5;

mat=translationMTX(arahx,arahy);


vector_kotak_bawah2[i]=Point2Vector(kotak_bawah2[i]);

vector_kotak_bawah2[i]=multiply(mat,vector_kotak_bawah2[i]);

kotak_bawah2[i]=Vector2Point(vector_kotak_bawah2[i]);}


vector_kotak_tengah2[i]=Point2Vector(kotak_tengah2[i]);

vector_kotak_tengah2[i]=multiply(mat,vector_kotak_tengah2[i]);

kotak_tengah2[i]=Vector2Point(vector_kotak_tengah2[i]);}



vector_kotak_atas2[i]=Point2Vector(kotak_atas2[i]);

vector_kotak_atas2[i]=multiply(mat,vector_kotak_atas2[i]);

kotak_atas2[i]=Vector2Point(vector_kotak_atas2[i]);}


vector_cerobong2[i]=Point2Vector(cerobong2[i]);

vector_cerobong2[i]=multiply(mat,vector_cerobong2[i]);

cerobong2[i]=Vector2Point(vector_cerobong2[i]);}










vector_jendela_3g[i]=Point2Vector(jendela_3g[i]);

vector_jendela_3g[i]=multiply(mat,vector_jendela_3g[i]);

jendela_3g[i]=Vector2Point(vector_jendela_3g[i]);}


























fillPolygon(kotak_tengah2,4,hijau_tua);fillPolygon(kotak_atas2,4,hijau_muda);fillPolygon(kotak_bawah2,4,coklatt);fillPolygon(cerobong2,4,abu);fillPolygon(jendela_3a,4,putih);fillPolygon(jendela_3b,4,putih);fillPolygon(jendela_3c,4,putih);fillPolygon(jendela_3d,4,putih);fillPolygon(jendela_3e,4,putih);fillPolygon(jendela_3f,4,putih);fillPolygon(jendela_3g,4,putih);fillPolygon(jendela_4a,4,putih);fillPolygon(jendela_4b,4,putih);fillPolygon(jendela_4c,4,putih);fillPolygon(jendela_4d,4,putih);fillPolygon(jendela_4e,4,putih);


fillPolygon(jendela_4f,4,putih);

tick+=0.3;}

Untuk membuat kapal yang dapat bergerak, saya membuat sebuah fungsi bernama kapal1 dan kapal2. Di dalam fungsi ini telah ditentukan koordinat-koordinat pembuatan kapal serta pengesetan tick untuk pergerakannya nanti. Digunakan looping supaya kapal dapat berjalan secara terus menerus ketika sudah mneghilang dari layar, dia akan kembali lagi. Untuk mengatur kecepatannya tinggal kita ubah pada tick++ yang terletak di source code paling bawah pada fungsi. Semakin kecil kita menginputkan angka, maka pergerakan akan semakin lambat, begitu sebaliknya.

Membuat Bayangan Kota, Jembatan, dan Bulan

Pertama-tama buat bangunan kota, jembatan, dan bulan seperti biasa dengan titik-titik koordinat. Namun bedanya ketiga objek ini harus digambar secara terbalik seprti gambar berikut supaya menyerupai sebuah bayangan :


Berikut cuplikan source codenya ://b_kota1

point2D_t b_kota1_a[4] = {{0,375},{46,375},{46,249},{0,249}};

point2D_t b_kota1_b[4] = {{6,369},{38,369},{38,359},{6,359}};

point2D_t b_kota1_c[4] = {{6,354},{19,354},{19,337},{6,337}};

point2D_t b_kota1_d[4] = {{26,354},{39,354},{39,337},{26,337}};

fillPolygon(b_kota1_a,4,kota1);fillPolygon(b_kota1_b,4,putih);


jendela_kiri[j].x = b_kota1_c[j].x;

jendela_kiri[j].y = b_kota1_c[j].y-20*i;

jendela_kanan[j].x = b_kota1_d[j].x;

jendela_kanan[j].y =


b_kota1_d[j].y-20*i;}fillPolygon(jendela_kiri,4,putih);fillPolygon(jendela_kanan,4,putih);

}

//b_kota2point2D_t b_kota2_a[4] = {{46,375},{126,375},

{126,200},{46,200}};fillPolygon(b_kota2_a,4,kota2);

point2D_t b_kota2_b[4] = {{52,362},{120,362},{120,351},{52,351}};


jendela[j].x = b_kota2_b[j].x;jendela[j].y = b_kota2_b[j].y-

20*i;}fillPolygon(jendela,4,putih);

}//b_kota3

point2D_t b_kota3_a[4] = {{126,375},{170,375},{170,284},{126,284}};

fillPolygon(b_kota3_a,4,kota3);

glBegin(GL_LINES);glColor3f(1,1,1);








glEnd();




point2D_t b_kota4_b[4] = {{175,359},{187,359},{187,343},{175,343}};




}

point2D_t b_kota4_c[4] = {{195,338},{207,338},{207,323},{195,323}};


jendela[j].x = b_kota4_c[j].x;jendela[j].y = b_kota4_c[j].y-


}



point2D_t b_kota5_b[4] = {{217,369},{266,369},{266,358},{217,358}};




}

point2D_t b_kota5_c[4] = {{218,314},{234,314},{234,297},{218,297}};

point2D_t b_kota5_d[4] = {{249,315},{265,315},{265,297},{249,297}};



jendela_kiri[j].x = b_kota5_c[j].x;

jendela_kiri[j].y = b_kota5_c[j].y-30*i;

jendela_kanan[j].x = b_kota5_d[j].x;

jendela_kanan[j].y = b_kota5_d[j].y-30*i;

}fillPolygon(jendela_kiri,4,putih);fillPolygon(jendela_kanan,4,putih);

}

Dst… samapai b_kota16

Untuk cuplikan source code pembuatan bayangan jembatan, sebagai berikut :

//bay_kotak persegi panjang jembatan bawahcolor_t satu = {0.6, 0.4, 0.2};


point2D_t kotak1[4] = {{0,296},{0,244},{1000,244},{1000,296}};

fillPolygon(kotak1,4,satu);

//bay_tower1color_t dua = {1, 0.8, 0.32941};point2D_t kotak2[4] = {{286,236},{369,236},

{369,118},{286,118}};fillPolygon(kotak2,4,dua);

//bay_segitiga besaarcolor_t tiga = {0.4, 0.4, 0.4};point2D_t segitiga1[3] = {{372,111},{322,18},

{284,111}};fillPolygon(segitiga1,3,tiga);

//bay_kotak persegi panjang berdiri 1color_t empat = {1, 0.8, 0.32941};point2D_t kotak3a[4] = {{285,111},{298,111},

{298,80},{285,80}};fillPolygon(kotak3a,4,empat);

//bay_segitiga kecil 1color_t lima = {0.4, 0.4, 0.4};point2D_t segitiga2a[3] = {{280,80},{304,80},

{290,46}};fillPolygon(segitiga2a,3,lima);

//bay_kootak persegi panjang tidur 1color_t enam = {0.6, 0.4, 0.2};point2D_t kotak3b[4] = {{275,83},{308,83},

{308,80},{275,80}};fillPolygon(kotak3b,4,enam);

Dst ..

Untuk membuat supaya bayangan terlihat transparant maka dibutuhkan sebuah set color untuk opacity. Pada fungsi set color tersebut memanggil glColor4f yang berisi (warna r, warna g, warna b, dan tingkat opacity).

void setColor(color_t color,int opacity){glColor4f(color.r,color.g,color.b,opacity);


}

Kemudian saya membuat fungsi drawRiver:void drawRiver(){

point2D_t sungai[] = {{0,317},{0,0},{1000,0},{1000,317}};

glColor4f(0.31373, 0.56863, 0.82353, 0.485);glBegin(GL_POLYGON);for(int i=0;i<4;i++){

glVertex2f(sungai[i].x,sungai[i].y);}glEnd();

}

Pada fungsi drawRiver ini dibuat sebuah objek yang berisi koordinat untuk membentuk sebuah laut yang sama dengan laut yang sudah ada. Warna yang kita deklarasikan pun sama. Namun cara pemanggilan fungsi ini harus diletakkan paling belakang, karena untuk menutupi koordinat kota dan jembatan yang sudah kita buat secara terbalik menyerupai bayangan. Sehingga ketika di run hasilnya akan tampak transparasi. Dan jangan lupa tambahkan sorce code berikut pada main kita.

glEnable (GL_BLEND);glBlendFunc

(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);


Proyek Akhir Grafika Komputer Objek 2D

Documents

Transcript of Proyek Akhir Grafika Komputer Objek 2D