API tools faq
paste
iFirdausku

Grafika Komputer OpenGL C++ Project Roket 2D

iFirdausku
Nov 17th, 2016
1,815
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 44.04 KB | None | 0 0
raw download clone embed print report
  1. #include
  2.  
  3. #include
  4.  
  5. #include "glut.h"
  6.  
  7. #include
  8.  
  9. #include
  10.  
  11. #include
  12.  
  13. #include
  14.  
  15.  
  16. typedef struct
  17.  
  18. {      float x;
  19.  
  20.        float y;
  21.  
  22. }point2D_t;
  23.  
  24.  
  25. typedef struct
  26.  
  27. {
  28.  
  29.        float v[3];
  30.  
  31. }vector2D_t;
  32.  
  33.  
  34. typedef struct
  35.  
  36.  {
  37.  
  38.        float m[3][3];
  39.  
  40. } matrix2D_t;
  41.  
  42.  
  43. typedef struct
  44.  
  45. {
  46.  
  47.        float r,g,b;
  48.  
  49. } color_t;
  50.  
  51.  
  52.  
  53. point2D_t Vector2Point1(vector2D_t vec)
  54.  
  55. {
  56.  
  57.        point2D_t pnt;
  58.  
  59.        pnt.x=vec.v[0];
  60.  
  61.        pnt.y=vec.v[1];
  62.  
  63.        return pnt;
  64.  
  65. }
  66.  
  67.  
  68. vector2D_t Point2Vector1(point2D_t pnt)
  69.  
  70. {
  71.  
  72.        vector2D_t vec;
  73.  
  74.        vec.v[0]=pnt.x;
  75.  
  76.        vec.v[1]=pnt.y;
  77.  
  78.        vec.v[2]=1.;
  79.  
  80.        return vec;
  81.  
  82. }
  83.  
  84.  
  85.  
  86. void setColor(float r,float g,float b)
  87.  
  88. {
  89.  
  90.        glColor3f(r,g,b);
  91.  
  92. }
  93.  
  94.  
  95. void setColor(color_t col)
  96.  
  97. {
  98.  
  99.        glColor3f(col.r,col.g,col.b);
  100.  
  101. }
  102.  
  103.  
  104. //fungsi untuk membuat titik
  105.  
  106. void drawDot(float x, float y)
  107.  
  108. {
  109.  
  110.      
  111.  
  112.        glPointSize(3);
  113.  
  114.        glBegin(GL_POINTS);
  115.  
  116.        glVertex2f(x,y);
  117.  
  118.        glEnd();
  119.  
  120. }
  121.  
  122.  
  123. //fungsi untuk membuat garis
  124.  
  125. void drawLine(float x1, float y1, float x2, float y2)
  126.  
  127. {
  128.  
  129.      
  130.  
  131.        glBegin(GL_LINES);
  132.  
  133.        glVertex2f(x1,y1);
  134.  
  135.        glVertex2f(x2,y2);
  136.  
  137.        glEnd();
  138.  
  139. }
  140.  
  141.  
  142. //fungsi yang digunakan untuk menggambar garis
  143.  
  144. void drawPolyline(point2D_t p[], int n)
  145.  
  146. {
  147.  
  148.        int i;
  149.  
  150.        glBegin(GL_LINE_STRIP);
  151.  
  152.        for(i=0;i<n;i++)
  153.  
  154.               glVertex2f(p[i].x,p[i].y);
  155.  
  156.        glEnd();
  157.  
  158. }
  159.  
  160.  
  161.  //fungsi untuk menggambar garis dengan bentuk kurva tertutup
  162.  
  163. void drawPolygon(point2D_t p[], int n)
  164.  
  165. {
  166.  
  167.        int i;
  168.  
  169.        glBegin(GL_LINE_LOOP);
  170.  
  171.        for(i=0;i<n;i++)
  172.  
  173.               glVertex2f(p[i].x,p[i].y);
  174.  
  175.        glEnd();
  176.  
  177. }
  178.  
  179.  
  180. //fungsi untuk mewarnai area poligon dengan satu warna
  181.  
  182. void fillPolygon(point2D_t pnt[],int n, color_t color)
  183.  
  184. {
  185.  
  186.    int i;
  187.  
  188.    setColor(color);
  189.  
  190.    glBegin(GL_POLYGON);
  191.  
  192.         for (i=0;i<n;i++) {
  193.  
  194.           glVertex2f(pnt[i].x, pnt[i].y);
  195.  
  196.         }
  197.  
  198.    glEnd();
  199.  
  200. }
  201.  
  202.  
  203. //fungsi yang menghasilkan efek gradasi jika digunakan untuk mewarnai pada poligon
  204.  
  205. void gradatePolygon(point2D_t p[], int n,color_t col[])
  206.  
  207. {
  208.  
  209.        int i;
  210.  
  211.        glBegin(GL_POLYGON);
  212.  
  213.        for(i=0;i<n;i++)
  214.  
  215.        {
  216.  
  217.               setColor(col[i]);
  218.  
  219.               glVertex2f(p[i].x,p[i].y);
  220.  
  221.        }
  222.  
  223.        glEnd();
  224.  
  225. }
  226.  
  227.  
  228. //fungsi yang menghasilkan efek gradasi jika digunakan untuk mewarnai pada lingkaran
  229.  
  230. void centerPolygon(point2D_t p[], point2D_t pc,color_t col,color_t colp, int n)
  231.  
  232. {
  233.  
  234.        int i;
  235.  
  236.        glBegin(GL_LINES);
  237.  
  238.               for(i=0;i<n;i++)
  239.  
  240.               {
  241.  
  242.                      setColor(colp);
  243.  
  244.                      glVertex2f(pc.x,pc.y);
  245.  
  246.                      setColor(col);
  247.  
  248.                      glVertex2f(p[i].x,p[i].y);
  249.  
  250.               }
  251.  
  252.        glEnd();
  253.  
  254. }
  255.  
  256.  
  257.  
  258. // Definisi dan pengolahan matrik
  259.  
  260. matrix2D_t createIdentity(void) {
  261.  
  262.        matrix2D_t u;
  263.  
  264.        int i,j;
  265.  
  266.        for (i=0;i
  267.  
  268.               for(j=0;j
  269.  
  270.               u.m[i][i]=1.;
  271.  
  272.        }
  273.  
  274.        return u;
  275.  
  276. }
  277.  
  278.  
  279. // untuk membuat efek translasi(bergerak)
  280.  
  281. matrix2D_t translationMTX(float dx,float dy)
  282.  
  283. {
  284.  
  285.        matrix2D_t trans=createIdentity();
  286.  
  287.        trans.m[0][2]=dx;
  288.  
  289.        trans.m[1][2]=dy;
  290.  
  291.        return trans;
  292.  
  293. }
  294.  
  295.  
  296. // untuk membuat efek scaling(berubah ukuran)
  297.  
  298. matrix2D_t scalingMTX(float mx,float my)
  299.  
  300. {
  301.  
  302.        matrix2D_t scale=createIdentity();
  303.  
  304.        scale.m[0][0]=mx;
  305.  
  306.        scale.m[1][1]=my;
  307.  
  308.        return scale;
  309.  
  310. }
  311.  
  312.  
  313. // untuk membuat efek rotasi(berputar)
  314.  
  315. matrix2D_t rotationMTX(float theta)
  316.  
  317. {
  318.  
  319.        matrix2D_t rotate=createIdentity();
  320.  
  321.        float cs=cos(theta);
  322.  
  323.        float sn=sin(theta);
  324.  
  325.        rotate.m[0][0]=cs; rotate.m[0][1]=-sn;
  326.  
  327.        rotate.m[1][0]=sn; rotate.m[1][1]=cs;
  328.  
  329.        return rotate;
  330.  
  331. }
  332.  
  333.  
  334. matrix2D_t operator * (matrix2D_t a, matrix2D_t b)
  335.  
  336. {
  337.  
  338.        matrix2D_t c;//c=a*b
  339.  
  340.        int i,j,k;
  341.  
  342.        for (i=0;ifor (j=0;j
  343.  
  344.               c.m[i][j]=0;
  345.  
  346.               for (k=0;k
  347.  
  348.                      c.m[i][j]+=a.m[i][k]*b.m[k][j];
  349.  
  350.        }
  351.  
  352.        return c;
  353.  
  354. }
  355.  
  356.  
  357. vector2D_t operator * (matrix2D_t a, vector2D_t b)
  358.  
  359. {
  360.  
  361.        vector2D_t c;//c=a*b
  362.  
  363.        int i,j;
  364.  
  365.        for (i=0;i
  366.  
  367.               c.v[i]=0;
  368.  
  369.               for (j=0;j
  370.  
  371.                      c.v[i]+=a.m[i][j]*b.v[j];
  372.  
  373.        }
  374.  
  375.        return c;
  376.  
  377. }
  378.  
  379.  
  380. // fungsi untuk menampilkan tulisan
  381.  
  382. void bitmap_output(int x, int y, char *string, void *font,color_t color)
  383.  
  384. {
  385.  
  386.        int len, i;
  387.  
  388.        setColor(color);
  389.  
  390.        glRasterPos2f(x, y);
  391.  
  392.        len = (int) strlen(string);
  393.  
  394.        for (i = 0; i < len; i++) {
  395.  
  396.               glutBitmapCharacter(font, string[i]);
  397.  
  398.        }
  399.  
  400. }
  401.  
  402.  
  403. // fungsi yang digunakan untuk membuat ellipse
  404.  
  405. static void createEllipse(point2D_t p[],point2D_t p0,float r1,float r2)
  406.  
  407. {
  408.  
  409.        for(int i=0;i
  410.  
  411.               p[i].x=p0.x+r1*cos(i/57.3);
  412.  
  413.               p[i].y=p0.y+r2*sin(i/57.3);
  414.  
  415.        }
  416.  
  417. }
  418.  
  419.  
  420.  
  421.  
  422.  
  423.  
  424. void userdraw()
  425.  
  426. {
  427.  
  428.  
  429. //backgroud yang digunakan ada 2 yaitu untuk langit(wback) dan untuk tanahnya sendiri(wback2)
  430.  
  431.        matrix2D_t mat;
  432.  
  433.        vector2D_t vec;
  434.  
  435.        static float tick,tick2,tick3,tick4,tick5,t1,t2,t3,t4,t5,temp=0;
  436.  
  437.        int i;
  438.  
  439.      
  440.  
  441.        color_t
  442.  
  443.               putih={1,1,1},
  444.  
  445.               hitam={0,0,0},
  446.  
  447.               wback[4]={{0.6,0.8,1.0},{0.6,0.8,1.0},{0.6,0.8,1.0},{1.0,1.0,1.0}},
  448.  
  449.               wback2[4]={{1.0,1.0,1.0},{0.772,0.772,0.670},{0.286,0.220,0.149},{0.772,0.772,0.670}};
  450.  
  451.        point2D_t
  452.  
  453.               backgroud[4]= {{-400,300},{400,300},{400,-180},{-400,-180}},
  454.  
  455.               backgroud2[4]= {{-400,-181},{400,-181},{400,-250},{-400,-250}}
  456.  
  457.               ;
  458.  
  459.        gradatePolygon(backgroud,4,wback);
  460.  
  461.        gradatePolygon(backgroud2,4,wback2);
  462.  
  463.  
  464.  
  465.        glColor3f(1,1,1);
  466.  
  467.      
  468.  
  469.  
  470.  
  471. ////////////////////////////// AWAN ///////////////////////////////////////////////////////////////////
  472.  
  473.  
  474.  
  475.        color_t wawan ={0.6,0.7,1.0};
  476.  
  477.      
  478.  
  479.         point2D_t
  480.  
  481.                //kumpulan awan 1
  482.  
  483.                awan1[360],pawan1={100,100},
  484.  
  485.                awan2[360],pawan2={110,110},
  486.  
  487.                awan3[360],pawan3={90,115},
  488.  
  489.                awan4[360],pawan4={85,90},
  490.  
  491.                awan5[360],pawan5={115,102},
  492.  
  493.                
  494.  
  495.                //kumpulan awan 2
  496.  
  497.                awan6[360],pawan6={-220,110},
  498.  
  499.                awan7[360],pawan7={-230,130},
  500.  
  501.                awan8[360],pawan8={-210,135},
  502.  
  503.                awan9[360],pawan9={-205,120},
  504.  
  505.                awan10[360],pawan10={-235,122},
  506.  
  507.  
  508.                //kumpulan awan 3
  509.  
  510.                awan11[360],pawan11={220,60},
  511.  
  512.                awan12[360],pawan12={230,70},
  513.  
  514.                awan13[360],pawan13={210,75},
  515.  
  516.                awan14[360],pawan14={205,60},
  517.  
  518.                awan15[360],pawan15={235,62};
  519.  
  520.  
  521.        //implementasi awan 2 dan 3
  522.  
  523.        createEllipse(awan6,pawan6,50,4);
  524.  
  525.        createEllipse(awan7,pawan7,30,14);
  526.  
  527.        createEllipse(awan8,pawan8,90,15);
  528.  
  529.        createEllipse(awan9,pawan9,10,5);
  530.  
  531.        createEllipse(awan10,pawan10,40,10);
  532.  
  533.  
  534.        createEllipse(awan11,pawan11,100,5);
  535.  
  536.        createEllipse(awan12,pawan12,20,14);
  537.  
  538.        createEllipse(awan13,pawan13,50,15);
  539.  
  540.        createEllipse(awan14,pawan14,10,5);
  541.  
  542.        createEllipse(awan15,pawan15,40,10);
  543.  
  544.  
  545.      
  546.  
  547.        //implementasi untuk kumpulan awan 1 (terdapat efek translasi disini)
  548.  
  549.               //awan1
  550.  
  551.               createEllipse(awan1,pawan1,100,5);
  552.  
  553.               mat=translationMTX(0+tick2,0+tick2);
  554.  
  555.               for(i=0; i
  556.  
  557.               {
  558.  
  559.                      vec=Point2Vector1(awan1[i]);
  560.  
  561.                      vec=mat*vec;
  562.  
  563.                      awan1[i]=Vector2Point1(vec);
  564.  
  565.               }
  566.  
  567.               //awan2
  568.  
  569.               createEllipse(awan2,pawan2,50,10);
  570.  
  571.               mat=translationMTX(0+tick2,0+tick2);
  572.  
  573.               for(i=0; i
  574.  
  575.               {
  576.  
  577.                      vec=Point2Vector1(awan2[i]);
  578.  
  579.                      vec=mat*vec;
  580.  
  581.                      awan2[i]=Vector2Point1(vec);
  582.  
  583.               }
  584.  
  585.               //awan3
  586.  
  587.               createEllipse(awan3,pawan3,30,15);
  588.  
  589.               mat=translationMTX(0+tick2,0+tick2);
  590.  
  591.               for(i=0; i
  592.  
  593.               {
  594.  
  595.                      vec=Point2Vector1(awan3[i]);
  596.  
  597.                      vec=mat*vec;
  598.  
  599.                      awan3[i]=Vector2Point1(vec);
  600.  
  601.               }
  602.  
  603.               //awan4
  604.  
  605.               createEllipse(awan4,pawan4,40,5);
  606.  
  607.               mat=translationMTX(0+tick2,0+tick2);
  608.  
  609.               for(i=0; i
  610.  
  611.               {
  612.  
  613.                      vec=Point2Vector1(awan4[i]);
  614.  
  615.                      vec=mat*vec;
  616.  
  617.                      awan4[i]=Vector2Point1(vec);
  618.  
  619.               }
  620.  
  621.               //awan5
  622.  
  623.               createEllipse(awan5,pawan5,60,15);
  624.  
  625.               mat=translationMTX(0+tick2,0+tick2);
  626.  
  627.               for(i=0; i
  628.  
  629.               {
  630.  
  631.                      vec=Point2Vector1(awan5[i]);
  632.  
  633.                      vec=mat*vec;
  634.  
  635.                      awan5[i]=Vector2Point1(vec);
  636.  
  637.               }
  638.  
  639.  
  640.        // mewarnai awan
  641.  
  642.        fillPolygon(awan1,360,wawan);
  643.  
  644.        fillPolygon(awan2,360,wawan);
  645.  
  646.        fillPolygon(awan3,360,wawan);
  647.  
  648.        fillPolygon(awan4,360,wawan);
  649.  
  650.        fillPolygon(awan5,360,wawan);
  651.  
  652.        fillPolygon(awan6,360,wawan);
  653.  
  654.        fillPolygon(awan7,360,wawan);
  655.  
  656.        fillPolygon(awan8,360,wawan);
  657.  
  658.        fillPolygon(awan9,360,wawan);
  659.  
  660.        fillPolygon(awan10,360,wawan);
  661.  
  662.        fillPolygon(awan11,360,wawan);
  663.  
  664.        fillPolygon(awan12,360,wawan);
  665.  
  666.        fillPolygon(awan13,360,wawan);
  667.  
  668.        fillPolygon(awan14,360,wawan);
  669.  
  670.        fillPolygon(awan15,360,wawan);
  671.  
  672.  
  673. ////////////////////////////////////////////////////////////////////////////////////////////////////////
  674.  
  675.      
  676.  
  677.  
  678.      
  679.  
  680. ////////////////////////////////////BANGUNAN PERTAMA(SAMPING PESAWAT)///////////////////////////////////
  681.  
  682.        //inisialisasi warna
  683.  
  684.      
  685.  
  686.        color_t
  687.  
  688.               wvert[4]={{0.8,0.81,0.18},{0.8,0.81,0.18},{1.0,1.0,1.0},{1.0,1.0,1.0}},  
  689.  
  690.               whor[4]={{0.8,0.81,0.18},{0.8,0.81,0.18},{1.0,1.0,1.0},{1.0,1.0,1.0}},
  691.  
  692.               wantena={0.901,0.911,0.915},wtam={1,1,1};
  693.  
  694.      
  695.  
  696.        glColor3f(1,1,1);
  697.  
  698.        //inisialisasi bangunan arah vertikal
  699.  
  700.        point2D_t
  701.  
  702.               antena[360],pantena={-75,63},
  703.  
  704.               lamppun[4] = {{-48,120},{-48,125},{-52,125},{-52,120}},
  705.  
  706.               puncak[4] = {{-48,120},{-48,65},{-52,65},{-52,120}},
  707.  
  708.               kotak1 [4]= {{-45,65},{-45,45},{-55,45},{-55,65}},
  709.  
  710.               miring1 [4]= {{-20,50},{-23,50},{-45,65},{-45,68}},
  711.  
  712.               miring2 [4]= {{-70,50},{-73,50},{-55,68},{-55,65}},
  713.  
  714.               miring3 [4]= {{-85,45},{-88,45},{-55,67},{-55,67}},
  715.  
  716.               vert1 [4]= {{-20,50},{-20,-180},{-23,-180},{-23,50}},
  717.  
  718.               vert2 [4]= {{-25,50},{-25,-180},{-28,-180},{-28,50}},
  719.  
  720.               vert5 [4]= {{-34,50},{-34,-180},{-37,-180},{-37,50}},
  721.  
  722.               vert6 [4]= {{-40,50},{-40,-180},{-43,-180},{-43,50}},
  723.  
  724.               kotak2 [4]= {{-40,45},{-40,30},{-68,30},{-68,45}},
  725.  
  726.               kotak3 [4]= {{-45,30},{-45,-180},{-63,-180},{-63,30}},
  727.  
  728.               vert3 [4]= {{-70,50},{-70,-180},{-73,-180},{-73,50}},
  729.  
  730.               vert4 [4]= {{-85,45},{-85,-182},{-88,-182},{-88,45}}
  731.  
  732.               ;
  733.  
  734.  
  735.  
  736.      
  737.  
  738.        //warna bangunan arah vertikal
  739.  
  740.        gradatePolygon(puncak,4,wvert); gradatePolygon(kotak1,4,wvert);       gradatePolygon(miring1,4,wvert);
  741.  
  742.        gradatePolygon(miring2,4,wvert); gradatePolygon(miring3,4,wvert); gradatePolygon(vert1,4,wvert);
  743.  
  744.        gradatePolygon(vert2,4,wvert); gradatePolygon(vert5,4,wvert); gradatePolygon(vert6,4,wvert);
  745.  
  746.        gradatePolygon(vert2,4,wvert); gradatePolygon(kotak2,4,wvert); gradatePolygon(kotak3,4,wvert);
  747.  
  748.        gradatePolygon(vert3,4,wvert); gradatePolygon(vert4,4,wvert);
  749.  
  750.  
  751.  
  752.        //inisialisasi bangunan arah horisontal
  753.  
  754.        point2D_t
  755.  
  756.               hor1 [4]= {{-20,49},{-20,46},{-72,46},{-72,49}},
  757.  
  758.               hor1samping [4]= {{-72,48},{-72,46},{-85,43},{-85,45}},
  759.  
  760.  
  761.               hor2 [4]= {{-20,31},{-20,28},{-72,28},{-72,31}},
  762.  
  763.               mrg1 [4]= {{-20,31},{-22,28},{-47,46},{-45,46}},
  764.  
  765.               mrg2 [4]= {{-72,28},{-72,31},{-47,46},{-45,46}},
  766.  
  767.               hor2samping [4]= {{-72,30},{-72,28},{-85,23},{-85,25}},
  768.  
  769.               hor3 [4]= {{34,25},{29,15},{-75,15},{-75,25}}, //NB= dibuat translasi ke samping
  770.  
  771.               hor4 [4]= {{-20,11},{-20,8},{-72,8},{-72,11}},
  772.  
  773.               hor3samping [4]= {{-72,10},{-72,8},{-85,3},{-85,5}},
  774.  
  775.               hor5 [4]= {{-20,-11},{-20,-8},{-72,-8},{-72,-11}},
  776.  
  777.               mrg3 [4]= {{-20,-11},{-20,-8},{-47,11},{-47,8}},
  778.  
  779.               mrg4 [4]= {{-72,-8},{-72,-11},{-47,8},{-47,11}},
  780.  
  781.               hor4samping [4]= {{-72,-10},{-72,-8},{-85,-13},{-85,-15}},
  782.  
  783.               hor6 [4]= {{-20,-25},{-20,-28},{-72,-28},{-72,-25}},
  784.  
  785.               mrg5 [4]= {{-20,-25},{-20,-28},{-47,-10},{-47,-8}},
  786.  
  787.               mrg6 [4]= {{-72,-27},{-72,-25},{-47,-8},{-47,-10}},
  788.  
  789.               hor5samping [4]= {{-72,-25},{-72,-27},{-85,-32},{-85,-30}},
  790.  
  791.               hor7 [4]= {{-20,-45},{-20,-48},{-72,-48},{-72,-45}},
  792.  
  793.               hor6bay [4]= {{-5,-22},{-5,-33},{-120,-33},{-120,-22}},//NB: translasi ke samping sebelum hor3
  794.  
  795.               mrg7 [4]= {{-20,-45},{-20,-47},{-47,-27},{-47,-25}},
  796.  
  797.               mrg8 [4]= {{-72,-47},{-72,-45},{-47,-25},{-47,-27}},
  798.  
  799.               hor6samping [4]= {{-72,-45},{-72,-47},{-85,-52},{-85,-50}},
  800.  
  801.               hor8 [4]= {{-20,-65},{-20,-68},{-72,-68},{-72,-65}},
  802.  
  803.               mrg9 [4]= {{-20,-65},{-20,-67},{-47,-47},{-47,-45}},
  804.  
  805.               mrg10 [4]= {{-72,-67},{-72,-65},{-47,-45},{-47,-47}},
  806.  
  807.               hor7samping [4]= {{-72,-65},{-72,-67},{-85,-72},{-85,-70}},
  808.  
  809.               hor9 [4]= {{-20,-85},{-20,-88},{-72,-88},{-72,-85}},
  810.  
  811.               mrg11 [4]= {{-20,-85},{-20,-87},{-47,-67},{-47,-65}},
  812.  
  813.               mrg12 [4]= {{-72,-87},{-72,-85},{-47,-65},{-47,-67}},
  814.  
  815.               hor8samping [4]= {{-72,-85},{-72,-87},{-85,-92},{-85,-90}},
  816.  
  817.               hor10 [4]= {{-20,-105},{-20,-108},{-72,-108},{-72,-105}},
  818.  
  819.               mrg13 [4]= {{-20,-105},{-20,-107},{-47,-87},{-47,-85}},
  820.  
  821.               mrg14 [4]= {{-72,-107},{-72,-105},{-47,-85},{-47,-87}},
  822.  
  823.               hor9samping [4]= {{-72,-105},{-72,-107},{-85,-112},{-85,-110}};
  824.  
  825.      
  826.  
  827.  
  828.               mat=translationMTX(0-tick5,0);
  829.  
  830.               for(i=0; i
  831.  
  832.               {
  833.  
  834.                      vec=Point2Vector1(hor3[i]);
  835.  
  836.                      vec=mat*vec;
  837.  
  838.                      hor3[i]=Vector2Point1(vec);
  839.  
  840.               }
  841.  
  842.               mat=translationMTX(0+t2,0);
  843.  
  844.               for(i=0; i
  845.  
  846.               {
  847.  
  848.                      vec=Point2Vector1(hor6bay[i]);
  849.  
  850.                      vec=mat*vec;
  851.  
  852.                      hor6bay[i]=Vector2Point1(vec);
  853.  
  854.               }
  855.  
  856.              
  857.  
  858.               mat=translationMTX(0-t4,0); // gerakan kembali ke posisi awal
  859.  
  860.               for(i=0; i
  861.  
  862.               {
  863.  
  864.                      vec=Point2Vector1(hor6bay[i]);
  865.  
  866.                      vec=mat*vec;
  867.  
  868.                      hor6bay[i]=Vector2Point1(vec);
  869.  
  870.               }
  871.  
  872.  
  873.  
  874.        //warna bangunan arah horisontal
  875.  
  876.        gradatePolygon(hor1,4,whor); gradatePolygon(hor1samping,4,whor);
  877.  
  878.        gradatePolygon(hor2,4,whor); gradatePolygon(mrg1,4,whor); gradatePolygon(mrg2,4,whor);
  879.  
  880.        gradatePolygon(hor2samping,4,whor);
  881.  
  882.        gradatePolygon(hor3,4,whor); gradatePolygon(hor4,4,whor); gradatePolygon(hor3samping,4,whor);
  883.  
  884.        gradatePolygon(hor5,4,whor); gradatePolygon(mrg3,4,whor); gradatePolygon(mrg4,4,whor);
  885.  
  886.        gradatePolygon(hor4samping,4,whor);
  887.  
  888.        gradatePolygon(hor6,4,whor); gradatePolygon(mrg5,4,whor); gradatePolygon(mrg6,4,whor);
  889.  
  890.        gradatePolygon(hor5samping,4,whor);    
  891.  
  892.        gradatePolygon(hor7,4,whor); gradatePolygon(mrg7,4,whor); gradatePolygon(mrg8,4,whor);
  893.  
  894.        gradatePolygon(hor6samping,4,whor);
  895.  
  896.        gradatePolygon(hor8,4,whor); gradatePolygon(mrg9,4,whor); gradatePolygon(mrg10,4,whor);
  897.  
  898.        gradatePolygon(hor7samping,4,whor);
  899.  
  900.        gradatePolygon(hor9,4,whor); gradatePolygon(mrg11,4,whor); gradatePolygon(mrg12,4,whor);
  901.  
  902.        gradatePolygon(hor8samping,4,whor);
  903.  
  904.        gradatePolygon(hor10,4,whor); gradatePolygon(mrg13,4,whor); gradatePolygon(mrg14,4,whor);
  905.  
  906.        gradatePolygon(hor9samping,4,whor);gradatePolygon(hor6bay,4,whor);
  907.  
  908.  
  909.  
  910.        //antena
  911.  
  912.        createEllipse(antena,pantena,13,15);
  913.  
  914.        fillPolygon(antena,360,wantena);
  915.  
  916.        setColor(0.286,0.220,0.149);
  917.  
  918.        drawLine(-80,63,-73,77);
  919.  
  920.        drawLine(-80,63,-73,49);
  921.  
  922.        drawLine(-80,64,-63,62);
  923.  
  924.        drawLine(-80,64,-88,61);
  925.  
  926.        drawDot(-81,63);
  927.  
  928.      
  929.  
  930.  
  931.  
  932.  
  933. /////////////////////////////////////////////////////////////////////////////////////////////////////////
  934.  
  935.  
  936. /////////////////////////////// BANGUNAN KETIGA (SAMPING BANGUNAN PERTAMA) ////////////////////////////
  937.  
  938. //inisialisasi
  939.  
  940.        color_t
  941.  
  942.               wbacklift={0,0,0},
  943.  
  944.               wlift={0.901,0.656,0.915};
  945.  
  946.  
  947.        point2D_t
  948.  
  949.               kotakbag3 [4] ={{-100,0},{-100,-180},{-140,-180},{-140,0}},
  950.  
  951.               kotakbag3a [4] ={{-147,-1},{-147,-180},{-170,-180},{-170,-1}},
  952.  
  953.               lift [4] ={{-147,-170},{-147,-180},{-170,-180},{-170,-170}},//gerakan keatas
  954.  
  955.               liftka [4] ={{-148,-172},{-148,-180},{-158,-180},{-158,-172}},
  956.  
  957.               liftki [4] ={{-159,-172},{-159,-180},{-169,-180},{-169,-172}},
  958.  
  959.               liftsamping [4]= {{-120,-23},{-120,-32},{-110,-32},{-110,-23}},
  960.  
  961.               horbag3 [4] = {{-93,5},{-93,2},{-180,2},{-180,5}},
  962.  
  963.               horbag3a [4] = {{-93,-25},{-93,-27},{-180,-27},{-180,-25}},
  964.  
  965.               horbag3b [4] = {{-93,-65},{-93,-67},{-180,-67},{-180,-65}},
  966.  
  967.               horbag3c [4] = {{-93,-105},{-93,-107},{-180,-107},{-180,-105}},
  968.  
  969.               horbag3d [4] = {{-93,-145},{-93,-147},{-180,-147},{-180,-145}},
  970.  
  971.               verbag3 [4] ={{-93,5},{-93,-180},{-97,-180},{-97,5}},
  972.  
  973.               verbag3a [4] ={{-143,5},{-143,-180},{-146,-180},{-146,5}},
  974.  
  975.               verbag3b [4] ={{-153,5},{-153,-180},{-156,-180},{-156,5}},
  976.  
  977.               verbag3c [4] ={{-172,5},{-172,-180},{-175,-180},{-175,5}}
  978.  
  979.               ;
  980.  
  981.  
  982.               mat=translationMTX(0,0+t1);
  983.  
  984.               for(i=0; i
  985.  
  986.               {
  987.  
  988.                      vec=Point2Vector1(lift[i]);
  989.  
  990.                      vec=mat*vec;
  991.  
  992.                      lift[i]=Vector2Point1(vec);
  993.  
  994.               }
  995.  
  996.                      mat=translationMTX(0,0+t1);
  997.  
  998.               for(i=0; i
  999.  
  1000.               {
  1001.  
  1002.                      vec=Point2Vector1(liftka[i]);
  1003.  
  1004.                      vec=mat*vec;
  1005.  
  1006.                      liftka[i]=Vector2Point1(vec);
  1007.  
  1008.               }
  1009.  
  1010.                      mat=translationMTX(0,0+t1);
  1011.  
  1012.               for(i=0; i
  1013.  
  1014.               {
  1015.  
  1016.                      vec=Point2Vector1(liftki[i]);
  1017.  
  1018.                      vec=mat*vec;
  1019.  
  1020.                      liftki[i]=Vector2Point1(vec);
  1021.  
  1022.               }
  1023.  
  1024.  
  1025.               mat=translationMTX(0+t2,0); // bergerak bersama dengan t2
  1026.  
  1027.               for(i=0; i
  1028.  
  1029.               {
  1030.  
  1031.                      vec=Point2Vector1(liftsamping[i]);
  1032.  
  1033.                      vec=mat*vec;
  1034.  
  1035.                      liftsamping[i]=Vector2Point1(vec);
  1036.  
  1037.               }
  1038.  
  1039.              
  1040.  
  1041.               mat=translationMTX(0-t4,0); // bergerak bersama dengan t4
  1042.  
  1043.               for(i=0; i
  1044.  
  1045.               {
  1046.  
  1047.                      vec=Point2Vector1(liftsamping[i]);
  1048.  
  1049.                      vec=mat*vec;
  1050.  
  1051.                      liftsamping[i]=Vector2Point1(vec);
  1052.  
  1053.               }
  1054.  
  1055.  
  1056.               mat=translationMTX(0+t3,0);
  1057.  
  1058.               for(i=0; i
  1059.  
  1060.               {
  1061.  
  1062.                      vec=Point2Vector1(liftsamping[i]);
  1063.  
  1064.                      vec=mat*vec;
  1065.  
  1066.                      liftsamping[i]=Vector2Point1(vec);
  1067.  
  1068.               }
  1069.  
  1070.  
  1071. //implementasi
  1072.  
  1073.        //lift
  1074.  
  1075.        fillPolygon(kotakbag3a,4,wbacklift);
  1076.  
  1077.        fillPolygon(lift,4,wbacklift);
  1078.  
  1079.        fillPolygon(liftka,4,wlift);
  1080.  
  1081.        fillPolygon(liftki,4,wlift);
  1082.  
  1083.        fillPolygon(liftsamping,4,wbacklift);
  1084.  
  1085.      
  1086.  
  1087.  
  1088.        gradatePolygon(kotakbag3,4,wvert); gradatePolygon(verbag3,4,wvert); gradatePolygon(verbag3a,4,wvert);
  1089.  
  1090.        gradatePolygon(verbag3b,4,wvert); gradatePolygon(verbag3c,4,wvert);       gradatePolygon(horbag3,4,wvert);
  1091.  
  1092.        gradatePolygon(horbag3a,4,wvert); gradatePolygon(horbag3b,4,wvert);       gradatePolygon(horbag3c,4,wvert);
  1093.  
  1094.        gradatePolygon(horbag3d,4,wvert);
  1095.  
  1096.  
  1097. /////////////////////////////////////////////////////////////////////////////////////////////////////////
  1098.  
  1099.  
  1100. //////////////////////////////////////////// PESAWAT ////////////////////////////////////////////////////
  1101.  
  1102.  
  1103.        color_t
  1104.  
  1105.               wroket={0.93,0.51,0.09},
  1106.  
  1107.               wroket2={0.93,0.71,0.09},
  1108.  
  1109.               wroketbaw [4]={{0.93,0.51,0.09},{1,1,1},{1,1,1},{0.8,0.81,0.18}},
  1110.  
  1111.               wroketsam={0.73,0.41,0.09},whias={1,1,1},
  1112.  
  1113.               wroketsambaw [4]={{0.73,0.41,0.09},{1,1,1},{1,1,1},{0.73,0.41,0.09}},
  1114.  
  1115.               wpes={0.901,0.911,0.915},wpesbaw={0,0,0},wsyp={0.901,0.900,0.915},
  1116.  
  1117.               fire [4] = {{0.93,0.51,0.09},{0.8,0.81,0.18},{0.8,0.81,0.18},{0.93,0.51,0.09}},
  1118.  
  1119.               fire2 [4] = {{0.93,0.51,0.99},{0.8,0.81,0.68},{0.8,0.81,0.68},{0.93,0.51,0.99}};
  1120.  
  1121.  
  1122.        point2D_t
  1123.  
  1124.               //big roket
  1125.  
  1126.               roket[360],proket={52,0},
  1127.  
  1128.               p1 [4] = {{36,-107},{36,20},{68,20},{68,-107}},
  1129.  
  1130.               p2 [4] = {{36,-107},{32,-127},{72,-127},{68,-107}},
  1131.  
  1132.               p3 [4] = {{28,-140},{36,-127},{71,-127},{80,-140}},
  1133.  
  1134.              
  1135.  
  1136.               // small roket
  1137.  
  1138.               roketsam[360],proketsam={60,-18},
  1139.  
  1140.               psam1 [4] = {{52,0},{68,0},{68,-107},{52,-107}},
  1141.  
  1142.               psam2 [4] = {{68,-107},{72,-124},{48,-124},{52,-107}},
  1143.  
  1144.               psam3 [4] = {{74,-134},{70,-125},{50,-125},{46,-134}},
  1145.  
  1146.              
  1147.  
  1148.               // pesawat
  1149.  
  1150.               pUtama [4] ={{15,-30},{15,-102},{36,-102},{36,-30}},
  1151.  
  1152.               pEkor [4] = {{15,-77},{5,-110},{5,-120},{15,-98}},    
  1153.  
  1154.               pSayap [3] ={{35,-64},{45,-87},{35,-95}},
  1155.  
  1156.               pes[360],ppes={30,-42},
  1157.  
  1158.               pesbaw1[360],ppesbaw1={19,-104},
  1159.  
  1160.               pesbaw2[360],ppesbaw2={31,-104},
  1161.  
  1162.              
  1163.  
  1164.              
  1165.  
  1166.               //garis penghias
  1167.  
  1168.               p1hias [4] = {{36,22},{36,20},{68,20},{68,22}},
  1169.  
  1170.               p1hias2 [4] = {{36,-107},{36,-105},{68,-105},{68,-107}},
  1171.  
  1172.               p1hias3 [4] = {{36,5},{36,-12},{68,-12},{68,5}},
  1173.  
  1174.               psam1hias [4] = {{52,0},{68,0},{68,-2},{52,-2}},
  1175.  
  1176.               psam1hias2 [4] = {{52,-105},{68,-105},{68,-107},{52,-107}},
  1177.  
  1178.               pUtamahias [4] ={{20,-30},{20,-85},{22,-85},{22,-30}};
  1179.  
  1180.  
  1181.  
  1182.      
  1183.  
  1184.  
  1185.               //implementasi
  1186.  
  1187.               createEllipse(pes,ppes,15,35);
  1188.  
  1189.               mat=translationMTX(0,0+tick4);
  1190.  
  1191.               for(i=0; i
  1192.  
  1193.               {
  1194.  
  1195.                      vec=Point2Vector1(pes[i]);
  1196.  
  1197.                      vec=mat*vec;
  1198.  
  1199.                      pes[i]=Vector2Point1(vec);
  1200.  
  1201.               }
  1202.  
  1203.  
  1204.               createEllipse(roket,proket,16,50);
  1205.  
  1206.               mat=translationMTX(0,0+tick4);
  1207.  
  1208.               for(i=0; i
  1209.  
  1210.               {
  1211.  
  1212.                      vec=Point2Vector1(roket[i]);
  1213.  
  1214.                      vec=mat*vec;
  1215.  
  1216.                      roket[i]=Vector2Point1(vec);
  1217.  
  1218.               }
  1219.  
  1220.  
  1221.               createEllipse(roketsam,proketsam,8,35);
  1222.  
  1223.               mat=translationMTX(0,0+tick4);
  1224.  
  1225.               for(i=0; i
  1226.  
  1227.               {
  1228.  
  1229.                      vec=Point2Vector1(roketsam[i]);
  1230.  
  1231.                      vec=mat*vec;
  1232.  
  1233.                      roketsam[i]=Vector2Point1(vec);
  1234.  
  1235.               }
  1236.  
  1237.  
  1238.  
  1239.               createEllipse(pesbaw1,ppesbaw1,5,2);
  1240.  
  1241.               mat=translationMTX(0,0+tick4);
  1242.  
  1243.               for(i=0; i
  1244.  
  1245.               {
  1246.  
  1247.                      vec=Point2Vector1(pesbaw1[i]);
  1248.  
  1249.                      vec=mat*vec;
  1250.  
  1251.                      pesbaw1[i]=Vector2Point1(vec);
  1252.  
  1253.               }
  1254.  
  1255.  
  1256.  
  1257.               createEllipse(pesbaw2,ppesbaw2,5,2);
  1258.  
  1259.               mat=translationMTX(0,0+tick4);
  1260.  
  1261.               for(i=0; i
  1262.  
  1263.               {
  1264.  
  1265.                      vec=Point2Vector1(pesbaw2[i]);
  1266.  
  1267.                      vec=mat*vec;
  1268.  
  1269.                      pesbaw2[i]=Vector2Point1(vec);
  1270.  
  1271.               }
  1272.  
  1273.  
  1274.              
  1275.  
  1276.               mat=translationMTX(0,0+tick4);
  1277.  
  1278.               for(i=0; i
  1279.  
  1280.               {
  1281.  
  1282.                      vec=Point2Vector1(p1[i]);
  1283.  
  1284.                      vec=mat*vec;
  1285.  
  1286.                      p1[i]=Vector2Point1(vec);
  1287.  
  1288.               }
  1289.  
  1290.  
  1291.               mat=translationMTX(0,0+tick4);
  1292.  
  1293.               for(i=0; i
  1294.  
  1295.               {
  1296.  
  1297.                      vec=Point2Vector1(pSayap[i]);
  1298.  
  1299.                      vec=mat*vec;
  1300.  
  1301.                      pSayap[i]=Vector2Point1(vec);
  1302.  
  1303.               }
  1304.  
  1305.  
  1306.               mat=translationMTX(0,0+tick4);
  1307.  
  1308.               for(i=0; i
  1309.  
  1310.               {
  1311.  
  1312.                      vec=Point2Vector1(p2[i]);
  1313.  
  1314.                      vec=mat*vec;
  1315.  
  1316.                      p2[i]=Vector2Point1(vec);
  1317.  
  1318.               }
  1319.  
  1320.  
  1321.               mat=translationMTX(0,0+tick4);
  1322.  
  1323.               for(i=0; i
  1324.  
  1325.               {
  1326.  
  1327.                      vec=Point2Vector1(psam1[i]);
  1328.  
  1329.                      vec=mat*vec;
  1330.  
  1331.                      psam1[i]=Vector2Point1(vec);
  1332.  
  1333.               }
  1334.  
  1335.  
  1336.               mat=translationMTX(0,0+tick4);
  1337.  
  1338.               for(i=0; i
  1339.  
  1340.               {
  1341.  
  1342.                      vec=Point2Vector1(psam2[i]);
  1343.  
  1344.                      vec=mat*vec;
  1345.  
  1346.                      psam2[i]=Vector2Point1(vec);
  1347.  
  1348.               }
  1349.  
  1350.  
  1351.  
  1352.               mat=translationMTX(0,0+tick4);
  1353.  
  1354.               for(i=0; i
  1355.  
  1356.               {
  1357.  
  1358.                      vec=Point2Vector1(pUtama[i]);
  1359.  
  1360.                      vec=mat*vec;
  1361.  
  1362.                      pUtama[i]=Vector2Point1(vec);
  1363.  
  1364.               }
  1365.  
  1366.  
  1367.               mat=translationMTX(0,0+tick4);
  1368.  
  1369.               for(i=0; i
  1370.  
  1371.               {
  1372.  
  1373.                      vec=Point2Vector1(pEkor[i]);
  1374.  
  1375.                      vec=mat*vec;
  1376.  
  1377.                      pEkor[i]=Vector2Point1(vec);
  1378.  
  1379.               }
  1380.  
  1381.  
  1382.               mat=translationMTX(0,0+tick4);
  1383.  
  1384.               for(i=1; i
  1385.  
  1386.               {
  1387.  
  1388.                      vec=Point2Vector1(p3[i]);
  1389.  
  1390.                      vec=mat*vec;
  1391.  
  1392.                      p3[i]=Vector2Point1(vec);
  1393.  
  1394.               }
  1395.  
  1396.  
  1397.               mat=translationMTX(0,0+tick4);
  1398.  
  1399.               for(i=1; i
  1400.  
  1401.               {
  1402.  
  1403.                      vec=Point2Vector1(psam3[i]);
  1404.  
  1405.                      vec=mat*vec;
  1406.  
  1407.                      psam3[i]=Vector2Point1(vec);
  1408.  
  1409.               }
  1410.  
  1411.  
  1412.               mat=translationMTX(0,0+tick4);
  1413.  
  1414.               for(i=0; i
  1415.  
  1416.               {
  1417.  
  1418.                      vec=Point2Vector1(p1hias[i]);
  1419.  
  1420.                      vec=mat*vec;
  1421.  
  1422.                      p1hias[i]=Vector2Point1(vec);
  1423.  
  1424.               }
  1425.  
  1426.  
  1427.               mat=translationMTX(0,0+tick4);
  1428.  
  1429.               for(i=0; i
  1430.  
  1431.               {
  1432.  
  1433.                      vec=Point2Vector1(p1hias2[i]);
  1434.  
  1435.                      vec=mat*vec;
  1436.  
  1437.                      p1hias2[i]=Vector2Point1(vec);
  1438.  
  1439.               }
  1440.  
  1441.  
  1442.               mat=translationMTX(0,0+tick4);
  1443.  
  1444.               for(i=0; i
  1445.  
  1446.               {
  1447.  
  1448.                      vec=Point2Vector1(p1hias3[i]);
  1449.  
  1450.                      vec=mat*vec;
  1451.  
  1452.                      p1hias3[i]=Vector2Point1(vec);
  1453.  
  1454.               }
  1455.  
  1456.  
  1457.               mat=translationMTX(0,0+tick4);
  1458.  
  1459.               for(i=0; i
  1460.  
  1461.               {
  1462.  
  1463.                      vec=Point2Vector1(psam1hias[i]);
  1464.  
  1465.                      vec=mat*vec;
  1466.  
  1467.                      psam1hias[i]=Vector2Point1(vec);
  1468.  
  1469.               }
  1470.  
  1471.  
  1472.               mat=translationMTX(0,0+tick4);
  1473.  
  1474.               for(i=0; i
  1475.  
  1476.               {
  1477.  
  1478.                      vec=Point2Vector1(psam1hias2[i]);
  1479.  
  1480.                      vec=mat*vec;
  1481.  
  1482.                      psam1hias2[i]=Vector2Point1(vec);
  1483.  
  1484.               }
  1485.  
  1486.  
  1487.               mat=translationMTX(0,0+tick4);
  1488.  
  1489.               for(i=0; i
  1490.  
  1491.               {
  1492.  
  1493.                      vec=Point2Vector1(pUtamahias[i]);
  1494.  
  1495.                      vec=mat*vec;
  1496.  
  1497.                      pUtamahias[i]=Vector2Point1(vec);
  1498.  
  1499.               }
  1500.  
  1501.      
  1502.  
  1503.  
  1504.        // pewarnaan
  1505.  
  1506.        fillPolygon(pes,360,wpes);
  1507.  
  1508.        fillPolygon(roket,360,wroket);
  1509.  
  1510.        fillPolygon(p1,4,wroket);
  1511.  
  1512.        fillPolygon(p1hias,4,wpes);
  1513.  
  1514.        fillPolygon(pSayap,3,wsyp);
  1515.  
  1516.        gradatePolygon(p2,4,wroketbaw);
  1517.  
  1518.        fillPolygon(p1hias2,4,wpes);
  1519.  
  1520.        fillPolygon(p1hias3,4,wroket2);
  1521.  
  1522.        fillPolygon(roketsam,360,wroketsam);
  1523.  
  1524.        fillPolygon(psam1,4,wroketsam);
  1525.  
  1526.        fillPolygon(psam1hias,4,wroket2);
  1527.  
  1528.        gradatePolygon(psam2,4,wroketsambaw);
  1529.  
  1530.        fillPolygon(psam1hias2,4,wroket2);
  1531.  
  1532.        fillPolygon(pUtama,4,wpes);
  1533.  
  1534.        fillPolygon(pEkor,4,wpes);
  1535.  
  1536.        fillPolygon(pesbaw1,360,wpesbaw);
  1537.  
  1538.        fillPolygon(pesbaw2,360,wpesbaw);
  1539.  
  1540.        fillPolygon(pUtamahias,4,whias);
  1541.  
  1542.        gradatePolygon(p3,4,fire);
  1543.  
  1544.        gradatePolygon(psam3,4,fire2);
  1545.  
  1546.      
  1547.  
  1548.  
  1549. /////////////////////////////////////////////////////////////////////////////////////////////////////////
  1550.  
  1551.  
  1552.  
  1553.  
  1554. /////////////////////////////// BANGUNAN KEDUA (BAWAH PESAWAT) //////////////////////////////////////////////
  1555.  
  1556. //inisialisasi
  1557.  
  1558.        point2D_t
  1559.  
  1560.               horbag2 [4] ={{110,-125},{110,-123},{-72,-123},{-72,-125}},
  1561.  
  1562.               horbag2a [4] ={{110,-145},{110,-147},{-72,-147},{-72,-145}},
  1563.  
  1564.               horbag2b [4] ={{110,-153},{110,-157},{-72,-157},{-72,-153}},
  1565.  
  1566.               horbag2c [4] ={{110,-170},{110,-175},{-72,-175},{-72,-170}},
  1567.  
  1568.               verbag2 [4] ={{-10,-123},{-10,-180},{-12,-180},{-12,-123}},
  1569.  
  1570.               verbag2a [4] ={{108,-123},{108,-180},{110,-180},{110,-123}},
  1571.  
  1572.               kotakbag2a [4] = {{20,-125},{20,-180},{-5,-180},{-5,-125}},
  1573.  
  1574.               kotakbag2b [4] = {{80,-170},{80,-130},{22,-130},{22,-170}},
  1575.  
  1576.               kotakbag2c [4] = {{102,-180},{102,-125},{82,-125},{82,-180}},
  1577.  
  1578.               mrgbag2 [4]   = {{110,-123},{100,-123},{70,-110},{70,-105}};
  1579.  
  1580.  
  1581.  
  1582.        mat=translationMTX(0+tick5,0-tick5);
  1583.  
  1584.               for(i=2; i
  1585.  
  1586.               {
  1587.  
  1588.                      vec=Point2Vector1(mrgbag2[i]);
  1589.  
  1590.                      vec=mat*vec;
  1591.  
  1592.                      mrgbag2[i]=Vector2Point1(vec);
  1593.  
  1594.               }
  1595.  
  1596.      
  1597.  
  1598.  
  1599. // implementasi
  1600.  
  1601.        gradatePolygon(kotakbag2a,4,whor); gradatePolygon(kotakbag2b,4,whor); gradatePolygon(kotakbag2c,4,whor);
  1602.  
  1603.        gradatePolygon(horbag2,4,whor);   gradatePolygon(horbag2a,4,whor); gradatePolygon(horbag2b,4,whor);
  1604.  
  1605.        gradatePolygon(horbag2c,4,whor); gradatePolygon(verbag2,4,whor); gradatePolygon(verbag2a,4,whor);
  1606.  
  1607.        gradatePolygon(mrgbag2,4,whor);
  1608.  
  1609.  
  1610.  
  1611.      
  1612.  
  1613.  
  1614. ////////////////////////////////////////////////////////////////////////////////////////////////////////
  1615.  
  1616.  
  1617.  
  1618.  
  1619. /////////////////////////////// BANGUNAN KEEMPAT (LANDASAN PESAWAT) /////////////////////////////////////
  1620.  
  1621.  
  1622.        //warna landasan(dominan coklat)
  1623.  
  1624.        color_t
  1625.  
  1626.               wland = {0.772,0.772,0.670},
  1627.  
  1628.               wland2 [4] ={{1.0,1.0,1.0},{0.772,0.772,0.670},{0.286,0.220,0.149},{0.772,0.772,0.670}},
  1629.  
  1630.               wrum={0.033,0.585,0.052},bayangan={0.401,0.411,0.415},
  1631.  
  1632.               wlamp={0.286,0.220,0.149};
  1633.  
  1634.  
  1635.        point2D_t
  1636.  
  1637.               land [4] ={{-400,-179},{400,-179},{400,-182},{-400,-182}},
  1638.  
  1639.               land2 [4] ={{-400,-229},{400,-229},{400,-235},{-400,-235}},
  1640.  
  1641.               mrgbag4 [4] ={{-300,-182},{-296,-182},{-266,-250},{-270,-250}},
  1642.  
  1643.               mrgbag4a [4] ={{-100,-182},{-96,-182},{-52,-250},{-56,-250}},
  1644.  
  1645.               mrgbag4b [4] ={{200,-182},{196,-182},{264,-250},{268,-250}},
  1646.  
  1647.              
  1648.  
  1649.               //lampu
  1650.  
  1651.               lamp [7]={{320,-180},{320,-150},{310,-140},{310,-139},{321,-150},{321,-180},{320,-180}},
  1652.  
  1653.               lamp2[7]={{-320,-180},{-320,-150},{-330,-140},{-330,-141},{-321,-150},{-321,-180},{-320,-180}},
  1654.  
  1655.              
  1656.  
  1657.               //bayangan
  1658.  
  1659.               bay1[4]={{-173,-180},{-143,-180},{-113,-250},{-143,-250}},
  1660.  
  1661.               bay2[4]={{-140,-180},{-101,-180},{-60,-250},{-110,-250}},
  1662.  
  1663.               bay3[4]={{-96,-180},{-92,-180},{-44,-250},{-54,-250}},
  1664.  
  1665.               bay4[4]={{-86,-180},{-82,-180},{-34,-250},{-44,-250}},
  1666.  
  1667.               bay5[4]={{-72,-180},{-68,-180},{-16,-250},{-24,-250}},
  1668.  
  1669.               bay6[4]={{-62,-180},{-43,-180},{6,-250},{-14,-250}},
  1670.  
  1671.               bay7[4]={{-42,-180},{-40,-180},{10,-250},{7,-250}},
  1672.  
  1673.               bay8[4]={{-35,-180},{-33,-180},{17,-250},{15,-250}},
  1674.  
  1675.               bay9[4]={{-27,-180},{-25,-180},{26,-250},{24,-250}},
  1676.  
  1677.               bay10[4]={{-23,-180},{-21,-180},{30,-250},{28,-250}},
  1678.  
  1679.               bay11[4]={{-12,-180},{-10,-180},{40,-250},{38,-250}},
  1680.  
  1681.               bay12[4]={{-6,-180},{20,-180},{74,-250},{44,-250}},
  1682.  
  1683.               bay13[4]={{29,-190},{87,-190},{140,-250},{77,-250}},
  1684.  
  1685.               bay14[4]={{81,-180},{100,-180},{162,-250},{142,-250}},
  1686.  
  1687.               bay15[4]={{107,-180},{110,-180},{172,-250},{169,-250}},
  1688.  
  1689.               bay16[4]={{-173,-200},{-82,-200},{-70,-202},{-171,-202}},
  1690.  
  1691.               bay17[4]={{-62,-200},{128,-200},{130,-202},{-64,-202}},
  1692.  
  1693.               bay18[4]={{-58,-210},{138,-210},{140,-212},{-54,-212}}
  1694.  
  1695.               ;
  1696.  
  1697.              
  1698.  
  1699.  
  1700.      
  1701.  
  1702.        //rumput
  1703.  
  1704.        point2D_t
  1705.  
  1706.               rum1 [15]={{-400,-250},{-400,-230},{-390,-220},{-370,-215},{-360,-225},{-355,-223},{-350,-220},
  1707.  
  1708.                            {-340,-230},{-330,-225},{-320,-220},{-300,-225},{-290,-235},{-270,-215},{-260,-220},
  1709.  
  1710.                            {-260,-400}},
  1711.  
  1712.  
  1713.               rum2 [15]={{-260,-400},{-260,-220},{-240,-225},{-220,-220},{-190,-222},{-180,-228},{-160,-232},
  1714.  
  1715.                            {-150,-235},{-140,-238},{-120,-235},{-100,-230},{-80,-228},{-60,-225},{-40,-225},
  1716.  
  1717.                            {-40,-400}},
  1718.  
  1719.  
  1720.               rum3 [15]={{-40,-400},{-40,-225},{-20,-215},{0,-230},{20,-225},{40,-215},{50,-230},
  1721.  
  1722.                            {60,-220},{90,-210},{120,-215},{130,-220},{150,-225},{170,-230},{190,-228},{190,-400}},
  1723.  
  1724.              
  1725.  
  1726.               rum4 [16]={{190,-400},{190,-228},{192,-225},{195,-223},{205,-220},{210,-215},{230,-218},
  1727.  
  1728.                            {250,-210},{270,-215},{290,-218},{310,-222},{320,-225},{340,-230},{350,-222},{380,-230},
  1729.  
  1730.                            {400,-250}};
  1731.  
  1732.                          
  1733.  
  1734.  
  1735.  
  1736.  
  1737.        gradatePolygon(land,4,wland2);
  1738.  
  1739.        gradatePolygon(land2,4,wland2);
  1740.  
  1741.        fillPolygon(mrgbag4,4,wland);
  1742.  
  1743.        fillPolygon(mrgbag4a,4,wland);
  1744.  
  1745.        fillPolygon(mrgbag4b,4,wland);
  1746.  
  1747.        //pagar
  1748.  
  1749.        setColor(0.286,0.220,0.149);
  1750.  
  1751.        drawLine(-300,-180,-300,-164);
  1752.  
  1753.        drawLine(-100,-180,-100,-164);
  1754.  
  1755.        drawLine(100,-180,100,-164);
  1756.  
  1757.        drawLine(300,-180,300,-164);
  1758.  
  1759.        drawLine(-400,-170,400,-170);
  1760.  
  1761.        drawLine(-400,-175,400,-175);
  1762.  
  1763.        drawPolygon(lamp,7);
  1764.  
  1765.        drawPolygon(lamp2,7);
  1766.  
  1767.      
  1768.  
  1769.  
  1770.        //bayangan
  1771.  
  1772.        setColor(0,0,0);
  1773.  
  1774.        drawLine(-300,-180,-294,-194);
  1775.  
  1776.        drawLine(-100,-180,-94,-194);
  1777.  
  1778.        drawLine(100,-180,106,-194);
  1779.  
  1780.        drawLine(300,-180,306,-194);
  1781.  
  1782.        drawLine(-400,-190,400,-190);
  1783.  
  1784.        drawLine(-400,-185,400,-185);
  1785.  
  1786.        drawLine(320,-180,330,-200);
  1787.  
  1788.        drawLine(330,-200,325,-210);
  1789.  
  1790.        drawLine(-320,-180,-310,-200);
  1791.  
  1792.        drawLine(-310,-200,-315,-210);
  1793.  
  1794.        drawDot(310,-140);
  1795.  
  1796.        drawDot(-330,-141);
  1797.  
  1798.        fillPolygon(bay1,4,bayangan);
  1799.  
  1800.        fillPolygon(bay2,4,bayangan);
  1801.  
  1802.        fillPolygon(bay3,4,bayangan);
  1803.  
  1804.        fillPolygon(bay4,4,bayangan);
  1805.  
  1806.        fillPolygon(bay5,4,bayangan);
  1807.  
  1808.        fillPolygon(bay6,4,bayangan);
  1809.  
  1810.        fillPolygon(bay7,4,bayangan);
  1811.  
  1812.        fillPolygon(bay8,4,bayangan);
  1813.  
  1814.        fillPolygon(bay9,4,bayangan);
  1815.  
  1816.        fillPolygon(bay10,4,bayangan);
  1817.  
  1818.        fillPolygon(bay11,4,bayangan);
  1819.  
  1820.        fillPolygon(bay12,4,bayangan);
  1821.  
  1822.        fillPolygon(bay13,4,bayangan);
  1823.  
  1824.        fillPolygon(bay14,4,bayangan);
  1825.  
  1826.        fillPolygon(bay15,4,bayangan);
  1827.  
  1828.        fillPolygon(bay16,4,bayangan);
  1829.  
  1830.        fillPolygon(bay17,4,bayangan);
  1831.  
  1832.        fillPolygon(bay18,4,bayangan);
  1833.  
  1834.  
  1835.  
  1836.  
  1837.        //bagian rumput
  1838.  
  1839.        setColor(0,1,0);
  1840.  
  1841.        fillPolygon(rum1,15,wrum);
  1842.  
  1843.        fillPolygon(rum2,15,wrum);
  1844.  
  1845.        fillPolygon(rum3,15,wrum);
  1846.  
  1847.        fillPolygon(rum4,16,wrum);
  1848.  
  1849.  
  1850.  
  1851. ////////////////////////////////////////////////////////////////////////////////////////////////////////
  1852.  
  1853.  
  1854.  
  1855. //////////////////////////////////////// ASAP  ////////////////////////////////////////////////////////
  1856.  
  1857.  
  1858.        color_t wasap={1,1,1},
  1859.  
  1860.               wasap2={0,0,0};
  1861.  
  1862.        point2D_t
  1863.  
  1864.               asap[360],pasap={50,-131},
  1865.  
  1866.               asap2[360],pasap2={70,-142},
  1867.  
  1868.  
  1869.               asap3[360],pasap3={34,-150},
  1870.  
  1871.               asap4[360],pasap4={23,-162},
  1872.  
  1873.               asap5[360],pasap5={-15,-173},
  1874.  
  1875.               asap6[360],pasap6={-70,-180},
  1876.  
  1877.               asap7[360],pasap7={-120,-160},
  1878.  
  1879.               asap11[360],pasap11={-150,-180},
  1880.  
  1881.  
  1882.               asap8[360],pasap8={114,-160},
  1883.  
  1884.               asap9[360],pasap9={120,-175},
  1885.  
  1886.               asap10[360],pasap10={180,-185},
  1887.  
  1888.               asap12[360],pasap12={250,-170},
  1889.  
  1890.               asap13[360],pasap13={280,-175};
  1891.  
  1892.  
  1893.               /////////asap tengah/////////////
  1894.  
  1895.              
  1896.  
  1897.               if(tick5>31)
  1898.  
  1899.               {
  1900.  
  1901.                      createEllipse(asap,pasap,27,4);  
  1902.  
  1903.                      fillPolygon(asap,360,wasap);
  1904.  
  1905.               }
  1906.  
  1907.  
  1908.               if(tick5>32)
  1909.  
  1910.               {
  1911.  
  1912.                      createEllipse(asap2,pasap2,60,10);
  1913.  
  1914.                      fillPolygon(asap2,360,wasap);
  1915.  
  1916.               }
  1917.  
  1918.               ////////////////////////////////////
  1919.  
  1920.  
  1921.               //////////////// asap kiri////////////
  1922.  
  1923.               if(tick5>33)
  1924.  
  1925.               {
  1926.  
  1927.                      createEllipse(asap3,pasap3,30,10);
  1928.  
  1929.                      fillPolygon(asap3,360,wasap);
  1930.  
  1931.               }
  1932.  
  1933.              
  1934.  
  1935.               if(tick5>34)
  1936.  
  1937.               {
  1938.  
  1939.                      createEllipse(asap4,pasap4,50,10);
  1940.  
  1941.                      fillPolygon(asap4,360,wasap);
  1942.  
  1943.               }
  1944.  
  1945.              
  1946.  
  1947.               if(tick5>35)
  1948.  
  1949.               {
  1950.  
  1951.                      createEllipse(asap5,pasap5,31,10);
  1952.  
  1953.                      fillPolygon(asap5,360,wasap);
  1954.  
  1955.               }
  1956.  
  1957.  
  1958.               if(tick5>36)
  1959.  
  1960.               {
  1961.  
  1962.                      createEllipse(asap6,pasap6,40,15);
  1963.  
  1964.                      fillPolygon(asap6,360,wasap);
  1965.  
  1966.               }
  1967.  
  1968.  
  1969.               if(tick5>37)
  1970.  
  1971.               {
  1972.  
  1973.                      createEllipse(asap7,pasap7,50,20);
  1974.  
  1975.                      fillPolygon(asap7,360,wasap);
  1976.  
  1977.               }
  1978.  
  1979.  
  1980.               if(tick5>38)
  1981.  
  1982.               {
  1983.  
  1984.                      createEllipse(asap11,pasap11,50,20);    
  1985.  
  1986.                      fillPolygon(asap11,360,wasap);
  1987.  
  1988.               }
  1989.  
  1990.               ////////////////////////////////////
  1991.  
  1992.               ////////// asap kanan ///////////////
  1993.  
  1994.               if(tick5>33)
  1995.  
  1996.               {
  1997.  
  1998.                      createEllipse(asap8,pasap8,60,15);
  1999.  
  2000.                      fillPolygon(asap8,360,wasap);
  2001.  
  2002.               }
  2003.  
  2004.              
  2005.  
  2006.               if(tick5>34)
  2007.  
  2008.               {
  2009.  
  2010.                      createEllipse(asap9,pasap9,110,10);    
  2011.  
  2012.                      fillPolygon(asap9,360,wasap);
  2013.  
  2014.               }
  2015.  
  2016.              
  2017.  
  2018.               if(tick5>35)
  2019.  
  2020.               {
  2021.  
  2022.                      createEllipse(asap10,pasap10,40,10);    
  2023.  
  2024.                      fillPolygon(asap10,360,wasap);
  2025.  
  2026.               }
  2027.  
  2028.               if(tick5>36)
  2029.  
  2030.               {
  2031.  
  2032.                      createEllipse(asap12,pasap12,40,10);    
  2033.  
  2034.                      fillPolygon(asap12,360,wasap);
  2035.  
  2036.  
  2037.               }
  2038.  
  2039.               if(tick5>37)
  2040.  
  2041.               {
  2042.  
  2043.                      createEllipse(asap13,pasap13,45,15);    
  2044.  
  2045.                      fillPolygon(asap13,360,wasap);
  2046.  
  2047.  
  2048.               }
  2049.  
  2050.                          
  2051.  
  2052.  
  2053.  
  2054. ////////////////////////////////////////////////////////////////////////////////////////////////////////
  2055.  
  2056.  
  2057.  
  2058. //////////////////////////////////////// RUMPUT YANG BERGERAK //////////////////////////////////////////
  2059.  
  2060.  
  2061.        color_t
  2062.  
  2063.               wgras [3] ={{0.033,0.585,0.052},{0.233,0.685,0.252},{0.033,0.785,0.052}};
  2064.  
  2065.        point2D_t
  2066.  
  2067.               gras1 [3] ={{300,-250},{100,-130},{280,-250}},
  2068.  
  2069.               gras2 [3] ={{305,-250},{270,-190},{285,-250}},
  2070.  
  2071.               gras3 [3] ={{-300,-250},{-350,-150},{-280,-250}},
  2072.  
  2073.               gras4 [3] ={{-305,-250},{-370,-190},{-285,-250}},
  2074.  
  2075.               gras5 [3] ={{-295,-250},{-270,-200},{-285,-250}};
  2076.  
  2077.  
  2078.      
  2079.  
  2080.  
  2081.  
  2082.               mat=translationMTX(0+tick,0+tick);
  2083.  
  2084.               for(i=1; i
  2085.  
  2086.               {
  2087.  
  2088.                      vec=Point2Vector1(gras1[i]);
  2089.  
  2090.                      vec=mat*vec;
  2091.  
  2092.                      gras1[i]=Vector2Point1(vec);
  2093.  
  2094.               }
  2095.  
  2096.               gradatePolygon(gras1,3,wgras);
  2097.  
  2098.  
  2099.               mat=translationMTX(0+tick3,0+tick3);
  2100.  
  2101.               for(i=1; i
  2102.  
  2103.               {
  2104.  
  2105.                      vec=Point2Vector1(gras2[i]);
  2106.  
  2107.                      vec=mat*vec;
  2108.  
  2109.                      gras2[i]=Vector2Point1(vec);
  2110.  
  2111.               }
  2112.  
  2113.               gradatePolygon(gras2,3,wgras);
  2114.  
  2115.  
  2116.               mat=translationMTX(0+tick3,0+tick3);
  2117.  
  2118.               for(i=1; i
  2119.  
  2120.               {
  2121.  
  2122.                      vec=Point2Vector1(gras3[i]);
  2123.  
  2124.                      vec=mat*vec;
  2125.  
  2126.                      gras3[i]=Vector2Point1(vec);
  2127.  
  2128.               }
  2129.  
  2130.               gradatePolygon(gras3,3,wgras);
  2131.  
  2132.  
  2133.               mat=translationMTX(0+tick3,0+tick3);
  2134.  
  2135.               for(i=1; i
  2136.  
  2137.               {
  2138.  
  2139.                      vec=Point2Vector1(gras4[i]);
  2140.  
  2141.                      vec=mat*vec;
  2142.  
  2143.                      gras4[i]=Vector2Point1(vec);
  2144.  
  2145.               }
  2146.  
  2147.               gradatePolygon(gras4,3,wgras);
  2148.  
  2149.              
  2150.  
  2151.               gradatePolygon(gras5,3,wgras);
  2152.  
  2153.              
  2154.  
  2155.      
  2156.  
  2157.  
  2158. ////////////////////////////////////////////////////////////////////////////////////////////////////////
  2159.  
  2160.  
  2161.        bitmap_output(-390,-240, "re-Master : Muhamad Firdaus Hidayat>",GLUT_BITMAP_TIMES_ROMAN_10,putih);
  2162.  
  2163.  
  2164.  
  2165. /////////////////////////////////////////////////////////////////////////////////////////////////////////
  2166.  
  2167.        tick+=0.5; //rumput panjang
  2168.  
  2169.               if(tick==30)
  2170.  
  2171.                      tick=0;
  2172.  
  2173.        tick2+=0.04; //awan
  2174.  
  2175.  
  2176.        tick3+=0.5;  //rumput kecil
  2177.  
  2178.               if(tick3==10)
  2179.  
  2180.                      tick3=0;
  2181.  
  2182.  
  2183.        if(tick5==40)
  2184.  
  2185.        {
  2186.  
  2187.               tick4+=0.5; //pesawat
  2188.  
  2189.        }
  2190.  
  2191.  
  2192.        if(t4==36)
  2193.  
  2194.        {
  2195.  
  2196.               tick5+=0.3; //pangkalan atas
  2197.  
  2198.               if(tick5>40) tick5=40;
  2199.  
  2200.        }
  2201.  
  2202.  
  2203.        t1+=0.5; //lift
  2204.  
  2205.        if(t1>170) t1=170;
  2206.  
  2207.  
  2208.        if(t1==170)
  2209.  
  2210.        {
  2211.  
  2212.               t2+=0.09;            //pangkalan bawah
  2213.  
  2214.               if(t2>36) t2=36;
  2215.  
  2216.        }
  2217.  
  2218.        if(t2==36)
  2219.  
  2220.        {
  2221.  
  2222.               t3+=0.09;  //lift kecil ke pesawat
  2223.  
  2224.               if(t3>104) t3=104;
  2225.  
  2226.        }
  2227.  
  2228.      
  2229.  
  2230.        if(t3==104)
  2231.  
  2232.        {
  2233.  
  2234.               t4+=0.09;  // lift balik
  2235.  
  2236.               if(t4>36) t4=36;
  2237.  
  2238.        }
  2239.  
  2240.  
  2241.              
  2242.  
  2243. }
  2244.  
  2245.  
  2246.  
  2247. void display(void)
  2248.  
  2249. {
  2250.  
  2251.     glClear(GL_COLOR_BUFFER_BIT);
  2252.  
  2253.        userdraw();
  2254.  
  2255.        glutSwapBuffers();
  2256.  
  2257. }
  2258.  
  2259.  
  2260. int main (int argc, char ** argv)
  2261.  
  2262. {
  2263.  
  2264.     // insert code here...
  2265.  
  2266.     glutInit(&argc,argv); //inisialisasi toolkit
  2267.  
  2268.     glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
  2269.  
  2270.     glutInitWindowPosition(100,100);
  2271.  
  2272.     glutInitWindowSize(800,600); // besar ukuran windows
  2273.  
  2274.     glutCreateWindow("Muhamad Firdaus Hidayat");
  2275.  
  2276.     glClearColor(0.6,0.8,1.0,0); // warna background biru muda/tua
  2277.  
  2278.     gluOrtho2D(-400,400,-250,250); // ukuran layar yang dipake
  2279.  
  2280.     glutIdleFunc(display);
  2281.  
  2282.     glutDisplayFunc(display);
  2283.  
  2284.     glutMainLoop();
  2285.  
  2286.     return 0;
  2287.  
  2288. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!