glMaterialfv() private method

private glMaterialfv ( uint face, uint pname, float paramsx ) : void
face uint
pname uint
paramsx float
return void
示例#1
0
        void drawFloor()
        {
            GL.glEnable(GL.GL_LIGHTING);

            GL.glPushMatrix();
            GL.glColor3d(0, 1, 0);
            GL.glTranslated(0, -0.01, 0);

            float[] grass_ambuse    = { 0.03f, 0.56f, 0.19f, 1.0f };
            float[] grass_specular  = { 0.0f, 0.0f, 0.0f, 1.0f };
            float[] grass_shininess = { 10 };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, grass_ambuse);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, grass_specular);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, grass_shininess);

            GL.glBegin(GL.GL_QUADS);

            GL.glNormal3f(0, 1, 0);
            GL.glVertex3f(-200, 0, -200);
            GL.glVertex3f(-200, 0, 200);
            GL.glVertex3f(200, 0, 200);
            GL.glVertex3f(200, 0, -200);
            GL.glEnd();

            GL.glDisable(GL.GL_LIGHTING);
            GL.glPopMatrix();
        }
示例#2
0
        protected virtual void initRenderingGL()
        {
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }
            if (this.Width == 0 || this.Height == 0)
            {
                return;
            }
            GL.glShadeModel(GL.GL_SMOOTH);
            GL.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
            GL.glClearDepth(1.0f);


            GL.glEnable(GL.GL_LIGHT0);
            GL.glEnable(GL.GL_COLOR_MATERIAL);
            GL.glColorMaterial(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE);

            GL.glEnable(GL.GL_DEPTH_TEST);
            GL.glDepthFunc(GL.GL_LEQUAL);
            GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_Hint, GL.GL_NICEST);

            GL.glViewport(0, 0, this.Width, this.Height);
            GL.glMatrixMode(GL.GL_PROJECTION);
            GL.glLoadIdentity();

            //nice 3D
            GLU.gluPerspective(45.0, 1.0, 0.4, 100.0);

            //! TEXTURE 1a
            GL.glEnable(GL.GL_COLOR_MATERIAL);
            float[] emis = { 0.3f, 0.3f, 0.3f, 1 };
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_EMISSION, emis);
            //! TEXTURE 1a



            GL.glShadeModel(GL.GL_SMOOTH);
            GLU.gluPerspective(viewAngle, (float)Width / (float)Height, 0.45f, 30.0f);

            GL.glMatrixMode(GL.GL_MODELVIEW);
            GL.glLoadIdentity();

            //! TEXTURE 1a
            GenerateTextures();
            //! TEXTURE 1b
            //save the current MODELVIEW Matrix (now it is Identity)
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedRotationsTraslations);
        }
        public void Drawlake()
        {
            float[] lake_ambuse = { 0.0117f, 0.4296f, 0.6562f, 0.3f };
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, lake_ambuse);

            for (int ll = 0; ll < 6; ll++)
            {
                GL.glPushMatrix();

                GL.glTranslated(160 - (ll * 70), 0, 0);
                GL.glColor4f(0.0117f, 0.4296f, 0.6562f, 0.5f);
                GL.glRotatef(90, 1, 0, 0);
                GLU.gluDisk(obj, 0, lake_size, 30, 30);// size of lake

                GL.glPopMatrix();
            }
        }
示例#4
0
        /**********************************************************************************************************
        *
        * Setup materials parametrs for water,ground and tree components.
        *
        **********************************************************************************************************/

        public void SetupMaterials()
        {
            float[] tree_ambuse    = { 0.4f, 0.25f, 0.1f, 1.0f };
            float[] tree_specular  = { 0.0f, 0.0f, 0.0f, 1.0f };
            float[] tree_shininess = { 0 };

            float[] leaf_ambuse    = { 0.0f, 0.8f, 0.0f, 1.0f };
            float[] leaf_specular  = { 0.0f, 0.8f, 0.0f, 1.0f };
            float[] leaf_shininess = { 10 };

            float[] water_ambuse    = { 0.70f, 0.85f, 0.95f, ScrollValue[15] };
            float[] water_specular  = { 0.0f, 0.0f, 1.0f, 1.0f };
            float[] water_shininess = { 1 };

            float[] apple_ambuse    = { 0.57f, 0.04f, 0.04f, 1.0f };
            float[] apple_specular  = { 0.5f, 0.05f, 0.05f, 1.0f };
            float[] apple_shininess = { 0.1f };

            GL.glNewList(APPLE_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, apple_ambuse);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, apple_specular);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, apple_shininess);
            GL.glEndList();

            GL.glNewList(WATER_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, water_ambuse);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, water_specular);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, water_shininess);
            GL.glEndList();

            GL.glNewList(TREE_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, tree_ambuse);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, tree_specular);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, tree_shininess);
            GL.glEndList();

            GL.glNewList(LEAF_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, leaf_ambuse);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, leaf_specular);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, leaf_shininess);
            GL.glEndList();
        }
 public override void DrawToy(double[] translateCoords, double[] rotateCoords, bool isShadow)
 {
     float[] material = new float[3];
     material[0] = 0.0215f;
     material[1] = 0.1745f;
     material[2] = 0.0215f;
     GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, material);
     material[0] = 0.07568f;
     material[1] = 0.61424f;
     material[2] = 0.07568f;
     GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, material);
     material[0] = 0.633f;
     material[1] = 0.727811f;
     material[2] = 0.633f;
     GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, material);
     GL.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, 5f);
     GL.glTranslated(translateCoords[0], translateCoords[1], translateCoords[2]);
     if (!isShadow)
     {
         GL.glColor3d(1, 1, 1);
     }
     else
     {
         GL.glDisable(GL.GL_TEXTURE_2D);
     }
     GL.glRotated(rotateCoords[0], rotateCoords[1], rotateCoords[2], rotateCoords[3]);
     GL.glScaled(10, 10, 10);
     if (isShadow)
     {
         GL.glCallList(SHADOW_LIST);
     }
     else
     {
         GL.glCallList(LIST);
     }
     GL.glScaled(0.1, 0.1, 0.1);
     GL.glRotated(-rotateCoords[0], rotateCoords[1], rotateCoords[2], rotateCoords[3]);
     GL.glTranslated(-translateCoords[0], -translateCoords[1], -translateCoords[2]);
     GL.glDisable(GL.GL_TEXTURE_2D);
 }
示例#6
0
        public void DrawRobot(bool isForShades)
        {
            GL.glPushMatrix();
            if (!isForShades)
            {
                GL.glColor4f(0f, 0f, 0.4f, 1f);
                GL.glEnable(GL.GL_COLOR_MATERIAL);
                GL.glMaterialf(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, 51.2f);
                GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, chrome_ambient);
                GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE, chrome_diffuse);
                GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, chrome_specular);
            }

            GL.glTranslated(0, 0, 7.5);

            GL.glRotatef(180, 0, 1, 0);
            GL.glRotatef(-alfa, 0, 0, 1);
            GL.glTranslated(0, 0, updn);
            GL.glRotatef(bodyAngle, 0, 1, 0);
            GL.glPushMatrix();


            //torso
            if (isForShades)
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }

            GLU.gluCylinder(obj, 1.0, 1.0, 4.0, 50, 3);
            GLU.gluDisk(obj, 0, 1, 40, 20);
            GL.glTranslated(0, 0, 4);
            GLU.gluDisk(obj, 0, 1, 40, 20);
            GL.glTranslated(0, 0, -4);
            //head
            GL.glTranslated(0, 0, -r * 3);
            GLU.gluSphere(obj, r * 3, 20, 20);

            GL.glPopMatrix();

            GL.glPushMatrix();
            //right_upper_ARM

            GL.glTranslated(0, 1.3, 0.3);

            GL.glRotatef(right_upper_ARM_yangle, 0, 1, 0);
            GL.glRotatef(right_upper_ARM_xangle, 1, 0, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.4, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);
            //right_lower_ARM
            GL.glTranslated(0, 0, 1.7);
            GL.glRotatef(right_lower_ARM_angle, 0, 1, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.1, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);

            GL.glPopMatrix();

            GL.glPushMatrix();

            //left_upper_ARM

            GL.glTranslated(0, -1.3, 0.3);
            GL.glRotatef(left_upper_ARM_yangle, 0, 1, 0);
            GL.glRotatef(left_upper_ARM_xangle, 1, 0, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.4, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);

            //left_lower_ARM

            /////
            GL.glTranslated(0, 0, 1.7);
            GL.glRotatef(left_lower_ARM_angle, 0, 1, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.1, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);

            GL.glPopMatrix();

            GL.glPushMatrix();

            //left_LEG

            GL.glTranslated(0, -0.7, 4.2);
            GL.glRotatef(right_upper_LEG_angle, 0, 1, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.5, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);
            GL.glTranslated(0, 0, 1.7);

            // right_lower_LEG

            GL.glRotatef(right_lower_LEG_angle, 0, 1, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.1, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);

            GL.glPopMatrix();

            GL.glPushMatrix();

            //right_LEG

            GL.glTranslated(0, 0.7, 4.2);
            GL.glRotatef(left_upper_LEG_angle, 0, 1, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.5, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);
            GL.glTranslated(0, 0, 1.7);
            //left_lower_LEG
            GL.glRotatef(left_lower_LEG_angle, 0, 1, 0);
            if (!isForShades)
            {
                GL.glColor3f(0.4f, 0.6f, 0f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluSphere(obj, r * 1.1, 20, 20);
            if (!isForShades)
            {
                GL.glColor3f(0, 0, 1f);
            }
            else
            {
                GL.glColor3f(0.2f, 0.2f, 0.2f);
            }
            GLU.gluCylinder(obj, 0.3, 0.3, 1.7, 50, 3);

            GL.glPopMatrix();

            GL.glPopMatrix();
        }
        public void drawPenguin()
        {
            GL.glPushMatrix();
            //  drawaxe();
            GL.glRotatef(90, 0.0f, 1.0f, 0.0f);

            GL.glRotatef(-90, 1.0f, 0.0f, 0.0f);


            //drawaxe();
            GL.glTranslated(0.0, -200, 0);
            GL.glTranslated(0.0, speed, 0);  // going forward
            GL.glRotated(spirala, 0, 0, 1);  //turn 180 deg

            // drawaxe();



            if (speedFlg)
            {
                if (!spiralaFlg)
                {
                    if (forward)
                    {
                        if (speed < 380)
                        {
                            speed += 5;
                            GL.glRotated(flap * 6, 0, 0, 1);  //Jump
                        }
                        if (speed >= 380)
                        {
                            speedFlg   = false;
                            spiralaFlg = true;
                            forward    = false;
                        }
                    }
                    if (!forward)
                    {
                        if (speed > 0)
                        {
                            speed -= 5;
                            GL.glRotated(flap * 6, 0, 0, 1);
                        }
                        if (speed <= 0)
                        {
                            speedFlg   = false;
                            spiralaFlg = true;
                            forward    = true;
                        }
                    }
                }
            }
            if (!speedFlg)
            {
                if (spiralaFlg)
                {
                    if (spirala < spindLim)
                    {
                        spirala += 18;
                        GL.glTranslated(0.0, 0, 0 + flap * 8);
                    }
                    else
                    {
                        spiralaFlg = false;
                        spindLim  += 180;
                    }
                }
                if (!spiralaFlg)
                {
                    speedFlg = true;
                }
            }

            if (!checkBox)
            {
                if (!flapFlg)
                {
                    flap += 0.5f;
                    if (flap >= 5)
                    {
                        flapFlg = true;
                    }
                }
                if (flapFlg)
                {
                    flap -= 0.5f;
                    if (flap <= 0)
                    {
                        flapFlg = false;
                    }
                }
            }
            if (checkBox)
            {
                flap = 0;
            }



            GL.glPushMatrix();

            GL.glScaled(scale_inc, scale_inc, scale_inc); //size of penguin
            //drawaxe();

            float[] front_ambuse = { 0.9f, 0.9f, 0.9f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, front_ambuse);

            GL.glColor3f(1.0f, 1.0f, 1.0f);
            //Front body
            GL.glBegin(GL.GL_QUADS);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-3, 3, 0);
            GL.glVertex3d(3, 3, 0);
            GL.glVertex3d(4, 4, 5);
            GL.glVertex3d(-4, 4, 5);
            GL.glEnd();

            GL.glBegin(GL.GL_QUADS);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-4, 4, 5);
            GL.glVertex3d(4, 4, 5);
            GL.glVertex3d(2.5, 3, 12);
            GL.glVertex3d(-2.5, 3, 12);
            GL.glEnd();

            float[] backLow_ambuse = { 0.01f, 0.01f, 0.01f, 1.0f };
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, backLow_ambuse);

            GL.glColor3f(0.01f, 0.01f, 0.01f);

            //Back body
            GL.glBegin(GL.GL_QUADS);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-3, 0, 0);
            GL.glVertex3d(3, 0, 0);
            GL.glVertex3d(4, -1, 5);
            GL.glVertex3d(-4, -1, 5);
            GL.glEnd();

            float[] backHigh_ambuse = { 0.18f, 0.18f, 0.18f, 1.0f };
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, backHigh_ambuse);

            GL.glColor3f(0.18f, 0.18f, 0.18f);

            GL.glBegin(GL.GL_QUADS);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-4, -1, 5);
            GL.glVertex3d(4, -1, 5);
            GL.glVertex3d(2.5, 0, 12);
            GL.glVertex3d(-2.5, 0, 12);
            GL.glEnd();


            float[] SideFront_ambuse = { 0.91f, 0.91f, 0.91f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, SideFront_ambuse);
            GL.glColor3f(0.91f, 0.91f, 0.91f);

            //leftSide-front body
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-3, 3, 0);
            GL.glVertex3d(-3.5, 1, 0);
            GL.glVertex3d(-4, 4, 5);
            GL.glVertex3d(-4.2, 1, 5.5);
            GL.glVertex3d(-2.5, 3, 12);
            GL.glEnd();

            //rightSide-front body
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(3, 3, 0);
            GL.glVertex3d(3.5, 1, 0);
            GL.glVertex3d(4, 4, 5);
            GL.glVertex3d(4.2, 1, 5.5);
            GL.glVertex3d(2.5, 3, 12);
            GL.glEnd();


            float[] SideBack_ambuse = { 0.1f, 0.1f, 0.1f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, SideBack_ambuse);
            GL.glColor3f(0.1f, 0.1f, 0.1f);

            //leftSide-front body
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-3, 0, 0);
            GL.glVertex3d(-3.5, 1, 0);
            GL.glVertex3d(-4, -1, 5);
            GL.glVertex3d(-4.2, 1, 5.5);
            GL.glVertex3d(-2.5, 0, 12);
            GL.glVertex3d(-2.5, 3, 12);
            GL.glEnd();

            //rightSide-front body
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(3, 0, 0);
            GL.glVertex3d(3.5, 1, 0);
            GL.glVertex3d(4, -1, 5);
            GL.glVertex3d(4.2, 1, 5.5);
            GL.glVertex3d(2.5, 0, 12);
            GL.glVertex3d(2.5, 3, 12);
            GL.glEnd();


            ////// neck
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);

            GL.glVertex3d(2.5, 3, 12);
            GL.glVertex3d(-2.5, 3, 12);
            GL.glVertex3d(0, 1.0, 15);
            GL.glEnd();

            GL.glColor3f(0f, 0.0f, 0.0f);

            float[] beak_ambuse = { 0.6021f, 0.3001f, 0.0156f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, beak_ambuse);
            GL.glColor3f(0.6021f, 0.3001f, 0.0156f);

            ////// beak -left
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-2.5, 3, 12);
            GL.glVertex3d(0, 1.0, 15);
            GL.glVertex3d(0, 6.0, 10);
            GL.glEnd();
            ////// beak -right
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(2.5, 3, 12);
            GL.glVertex3d(0, 1.0, 15);
            GL.glVertex3d(0, 6.0, 10);
            GL.glEnd();


            float[] wing_ambuse = { 0.7421f, 0.4101f, 0.0156f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, wing_ambuse);
            GL.glColor3f(0.7421f, 0.4101f, 0.0156f);

            ////// wing -left
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(-2.5, 3, 12);
            GL.glVertex3d(-4.2, +1.0, 5.5);
            GL.glVertex3d(-5 + (float)-flap * 0.4, -5.0 + (float)flap * 0.4, 4);

            GL.glEnd();
            ////// wing -right
            GL.glBegin(GL.GL_TRIANGLE_STRIP);
            GL.glNormal3d(0, 0, 1);
            GL.glVertex3d(2.5, 3, 12);
            GL.glVertex3d(4.2, +1.0, 5.5);
            GL.glVertex3d(5 + (float)flap * 0.4, -5.0 + (float)flap * 0.4, 4);
            GL.glEnd();


            //Head
            float[] head_ambuse = { 0.1117f, 0.1296f, 0.1562f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, head_ambuse);
            GL.glColor3f(0.1117f, 0.1296f, 0.1562f);

            GL.glPushMatrix();
            GL.glTranslated(0, 1.5, 13);
            GLUT.glutSolidSphere(3.2, 64, 64);
            GL.glPopMatrix();



            //Legs
            float[] legs_ambuse = { 0.5021f, 0.2001f, 0.0156f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, legs_ambuse);
            GL.glColor3f(0.1117f, 0.1296f, 0.1562f);

            GL.glPushMatrix();
            GL.glTranslated(-2.2, 3, 0);
            GLUT.glutSolidSphere(1.8, 32, 100);
            GL.glPopMatrix();
            GL.glPushMatrix();
            GL.glTranslated(2.2, 3, 0);
            GLUT.glutSolidSphere(1.8, 32, 100);
            GL.glPopMatrix();


            GL.glPushMatrix();



            //Eyes
            float[] eyesW_ambuse = { 1f, 1f, 1f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, eyesW_ambuse);
            GL.glColor3f(1f, 1f, 1f);

            GL.glPushMatrix();
            GL.glTranslated(-1.2, 3.5, 13);
            GLUT.glutSolidSphere(1, 32, 32);
            GL.glPopMatrix();
            GL.glPushMatrix();
            GL.glTranslated(1.2, 3.5, 13);
            GLUT.glutSolidSphere(1, 32, 32);
            GL.glPopMatrix();

            float[] eyesB_ambuse = { 0f, 0f, 0f, 1.0f };

            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, eyesB_ambuse);
            GL.glColor3f(1f, 1f, 1f);

            GL.glPushMatrix();
            GL.glTranslated(-1.2, 3.9, 12.8);
            GLUT.glutSolidSphere(0.7, 32, 32);
            GL.glPopMatrix();
            GL.glPushMatrix();
            GL.glTranslated(1.2, 3.9, 12.8);
            GLUT.glutSolidSphere(0.7, 32, 32);
            GL.glPopMatrix();

            GL.glPopMatrix();
            GL.glPopMatrix();
            GL.glPopMatrix();
        }