Latihan 3

#include
#include
#include
#include
#include
#include
#include

//bamabng siswanto
//nim:0910.031.802.045
//class:A-VI

#define MAXLINE 200
static float tick=0,tack=0;

// Definisi struktur data
typedef struct {
float x,y;
} point2D_t;

typedef struct {
float v[3];
} vector2D_t;

typedef struct {
float m[3][3];
} matrix2D_t;

typedef struct {
float r,g,b;
} color_t;

// Setting warna
void setColor(float r,float g,float b)
{
glColor3f(r,g,b);
}

void setColor(color_t col)
{
glColor3f(col.r,col.g,col.b);
}


vector2D_t point2vector(point2D_t pnt)
{
vector2D_t vec;
vec.v[0]=pnt.x;
vec.v[1]=pnt.y;
vec.v[2]=1.;
return vec;
}

point2D_t vector2point(vector2D_t vec)
{
point2D_t pnt;
pnt.x=vec.v[0];
pnt.y=vec.v[1];
return pnt;
}

matrix2D_t createIdentity(void)
{
matrix2D_t u;
int i,j;
for (i=0;i♥;i++)
{
for(j=0;j♥;j++)
u.m[i][j]=0.;
u.m[i][i]=1.;
}
return u;
}

matrix2D_t translationMTX(float dx,float dy)
{
matrix2D_t trans=createIdentity();
trans.m[0][2]=dx;
trans.m[1][2]=dy;
return trans;
}

matrix2D_t scalingMTX(float mx,float my)
{
matrix2D_t scale=createIdentity();
scale.m[0][0]=mx;
scale.m[1][1]=my;
return scale;
}

matrix2D_t rotationMTX(float theta)
{
matrix2D_t rotate=createIdentity();
float cs=cos(theta);
float sn=sin(theta);
rotate.m[0][0]=cs;
rotate.m[0][1]=-sn;
rotate.m[1][0]=sn;
rotate.m[1][1]=cs;
return rotate;
}

matrix2D_t operator * (matrix2D_t a, matrix2D_t b)
{
matrix2D_t c;
int i,j,k;
for (i=0;i♥;i++) for (j=0;j♥;j++)
{
c.m[i][j]=0;
for (k=0;k♥;k++)
c.m[i][j]+=a.m[i][k]*b.m[k][j];
}
return c;
}

vector2D_t operator * (matrix2D_t a, vector2D_t b)
{
vector2D_t c;
int i,j;
for (i=0;i♥;i++) {
c.v[i]=0;
for (j=0;j♥;j++)
c.v[i]+=a.m[i][j]*b.v[j];
}
return c;
}

// Fungsi-fungsi untuk menggambar
void drawDot(float x,float y){
glBegin(GL_POINTS);
glVertex2f(x,y);
glEnd();
}

void drawLine(float x1, float y1, float x2,float y2){
glBegin(GL_LINES);
glVertex2f(x1,y1);
glVertex2f(x2,y2);
glEnd();
}

void drawPolyline(point2D_t p[],int n){
glBegin(GL_LINE_STRIP);
for(int i=0;i glEnd();
}

void drawPolygon(point2D_t p[],int n){
glBegin(GL_LINE_LOOP);
for(int i=0;i glVertex2f(p[i].x,p[i].y);
glEnd();
}

void fillPolygon(point2D_t p[], color_t col,int n){
glBegin(GL_POLYGON);
setColor(col);
for(int i=0;i glEnd();
}

void gradatePolygon(point2D_t p[],color_t col[],int n){
glBegin(GL_POLYGON);
for(int i=0;i setColor(col[i]);
glVertex2f(p[i].x,p[i].y);
}
glEnd();
}

void centerPolygon(point2D_t p[], point2D_t pc, color_t col, color_t colp, int n)
{
for(int i = 0; i < n; i++)
{
glBegin(GL_LINE_STRIP);
setColor(colp);
glVertex2f(pc.x, pc.y);
setColor(col);
glVertex2f(p[i].x, p[i].y);
glEnd();
}
}


point2D_t interpolasi(point2D_t a,point2D_t b, float m)
{
point2D_t c;
c.x=m*a.x+(1.-m)*b.x;
c.y=m*a.y+(1.-m)*b.y;
return c;
}


static void createPolar(point2D_t p[],float r[])
{
for(int i=0;i<360;i++){
p[i].x=r[i]*cos(i/57.3);
p[i].y=r[i]*sin(i/57.3);
}
}


static void createCircle(point2D_t p[],float r)
{
for(int i=0;i<360;i++)
{
p[i].x=r*cos(i/57.3);
p[i].y=r*sin(i/57.3);
}
}

point2D_t interpolasi(point2D_t p1,point2D_t p2,int k,int n)
{
point2D_t q;
q.x=p1.x+(float)k*(p2.x-p1.x)/n;
q.y=p1.y+(float)k*(p2.y-p1.y)/n;
return q;
}


void userdraw()
{
/////////////////////////////////////////////////DEKLARASI/////////////////////////////////
static float x,y;int i,j,k;
point2D_t lingkaran[360],lingkaran1[360],lingkaran2[360];
vector2D_t vect_circle[360],vect_kotak[4],vect_kotak1[4],vec[4],vec1[4],vec2[4],vec3[4],vec4[4];
matrix2D_t trans,trans1, trans2,trans3,trans4;
matrix2D_t rot1, scale,scale1,scale2;point2D_t circle[360],circle1[360];
float s;
float x1,y1,x2,y2;
static float tick=0,tick1=0,tick2=0,tick3=0;double srad,r;
color_t putih={1,1,1};color_t hitam={0,0,0};color_t cyan={0.3,1,0.9};color_t hijau_muda={0.4,1,0.6};
color_t coklat={0.7,0.5,0};color_t kuning={1,1,0};color_t biru={0,0,1};color_t merah={1,0,0};
color_t put2={0.9,0.9,0.9};color_t abu={0.7,0.7,0.7};color_t hijau={0,1,0};color_t coklat_muda={0.8,0.6,0.5};
color_t ungu={1,0,1};
////////////////////////////////////////////DINDING///////////////////////////////
////////KIRI/////////
setColor(cyan);
glBegin(GL_POLYGON);
glVertex2f(-400,480);
setColor(putih);
glVertex2f(-400,0);
setColor(cyan);
glVertex2f(-640,-480);
glVertex2f(-640,480);
glEnd();
//////////KANAN//////
setColor(cyan);
glBegin(GL_POLYGON);
glVertex2f(400,480);
setColor(putih);
glVertex2f(400,0);
setColor(cyan);
glVertex2f(640,-480);
glVertex2f(640,480);
glEnd();
///BELAKANG
point2D_t dinding3[5] ={{-400,0},{-400,480},{400,480},{400,0}};
point2D_t garis[4]={{-400,200},{-400,150},{400,150},{400,200}};
fillPolygon(dinding3,hijau_muda,4);
setColor(0.7,0.5,0);
drawPolygon(dinding3,4);
fillPolygon(garis,hijau,4);
setColor(putih);
drawPolygon(garis,4);


//JENDELA
point2D_t dimensi_jendela[]={{-255,400},{-245,410},{245,410},{255,400}};
point2D_t jendela[]={{-250,100},{-250,400},{250,400},{250,100}};
point2D_t kayu_jendela1[]={{-30,100},{-30,400},{0,400},{0,100}};
point2D_t kayu_jendela2[]={{0,100},{0,400},{30,400},{30,100}};
point2D_t kayu_jendela3[]={{-250,350},{-250,320},{250,320},{250,350}};
fillPolygon(dimensi_jendela,abu,4);
fillPolygon(jendela,hitam,4);
glColor3f(1.,1.,1.);

///TITIK HUJAN
glPointSize(2);
for( int l=0;l<1000;l++ )
{
x1=-245*(float)rand()/RAND_MAX-10;
y1=400*(float)rand()/RAND_MAX-10;
drawDot(x1,y1);
x2=245*(float)rand()/RAND_MAX-10;
y2=400*(float)rand()/RAND_MAX-10;
drawDot(x2,y2);
}
fillPolygon(kayu_jendela3,coklat,4);
setColor(putih);
drawPolygon(kayu_jendela3,4);
fillPolygon(kayu_jendela1,coklat,4);
setColor(putih);
drawPolygon(kayu_jendela1,4);
fillPolygon(kayu_jendela2,coklat,4);
setColor(putih);
drawPolygon(kayu_jendela2,4);


//GORDEN
float a=(tick-100)/100.;
setColor(hijau_muda);
glBegin(GL_POLYGON);
glVertex2f(-255,50);setColor(coklat);
glVertex2f(-255,400);
glVertex2f(0,400);
glVertex2f(-250,390);
glVertex2f(-200,80);
glEnd();
setColor(hijau_muda);
glBegin(GL_POLYGON);
glVertex2f(255,50);
setColor(coklat);
glVertex2f(255,400);
glVertex2f(0,400);
glVertex2f(250,390);
glVertex2f(200,80);
glEnd();



//KARPET LUAR
glBegin(GL_POLYGON);
setColor(putih);
glVertex2f(-583,-500);
glVertex2f(583,-500);
glVertex2f(375,-10);
glVertex2f(-375,-10);
glEnd();
//KARPET tengah
glColor3f(0.8,0.,0.);
glBegin(GL_POLYGON);
glVertex2f(-550,-470);
glVertex2f(550,-470);
glVertex2f(365,-30);
glVertex2f(-365,-30);
glEnd();

//KARPET DALAM
setColor(putih);
glBegin(GL_POLYGON);
glVertex2f(350,-100);
glVertex2f(-350,-100);
glVertex2f(-464,-430);
glVertex2f(464,-430);
glEnd();

//KARPET DALAM
glColor3f(0.8,0.,0.);
glBegin(GL_POLYGON);
glVertex2f(280,-150);
glVertex2f(-280,-150);
glVertex2f(-330,-380);
glVertex2f(330,-380);
glEnd();
setColor(putih);
glBegin(GL_POLYGON);
glVertex2f(250,-180);
glVertex2f(-250,-180);
glVertex2f(-290,-350);
glVertex2f(290,-350);
glEnd();


///Gambar Bintang KARPET
point2D_t motif1[5],motif2[5],motif3[5],motif4[5],motif5[5];
point2D_t motif[5]={{-250,-100},{-320,-120},{-300,-140},{-280,-120}};
fillPolygon(motif,kuning,4);
setColor(0,0,0);
drawPolygon(motif,4);
trans = translationMTX(-50,-100);trans1=translationMTX(-50,-130);
trans2=translationMTX(680,-10);
trans3=translationMTX(680,-100);trans4=translationMTX(650,100);
scale1 = scalingMTX(1, 1);
for(k = 0; k <= 4; k++)
{
vec[k] = point2vector(motif[k]);
vec[k] = trans*scale1* vec[k];
vec1[k] =trans1*scale1* vec[k];
vec2[k]=trans2*scale1*vec[k];
vec3[k]=trans3*scale1*vec[k];
vec4[k]=trans4*scale1*vec[k];
motif1[k] =vector2point(vec[k]);
motif2[k] =vector2point(vec1[k]);
motif3[k] =vector2point(vec2[k]);
motif4[k]=vector2point(vec3[k]);
motif5[k] =vector2point(vec4[k]);

}
fillPolygon(motif1, biru,4);
setColor(ungu);
drawPolygon(motif1,4);

fillPolygon(motif2,merah,4);
setColor(ungu);
drawPolygon(motif2,4);

fillPolygon(motif3,kuning,4);
setColor(ungu);
drawPolygon(motif3,4);

fillPolygon(motif4,biru,4);
setColor(ungu);
drawPolygon(motif4,4);

fillPolygon(motif5,merah,4);
setColor(ungu);
drawPolygon(motif5,4);


//TEMPAT TIDUR
//Dipan
setColor(coklat);
glBegin(GL_POLYGON);
glVertex2f(150,250);
glVertex2f(-150,250);
setColor(abu);
glVertex2f(-150,0);
glVertex2f(150,0);
glEnd();
//3D Dipan
setColor(coklat);
glBegin(GL_POLYGON);
glVertex2f(140,260);
glVertex2f(-140,260);
setColor(abu);
glVertex2f(-150,250);
glVertex2f(150,250);
glEnd();
//Gambar kembang
for(j=0;j<360;j++)
{
srad=j*3.14/180;
r=120*sin(4*srad);
circle[j].x=(float)(r*cos(srad))+0;
circle[j].y=(float)(r*sin(srad))+120;
}
fillPolygon(circle,coklat,360);
setColor(putih);
drawPolygon(circle,360);
for(j=0;j<360;j++)
{
srad=j*3.14/180;
r=90*sin(2*srad);
circle[j].x=(float)(r*cos(srad))+0;
circle[j].y=(float)(r*sin(srad))+120;
}
fillPolygon(circle,coklat_muda,360);
setColor(putih);
drawPolygon(circle,360);
//Kasur
setColor(biru);
glBegin(GL_POLYGON);
glVertex2f(200,-400);
glVertex2f(-200,-400);
setColor(putih);
glVertex2f(-150,0);
glVertex2f(150,0);
glEnd();
//Dipan bawah
setColor(coklat);
glBegin(GL_POLYGON);
glVertex2f(200,-460);
glVertex2f(-200,-460);setColor(abu);
glVertex2f(-200,-400);
glVertex2f(200,-400);
glEnd();

//BANTAL
setColor(cyan);
glBegin(GL_POLYGON);
glVertex2f(90,30);
glVertex2f(-90,30);setColor(biru);
glVertex2f(-93,28);
glVertex2f(-90,25);
glVertex2f(-110,-30);
glVertex2f(-106,-35);
glVertex2f(106,-35);
glVertex2f(104,-30);
glVertex2f(90,25);
glVertex2f(93,28);
glEnd();


//MEJA

//Meja Kiri
setColor(0.7,0.5,0);
glBegin(GL_POLYGON);
glVertex2f(-150,50);
glVertex2f(-300,50);
glVertex2f(-350,-10);
setColor(abu);
glVertex2f(-150,-10);
glEnd();
// Kaki Meja Kiri
setColor(0.7,0.5,0);
glBegin(GL_POLYGON);
glVertex2f(-150,-10);
glVertex2f(-350,-10);
glVertex2f(-350,-100);
glVertex2f(-160,-100);
glVertex2f(-200,-10);
glEnd();
// Meja kanan
setColor(0.7,0.5,0);
glBegin(GL_POLYGON);
glVertex2f(150,50);
glVertex2f(300,50);
glVertex2f(350,-10);
setColor(abu);
glVertex2f(150,-10);
glEnd();
//Kaki Meja Kanan
setColor(0.7,0.5,0);
glBegin(GL_POLYGON) ;
glVertex2f(150,-10);
glVertex2f(350,-10);
glVertex2f(350,-100);
glVertex2f(160,-100);
glVertex2f(200,-10);
glEnd();
//LOKER
glColor3f(0.8,0.6,0);
glBegin(GL_POLYGON);
glVertex2f(-180,-30);
glVertex2f(-180,-80);
glVertex2f(-320,-80);
glVertex2f(-320,-30);
glEnd();
glColor3f(0.8,0.6,0);
glBegin(GL_POLYGON);
glVertex2f(180,-30);
glVertex2f(180,-80);
glVertex2f(320,-80);
glVertex2f(320,-30);
glEnd();
//PEGANGAN MEJA
setColor(hitam);
glBegin(GL_POLYGON);
glVertex2f(-280,-60);
glVertex2f(-220,-60);
glVertex2f(-220,-50);
glVertex2f(-280,-50);
glEnd();
setColor(hitam);
glBegin(GL_POLYGON);
glVertex2f(280,-60);
glVertex2f(220,-60);
glVertex2f(220,-50);
glVertex2f(280,-50);
glEnd();

///JAM DINGDONG
//point2D_t pusat = {200,50};
point2D_t jam[4]={{158,10},{158,90},{235,90},{235,10}};
fillPolygon(jam,putih,4);
setColor(merah);
drawPolygon(jam,4);
r=27;
for(i = 0; i < 360; i++)
{
s = i* 3.14 / 180;
lingkaran[i].x =(float)(r * cos(s))+200;
lingkaran[i].y =(float)(r * sin(s))+50;
}
fillPolygon(lingkaran, kuning, 360);
setColor(merah);
drawPolygon(lingkaran, 360);

//JARUM
point2D_t jarum[]={{0,0},{10,0},{10,-10},{0.-10},{0,0}};
point2D_t jarum1[4];
trans = translationMTX(200,50);

fillPolygon(jarum,hitam,4);
drawPolygon(jarum,4);
rot1 = rotationMTX(tick+1);
for(i=0;i<4;i++)
{
vec[i] = point2vector(jarum[i]);
vec[i] = trans*rot1* vec[i];
jarum1[i] = vector2point(vec[i]);
}
tick+=0.0001;

fillPolygon(jarum1,biru ,4 );
setColor(putih);
drawPolygon(jarum1, 4);

////////////////////////////////////SELIMUT/////////////////////////////////////////////
point2D_t selimut[]={{-200,-380},{-188,-400},{188,-400},{200,-380},{160,-100},{80,-70},{-80,-70},{-160,-100}};
fillPolygon(selimut,biru,8);
drawPolygon(selimut,8);


/////////////////////////////////////////TANGAN//////////////////////////////////////////
point2D_t tangan1[]= {{-70,-66},{-80,-80},{-80,-90},{-70,-91},{-50,-90},{-50,-80},{-55,-66}};
fillPolygon(tangan1,coklat_muda,7);
drawPolygon(tangan1,7);
point2D_t tangan2[]= {{70,-66},{80,-80},{80,-90},{70,-91},{50,-90},{50,-80},{55,-66}};
fillPolygon(tangan2,coklat_muda,7);
drawPolygon(tangan2,7);


////////////////////////////////////////////ORANG///////////////////////////////////////
////BAJU///
setColor(merah);
glBegin(GL_POLYGON);
glVertex2f(60,-68);
glVertex2f(-60,-68);
glVertex2f(-40,-35);
glVertex2f(40,-35);
glEnd();
///KEPALA///
point2D_t pusat={0,0};r=40;
for(i = 0; i < 360; i++)
{
s = i* 3.14 / 180;
lingkaran[i].x =pusat.x+(float)(r * cos(s));
lingkaran[i].y =pusat.y+(float)(r * sin(s));
}
fillPolygon(lingkaran, coklat_muda, 360);
setColor(hitam);
drawPolygon(lingkaran, 360);
///RAMBUT///
for(i = 0; i < 180; i++)
{
s = i* 3.14 / 180;
lingkaran[i].x =pusat.x+(float)(r * cos(s));
lingkaran[i].y =pusat.y+(float)(r * sin(s));
}
fillPolygon(lingkaran, hitam, 180);
setColor(hitam);
drawPolygon(lingkaran, 180);
//////////WAJAH//////////

/////MATA/////
drawLine(-10,-10,-20,-10);
drawLine(10,-10,20,-10);
////////HIDUNG//////////
r=2;
for(i = 0; i < 360; i++)
{
s = i* 3.14 / 180;
lingkaran[i].x =0+(float)(r * cos(s));
lingkaran[i].y =-15+(float)(r * sin(s));
}
fillPolygon(lingkaran, coklat, 360);
setColor(hitam);
drawPolygon(lingkaran, 360);
////////MULUT/////////
point2D_t mulut[360];
point2D_t hasil[36];
r=5;
for(i = 0; i < 360; i++)
{
s = i* 3.14 / 180;
mulut[i].x =0+(float)(r * cos(s));
mulut[i].y =-30+(float)(r * sin(s));
}
fillPolygon(lingkaran, coklat, 360);
setColor(hitam);
drawPolygon(lingkaran, 360);
point2D_t gerak[360];
r=10;
for(i = 0; i < 360; i++)
{
s = i* 3.14 / 180;
gerak[i].x =-0+(float)(r * cos(s));
gerak[i].y =-30+(float)(r * sin(s));
}

a=(tick2-100)/100.;

glColor3f(0,0,0);
if(tick2<100)
{
for(i=0;i<360;i++) hasil[i]=mulut[i];
}
else
{
if(tick2<200)
{
for(i=0;i<360;i++)
hasil[i]=interpolasi(gerak[i],mulut[i],a);
}
else
{
for(i=0;i<360;i++) hasil[i]=mulut[i];
tick2=0;
}
}
tick2=(tick2+1);
fillPolygon(hasil,coklat,360);
setColor(hitam);
drawPolygon(hasil,360);


///////////////////////GERAK SELIMUT&TANGAN////////////////////
point2D_t gerak_selimut[]={{-200,-380},{-188,-400},{188,-400},{200,-380},{160,-70}
,{80,-40},{-80,-40},{-160,-70},{-200,-350}};
point2D_t gerak_tangan1[]={{-70,-30},{-80,-40},{-80,-50},{-70,-51},{-50,-50},{-50,-50}
,{-55,-30},{-70,-30}};
point2D_t gerak_tangan2[]={{70,-30},{80,-40},{80,-50},{70,-51},{50,-50},{50,-50}
,{55,-30},{70,30}};
point2D_t hasil_selimut[8],hasil_tangan1[8],hasil_tangan2[8];

a=(tick2-100)/100.;

glColor3f(0,0,0);
if(tick3<100)
{
for(i=0;i<8;i++)
//hasil_selimut[i]=selimut[i];
hasil_tangan1[i]=tangan1[i];
hasil_tangan2[i]=tangan2[i];

}
else
{
if(tick3<200)
{
for(i=0;i<8;i++){
hasil_selimut[i]=interpolasi(gerak_selimut[i],selimut[i],a);
hasil_tangan1[i]=interpolasi(gerak_tangan1[i],tangan1[i],a);
hasil_tangan2[i]=interpolasi(gerak_tangan2[i],tangan2[i],a);}


}
else
{
for(i=0;i<8;i++)
//hasil_selimut[i]=selimut[i];
hasil_tangan1[i]=tangan1[i];
hasil_tangan2[i]=tangan2[i];

tick3=0;

}
}
tick3=(tick3+1);
fillPolygon(hasil_selimut,biru,8);
drawPolygon(hasil_selimut,8);
fillPolygon(hasil_tangan1,coklat_muda,7);
setColor(coklat);
drawPolygon(hasil_tangan1,7);
fillPolygon(hasil_tangan2,coklat_muda,7);
setColor(coklat);
drawPolygon(hasil_tangan2,7);

///////////////////////////////////////LAMPU//////////////////////////////////////////
////KAP LAMPU KANAN/////////
setColor(biru);
glBegin(GL_POLYGON);
glVertex2f(220,100);
glVertex2f(320,100);
setColor(putih);
glVertex2f(300,150);
glVertex2f(240,150);
glEnd();


/////TIANG LAMPU//////////
setColor(putih);
glBegin(GL_POLYGON);
glVertex2f(260,100);
glVertex2f(280,100);
setColor(hitam);
glVertex2f(280,20);
glVertex2f(260,20);
glEnd();
//////KAKI LAMPU KANAN//////
setColor(hitam);
glBegin(GL_POLYGON);
glVertex2f(260,20);
glVertex2f(255,5);
glVertex2f(288,5);
glVertex2f(280,20);
glEnd();
//////KAP LAMPU KIRI///////
setColor(biru);
glBegin(GL_POLYGON);
glVertex2f(-220,100);
glVertex2f(-320,100);
setColor(putih);
glVertex2f(-300,150);
glVertex2f(-240,150);
glEnd();
//////TIANG LAMPU KIRI/////
setColor(putih);
glBegin(GL_POLYGON);
glVertex2f(-260,100);
glVertex2f(-280,100);
setColor(hitam);
glVertex2f(-280,20);
glVertex2f(-260,20);
glEnd();
//////KAKI LAMPU KIRI//////
setColor(hitam);
glBegin(GL_POLYGON);
glVertex2f(-260,20);
glVertex2f(-255,5);
glVertex2f(-288,5);
glVertex2f(-280,20);
glEnd();


///////////////////////////////////KIPAS ANGIN////////////////////////////////////
point2D_t kotak[4]={{280,250.},{380,250},{380,350},{280,350}};
point2D_t kotak1[4]={{270,240.},{390,240},{390,360},{270,360}};
point2D_t kotak2[4];
point2D_t kotak3[4];
setColor(merah);
fillPolygon(kotak1,abu,4);
setColor(hitam);
drawPolygon(kotak1,4);
setColor(merah);
fillPolygon(kotak,putih,4);
setColor(hitam);
drawPolygon(kotak,4);

setColor(1,0,0.);
for(j=0;j<360;j++)
{
srad=j*3.14/180;
r=50*sin(4*srad);
circle[j].x=(float)(r*cos(srad-tick))+330;
circle[j].y=(float)(r*sin(srad-tick))+300;
}
fillPolygon(circle,biru,360);
setColor(putih);
drawPolygon(circle,360);
tick+=0.1;

trans = translationMTX(-650,0);
scale = scalingMTX(1, 1);
for(k = 0; k <= 4; k++)
{
vect_kotak1[k] = point2vector(kotak1[k]);
vect_kotak1[k] = trans*scale* vect_kotak1[k];
kotak3[k] =vector2point(vect_kotak1[k]);
}
fillPolygon(kotak3,abu,4);
setColor(hitam);
drawPolygon(kotak3,4);


for(k = 0; k <= 4; k++)
{
vect_kotak[k] = point2vector(kotak[k]);
vect_kotak[k] = trans*scale* vect_kotak[k];
kotak2[k] =vector2point(vect_kotak[k]);
}
fillPolygon(kotak2,putih,4);
setColor(hitam);
drawPolygon(kotak2,4);

for(k = 0; k <= 360; k++)
{
vect_circle[k] = point2vector(circle[k]);
vect_circle[k] = trans*scale* vect_circle[k];
circle1[k] =vector2point(vect_circle[k]);

}
fillPolygon(circle1, biru,360);
setColor(putih);
drawPolygon(circle1,360);
setColor(merah);


////////////////////////////////////TELEPON/////////////////////////////////////////
//TELPON BAWAH ///
point2D_t telpon[6]={{-160,5},{-160,15},{-180,70},{-220,70},{-240,15},{-240,5}};
fillPolygon(telpon,ungu,6);
setColor(putih);
drawPolygon(telpon,6);
///NOMOR TELPON ////
r=20;
for(i = 0; i < 360; i++)
{
s = i* 3.14 / 180;
lingkaran[i].x =-200+(float)(r * cos(s));
lingkaran[i].y =40+(float)(r * sin(s));
}
fillPolygon(lingkaran,putih, 360);
setColor(hitam);
drawPolygon(lingkaran, 360);
for(i = 0; i < 360; i++)
{
s = i* 3.14 / 180;
r=120*sin(4*srad);
lingkaran1[i].x =-200+(float)(r * cos(s));
lingkaran1[i].y =40+(float)(r * sin(s));
}
fillPolygon(lingkaran1,putih, 360);
setColor(hitam);
drawPolygon(lingkaran1, 360);
///GAGANG TELPON///
point2D_t gagang_telpon[10]={{-220,70},{-220,65},{-240,65},{-240,80},{-230,83},{-170,83}
,{-160,80},{-160,65},{-180,65},{-180,70}};
fillPolygon(gagang_telpon,ungu,10);
setColor(putih);
drawPolygon(gagang_telpon,10);


///////////////////////////////////////////LEMARI////////////////////////////////////
///PINTU DEPAN /////
color_t coklet={0.8,0.5,0};
point2D_t pintu[]={{400,450},{400,-95},{550,-430},{550,300},{400,450}};
fillPolygon(pintu,coklat,4);
setColor(hitam);
drawPolygon(pintu,4);
///DIMENSI 3 PINTU SAMPING
point2D_t dimensi_pintu1[]={{550,-430},{620,-430},{620,300},{550,300}};
fillPolygon(dimensi_pintu1,coklat,4);
setColor(hitam);
drawPolygon(dimensi_pintu1,4);
///DIMENSI PINTU ATAS ///
point2D_t dimensi_pintu2[]={{620,300},{550,300},{400,450},{460,450}};
fillPolygon(dimensi_pintu2,coklat,4);
setColor(hitam);
drawPolygon(dimensi_pintu2,4);
///LOKER///
point2D_t loker1[]={{420,400},{420,200},{530,70},{530,280}};
fillPolygon(loker1,coklat_muda,4);
setColor(hitam);
drawPolygon(loker1,4);

point2D_t loker2[]={{420,-100},{420,150},{530,0},{530,-320}};
fillPolygon(loker2,coklat_muda,4);
setColor(hitam);
drawPolygon(loker2,4);

point2D_t tarikan[2]={{430,350},{430,250}};
setColor(hitam);
drawPolygon(tarikan,2);
point2D_t tarikan1[2];
trans =translationMTX(0,-450);
scale=scalingMTX(1.,1.5);
for(i=0;i<2;i++)
{
vec[i] = point2vector(tarikan[i]);
vec[i] = trans*scale* vec[i];
tarikan1[i] = vector2point(vec[i]);
}
setColor(hitam);
drawPolygon(tarikan1, 2);



// drawLine();

///////////////////////////////////////////LEMARI KIRI////////////////////////////////////
///PINTU DEPAN /////
point2D_t pintu_kiri[]={{-400,450},{-400,-95},{-550,-430},{-550,300},{-400,450}};
fillPolygon(pintu_kiri,coklat,4);
setColor(hitam);
drawPolygon(pintu_kiri,4);
///DIMENSI 3 PINTU SAMPING
point2D_t dimensi_pintu_kiri1[]={{-550,-430},{-620,-430},{-620,300},{-550,300}};
fillPolygon(dimensi_pintu_kiri1,coklat,4);
setColor(hitam);
drawPolygon(dimensi_pintu_kiri1,4);
///DIMENSI PINTU ATAS ///
point2D_t dimensi_pintu_kiri2[]={{-620,300},{-550,300},{-400,450},{-460,450}};
fillPolygon(dimensi_pintu_kiri2,coklat,4);
setColor(hitam);
drawPolygon(dimensi_pintu_kiri2,4);
///LOKER///
point2D_t loker_kiri1[]={{-420,400},{-420,200},{-530,70},{-530,280}};
fillPolygon(loker_kiri1,coklat_muda,4);
setColor(hitam);
drawPolygon(loker1,4);
point2D_t loker_kanan2[]={{-420,-100},{-420,150},{-530,0},{-530,-320}};
fillPolygon(loker_kanan2,coklat_muda,4);
setColor(hitam);
drawPolygon(loker_kanan2,4);

point2D_t tarikan_kiri1[2]={{-430,350},{-430,250}};
setColor(hitam);
drawPolygon(tarikan_kiri1,2);
point2D_t tarikan_kiri2[2];
trans =translationMTX(0,-450);
scale=scalingMTX(1.,1.5);
for(i=0;i<2;i++)
{
vec[i] = point2vector(tarikan_kiri1[i]);
vec[i] = trans*scale* vec[i];
tarikan_kiri2[i] = vector2point(vec[i]);
}
setColor(hitam);
drawPolygon(tarikan_kiri2, 2);


//GORDEN LUAR
color_t warnaget[]={{1,1,1},{1,0,1},{1,1,1}};
color_t warnagete[]={{0,1,0},{1,1,0},{1,1,1}};
point2D_t gorden1[]={{-640,480},{-400,480},{-600,0},{-500,-480},{-640,-550}};
setColor(biru);
gradatePolygon(gorden1,warnaget,5);
drawPolygon(gorden1,5);
point2D_t gorden2[]={{640,480},{400,480},{600,0},{500,-480},{640,-550}};
gradatePolygon(gorden2,warnaget,5);
drawPolygon(gorden2,5);
/////TUTUP////////
point2D_t tutup1[]={{-570,35},{-580,50},{-640,30},{-640,0}};
gradatePolygon(tutup1,warnagete,4);
drawPolygon(tutup1,4);
point2D_t tutup2[]={{570,35},{580,50},{640,30},{640,0}};
gradatePolygon(tutup2,warnagete,4);
drawPolygon(tutup2,4);



point2D_t gerak1[]={{-640,480},{-400,480},{-600,0},{-500,-550},{-640,-550}};
point2D_t hasil1[5];
point2D_t gerak2[]={{640,480},{400,480},{600,0},{500,-550},{640,-550}};
point2D_t hasil2[5];
point2D_t gerak3[]={{-570,30},{-580,50},{-640,30},{-640,0}};
point2D_t hasil3[5];
point2D_t gerak4[]={{570,30},{580,50},{640,30},{640,0}};
point2D_t hasil4[5];

a=(tick1-100)/100.;
if(tick1<1000){
for(i=0;i<5;i++)
{
hasil1[i]=interpolasi(gerak1[i],gorden1[i],a);
hasil2[i]=interpolasi(gerak2[i],gorden2[i],a);
hasil3[i]=interpolasi(gerak3[i],tutup1[i],a);
hasil4[i]=interpolasi(gerak4[i],tutup2[i],a);
tick1=(tick1+1);

}
gradatePolygon(hasil1,warnaget,5);
drawPolygon(hasil1,8);
gradatePolygon(hasil2,warnaget,5);
drawPolygon(hasil2,8);
gradatePolygon(hasil3,warnagete,4);
drawPolygon(hasil3,4);
gradatePolygon(hasil4,warnagete,4);
drawPolygon(hasil4,4);
}
else{
tick1=0;
}

}

void display(void)
{
static int mus=1;


glClear(GL_COLOR_BUFFER_BIT);

userdraw();
glutSwapBuffers();
}

int main (int argc, char ** argv) {
// insert code here...
glutInit(&argc,argv); //inisialisasi toolkit
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(900,650);
glutCreateWindow("bambang siswanto");
glClearColor(1.,0.9,0.3,0.5);//
gluOrtho2D(-640,640,-550,480);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

By. Bem Aza  --- Post -- Mhs -- Stmik-Amik Riau