Beispiel #1
0
        // --- Callbacks ---
        #region Display()
        private static void Display()
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);

            Gl.glPushMatrix();
            Gl.glRotatef(20.0f, 1.0f, 0.0f, 0.0f);

            Gl.glPushMatrix();
            Gl.glTranslatef(-0.75f, 0.5f, 0.0f);
            Gl.glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
            Glut.glutSolidTorus(0.275, 0.85, 15, 15);
            Gl.glPopMatrix();

            Gl.glPushMatrix();
            Gl.glTranslatef(-0.75f, -0.5f, 0.0f);
            Gl.glRotatef(270.0f, 1.0f, 0.0f, 0.0f);
            Glut.glutSolidCone(1.0, 2.0, 15, 15);
            Gl.glPopMatrix();

            Gl.glPushMatrix();
            Gl.glTranslatef(0.75f, 0.0f, -1.0f);
            Glut.glutSolidSphere(1.0, 15, 15);
            Gl.glPopMatrix();
            Gl.glPopMatrix();
            Gl.glFlush();
        }
Beispiel #2
0
        private void Clock()
        {
            Gl.glColor3ub(255, 180, 180);

            Gl.glPushMatrix();
            Gl.glScaled(1.0f, 1.0f, 0.7f);
            Glut.glutSolidTorus(1, 9, 32, 32);
            Gl.glPopMatrix();

            Glut.glutSolidCylinder(0.5f, 0.3f, 32, 32);
            Gl.glColor3ub(255, 255, 255);

            Gl.glPushMatrix();
            Gl.glScaled(9.0f, 9.0f, 0.1f);
            Glut.glutSolidSphere(1.0f, 100, 100);
            Gl.glPopMatrix();
            //Glut.glutSolidCylinder(9f, 0.1f, 32, 32);
            for (int i = 0; i < 12; i++)
            {
                Gl.glPushMatrix();

                Gl.glColor3ub(150, 175, 255);
                Gl.glRotated(i * 30.0f, 0, 0, 1);
                Gl.glTranslated(7.5f, 0.0f, 0.1f);
                Gl.glScaled(1.0f, 0.2f, 0.2f);
                Glut.glutSolidCube(1.0f);

                Gl.glPopMatrix();
            }
        }
Beispiel #3
0
        private void tor()
        {
            Gl.glEnable(Gl.GL_ALPHA_TEST);
            Gl.glEnable(Gl.GL_BLEND);


            Gl.glBlendFunc(Gl.GL_SRC_COLOR, Gl.GL_ONE_MINUS_SRC_COLOR);
            Gl.glLoadIdentity();
            float[] color_con  = { 0.5f, 0, 1, 0.5f };
            float[] light0_dif = { 0.7f, 0.7f, 0.2f, 0.9f };
            float[] light0_pos = { 0.0f, 1.0f, 0.0f, 0.0f };
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, light0_dif);
            Gl.glMaterialfv(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT, color_con);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, light0_pos);

            Gl.glLoadIdentity();
            Gl.glTranslated(0, 0, -10);
            Gl.glRotated(30, 0, 1, 1);

            Glut.glutSolidTorus(1, 2, 20, 20);
            Gl.glLoadIdentity();

            Gl.glDisable(Gl.GL_ALPHA_TEST);
            Gl.glDisable(Gl.GL_BLEND);

            holst.Invalidate();
        }
Beispiel #4
0
        protected override void Particular()
        {
            Gl.glColor3d(0.2, 0.3, 0);
            Gl.glRotated(90, 1, 0, 0);
            Gl.glRotated(45, 0, 0, 1);
            Gl.glScaled(1, 1, 0.4);
            Glut.glutSolidTorus(0.22f * 30, 0.22f * 30, 40, 4);
            Gl.glColor3d(0.3, 1, 0.2);
            Gl.glScaled(1, 1, 1.5);
            Glut.glutSolidTorus(0.15f * 30, 0.15f * 30, 40, 40);

//			}
//			else if(objStruct.angle==2)
//			{
//				Glut.glutSolidTorus(0.18,0.18,40,40);
//				Gl.glColor3d(1-temp[0],1-temp[1],1-temp[2]);
//				Glut.glutSolidTorus(0.18,0.18,40,3);
//			}

            Gl.glColor3d(0.2, 0.5, 0.3);
            Gl.glScaled(1, 1, 1);
            Glut.glutSolidSphere(0.1f * 30, 20, 20);
            height = 6.6;
            Gl.glColor3d(1, 1, 1);
        }
Beispiel #5
0
        private void Carousel()
        {
            Gl.glPushMatrix();

            Gl.glRotated(-90, 1f, 0f, 0f);
            Gl.glTranslated(0f, 0.0f, -1.0f);

            Gl.glColor4d(0.5f, 0.5f, 0.5f, 0.2f);
            //center

            Glut.glutSolidCylinder(0.4f, 1.2f, 20, 1);

            //top
            Gl.glColor3ub(255, 200, 220);
            Gl.glPushMatrix();
            Gl.glTranslated(0f, 0f, 1.2f);
            Glut.glutSolidTorus(0.1f, 1.0f, 20, 9);
            Glut.glutSolidCylinder(1f, 0.05f, 20, 1);
            Gl.glColor3ub(200, 250, 255);
            Glut.glutSolidCone(0.8f, 1.1f, 20, 20);
            Gl.glTranslated(0f, 0f, 1.1f);
            Gl.glColor3ub(255, 200, 220);
            Glut.glutSolidSphere(0.1f, 10, 10);
            Gl.glPopMatrix();

            Gl.glPopMatrix();
        }
Beispiel #6
0
 protected void pintaEslabon()
 {
     Gl.glPushMatrix();
     Gl.glScaled(1, 2, 1);
     Gl.glColor3d(128 / 256.0, 64 / 256.0, 64 / 256.0);
     Glut.glutSolidTorus(grosor / 2, (yeslabon + grosor) / 4, 10, 10);
     Gl.glPopMatrix();
 }
Beispiel #7
0
        // --- Callbacks ---
        #region Display()
        /// <summary>
        ///     <para>
        ///         Draw a sphere in a diamond-shaped section in the middle of a window with 2
        ///         torii.
        ///     </para>
        /// </summary>
        private static void Display()
        {
            Gl.glClear(Gl.GL_STENCIL_BUFFER_BIT);

            // create a diamond shaped stencil area
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glPushMatrix();
            Gl.glLoadIdentity();
            Gl.glOrtho(-3.0, 3.0, -3.0, 3.0, -1.0, 1.0);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glPushMatrix();
            Gl.glLoadIdentity();

            // Disable color buffer update.
            Gl.glColorMask(0, 0, 0, 0);
            Gl.glDisable(Gl.GL_DEPTH_TEST);
            Gl.glStencilFunc(Gl.GL_ALWAYS, 0x1, 0x1);
            Gl.glStencilOp(Gl.GL_REPLACE, Gl.GL_REPLACE, Gl.GL_REPLACE);

            Gl.glBegin(Gl.GL_QUADS);
            Gl.glVertex3f(-1.0f, 0.0f, 0.0f);
            Gl.glVertex3f(0.0f, 1.0f, 0.0f);
            Gl.glVertex3f(1.0f, 0.0f, 0.0f);
            Gl.glVertex3f(0.0f, -1.0f, 0.0f);
            Gl.glEnd();
            Gl.glPopMatrix();
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glPopMatrix();
            Gl.glMatrixMode(Gl.GL_MODELVIEW);

            // Enable color buffer update.
            Gl.glColorMask(1, 1, 1, 1);
            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glStencilOp(Gl.GL_KEEP, Gl.GL_KEEP, Gl.GL_KEEP);

            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);

            // draw blue sphere where the stencil is 1
            Gl.glStencilFunc(Gl.GL_EQUAL, 0x1, 0x1);
            Gl.glCallList(BLUEMAT);
            Glut.glutSolidSphere(0.5, 15, 15);

            // draw the tori where the stencil is not 1
            Gl.glStencilFunc(Gl.GL_NOTEQUAL, 0x1, 0x1);
            Gl.glPushMatrix();
            Gl.glRotatef(45.0f, 0.0f, 0.0f, 1.0f);
            Gl.glRotatef(45.0f, 0.0f, 1.0f, 0.0f);
            Gl.glCallList(YELLOWMAT);
            Glut.glutSolidTorus(0.275, 0.85, 15, 15);
            Gl.glPushMatrix();
            Gl.glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
            Glut.glutSolidTorus(0.275, 0.85, 15, 15);
            Gl.glPopMatrix();
            Gl.glPopMatrix();

            Gl.glFlush();
        }
Beispiel #8
0
 static void Cesta2()
 {
     Gl.glPushMatrix();
     Gl.glColor3f(0.2f, 0.2f, 0.2f);
     Gl.glScalef(1.0f, 1.0f, 0.4f);
     Gl.glTranslatef(0.0f, -3.0f, 32.6f);
     Gl.glRotatef(90.0f, 10.0f, 0.0f, 0.0f);
     Glut.glutSolidTorus(0.10f, 0.5f, 200, 200);
     Gl.glPopMatrix();
 }
Beispiel #9
0
 private static void DrawTorus()
 {
     Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT, mat1_amb);
     Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, mat1_dif);
     Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, mat1_spec);
     Gl.glMaterialf(Gl.GL_FRONT, Gl.GL_SHININESS, mat1_shiness);
     Gl.glPushMatrix();
     Gl.glTranslatef(-0.75f, 0.5f, -10.0f);
     Gl.glRotated(20.0, 1.0, 0.0, 0.0);
     Gl.glRotated(90.0, 1.0, 0.0, 0.0);
     Glut.glutSolidTorus(0.275, 0.85, 15, 15);
     Gl.glPopMatrix();
 }
Beispiel #10
0
        protected override void Particular()
        {
            Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("rose"));
            Gl.glRotated(90, 1, 0, 0);
            Gl.glRotated(45, 0, 0, 1);
            Gl.glScaled(1, 1, 0.4);
            Glut.glutSolidTorus(0.5f * 30, 0.5 * 30, 40, 4);

            Gl.glScaled(1, 1, 1.5);
            Glut.glutSolidTorus(0.3f * 30, 0.3f * 30, 40, 40);

            Gl.glScaled(1, 1, 1);
            Glut.glutSolidSphere(0.2f * 30, 20, 20);
            height = 6.6;
            Gl.glColor3d(1, 1, 1);
        }
Beispiel #11
0
        public override void Render()
        {
            Gl.glPushMatrix();

            // Set material properties
            float[] qaGreen = { 0f, 1f, 0f, 1f };
            float[] qaBlack = { 0f, 0f, 0f, 0.5f };
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT, qaGreen);
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, qaGreen);
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, qaBlack);

            Gl.glPushMatrix();
            Gl.glTranslatef(0.0f, -0.3f, 0.0f);
            Gl.glColor3f(0f, 0.392157f, 0f);
            Glut.glutSolidTorus(7.0f, 0.0f, 4, 2);
            Gl.glPopMatrix();

            Gl.glPopMatrix();
        }
Beispiel #12
0
        protected override void Particular()
        {
            Gl.glPushMatrix();
            double w = 17;

            Gl.glColor3d(1, 1, 1);
            Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("rose"));
            Gl.glBegin(Gl.GL_QUADS);
            Gl.glNormal3d(0, 0, 1);
            Gl.glTexCoord2d(0, 0); Gl.glVertex3d(-w, -w, 0);
            Gl.glTexCoord2d(1, 0); Gl.glVertex3d(w, -w, 0);
            Gl.glTexCoord2d(1, 1); Gl.glVertex3d(w, w, 0);
            Gl.glTexCoord2d(0, 1); Gl.glVertex3d(-w, w, 0);
            Gl.glEnd();
            Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);

            Gl.glColor3d(.1, 0, 0);
            Glut.glutSolidTorus(3, 19, 30, 40);
            Glut.glutSolidTorus(4, 23, 10, 6);
            Gl.glPopMatrix();
        }
Beispiel #13
0
        private static void DisplayObjects()
        {
            float[] torusDiffuse  = { 0.7f, 0.7f, 0.0f, 1.0f };
            float[] cubeDiffuse   = { 0.0f, 0.7f, 0.7f, 1.0f };
            float[] sphereDiffuse = { 0.7f, 0.0f, 0.7f, 1.0f };
            float[] octaDiffuse   = { 0.7f, 0.4f, 0.4f, 1.0f };

            Gl.glPushMatrix();
            Gl.glTranslatef(0.0f, 0.0f, -5.0f);
            Gl.glRotatef(30.0f, 1.0f, 0.0f, 0.0f);

            Gl.glPushMatrix();
            Gl.glTranslatef(-0.80f, 0.35f, 0.0f);
            Gl.glRotatef(100.0f, 1.0f, 0.0f, 0.0f);
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, torusDiffuse);
            Glut.glutSolidTorus(0.275f, 0.85f, 16, 16);
            Gl.glPopMatrix();

            Gl.glPushMatrix();
            Gl.glTranslatef(-0.75f, -0.50f, 0.0f);
            Gl.glRotatef(45.0f, 0.0f, 0.0f, 1.0f);
            Gl.glRotatef(45.0f, 1.0f, 0.0f, 0.0f);
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, cubeDiffuse);
            Glut.glutSolidCube(1.5f);
            Gl.glPopMatrix();

            Gl.glPushMatrix();
            Gl.glTranslatef(0.75f, 0.60f, 0.0f);
            Gl.glRotatef(30.0f, 1.0f, 0.0f, 0.0f);
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, sphereDiffuse);
            Glut.glutSolidSphere(1.0f, 16, 16);
            Gl.glPopMatrix();

            Gl.glPushMatrix();
            Gl.glTranslatef(0.70f, -0.90f, 0.25f);
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, octaDiffuse);
            Glut.glutSolidOctahedron();
            Gl.glPopMatrix();
            Gl.glPopMatrix();
        }
Beispiel #14
0
        // --- Callbacks ---
        #region Display()
        /// <summary>
        ///     <para>
        ///         Here is where the light position is reset after the modeling transformation
        ///         (Gl.glRotated) is called.  This places the light at a new position in world
        ///         coordinates.  The cube represents the position of the light.
        ///     </para>
        /// </summary>
        private static void Display()
        {
            float[] position = { 0.0f, 0.0f, 1.5f, 1.0f };

            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            Gl.glPushMatrix();
            Glu.gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

            Gl.glPushMatrix();
            Gl.glRotated((double)spin, 1.0, 0.0, 0.0);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, position);

            Gl.glTranslated(0.0, 0.0, 1.5);
            Gl.glDisable(Gl.GL_LIGHTING);
            Gl.glColor3f(0.0f, 1.0f, 1.0f);
            Glut.glutWireCube(0.1);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glPopMatrix();

            Glut.glutSolidTorus(0.275, 0.85, 8, 15);
            Gl.glPopMatrix();
            Gl.glFlush();
        }
        private void DrawTorus()
        {
            //рисование тора с помощью библиотеки FreeGlut
            Gl.glDisable(Gl.GL_BLEND);
            Gl.glColor3f(Convert.ToSingle(_figureColor.R) / 255, Convert.ToSingle(_figureColor.G) / 255, Convert.ToSingle(_figureColor.B) / 255); //цвет фигуры без освещения

            Gl.glPushMatrix();                                                                                                                    // сохраняет текущие координаты
            Gl.glTranslated(0, 0, -5);                                                                                                            // перенос по Z

            RotationGlut();                                                                                                                       // поворот

            if (Wire.Checked)
            {
                Glut.glutWireTorus(0.3, 0.65, 16, 200);// сеточный режим
            }
            else
            {
                Glut.glutSolidTorus(0.3, 0.65, 16, 200);//режим с заливкой
            }
            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_LIGHTING); // пересчитываем освещение
            Gl.glFlush();                 // довыполнение предыдущих команд
        }
Beispiel #16
0
        private void DrawTorus()
        {
            Gl.glDisable(Gl.GL_BLEND);

            Gl.glColor3f(0.3f, 0.16f, 0.2f);

            Gl.glPushMatrix();

            GlutRotation();

            if (checkBoxType.Checked)
            {
                Glut.glutWireTorus(0.3, 0.65, 16, 16);
            }
            else
            {
                Glut.glutSolidTorus(0.3, 0.65, 16, 16);
            }

            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_LIGHTING); // Будем рассчитывать освещенность
            Gl.glFlush();
        }
Beispiel #17
0
    public override void Recompile()
    {
        Gl.glNewList(idVisualizar, Gl.GL_COMPILE);
        Gl.glPushMatrix();
        Gl.glColor3fv(color);
        Gl.glTranslated(start.x, start.y, start.z);
        Glut.glutSolidTorus(radio / 8.0, radio, 32, 32);
        Glu.GLUquadric sph;
        sph = Glu.gluNewQuadric();
        Glu.gluSphere(sph, radio / 6.0, 32, 32);

        for (int i = 0; i < 3; i++)
        {
            Gl.glPushMatrix();
            Gl.glRotated(120 * i, 0, 0, 1);
            Gl.glRotated(-90, 1, 0, 0);
            sph = Glu.gluNewQuadric();
            Glu.gluCylinder(sph, radio / 8.0, radio / 8.0, radio, 32, 32);
            Gl.glPopMatrix();
        }

        Gl.glPopMatrix();
        Gl.glEndList();
    }
Beispiel #18
0
        // --- Callbacks ---
        #region Display()
        private static void Display()
        {
            if (performanceTiming)
            {
                start = Glut.glutGet(Glut.GLUT_ELAPSED_TIME);
            }

            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);

            if (drawBackground || drawStars || performanceTiming)
            {
                Gl.glMatrixMode(Gl.GL_PROJECTION);
                Gl.glPushMatrix();
                Gl.glLoadIdentity();
                Gl.glOrtho(0, width, 0, height, -1, 1);
                Gl.glMatrixMode(Gl.GL_MODELVIEW);
                Gl.glPushMatrix();
                Gl.glLoadIdentity();
                Gl.glDepthMask(Gl.GL_FALSE);
                Gl.glDisable(Gl.GL_DEPTH_TEST);
                Gl.glDisable(Gl.GL_LIGHTING);

                if (drawBackground)
                {
                    Gl.glEnable(Gl.GL_TEXTURE_2D);
                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, backgroundTexture);
                    Gl.glColor3ub(255, 255, 255);
                    Gl.glBegin(Gl.GL_QUADS);
                    Gl.glTexCoord2i(0, 0);
                    Gl.glVertex2i(0, 0);
                    Gl.glTexCoord2i(1, 0);
                    Gl.glVertex2i(width, 0);
                    Gl.glTexCoord2i(1, 1);
                    Gl.glVertex2i(width, height);
                    Gl.glTexCoord2i(0, 1);
                    Gl.glVertex2i(0, height);
                    Gl.glEnd();
                    Gl.glDisable(Gl.GL_TEXTURE_2D);
                }

                if (drawStars)
                {
                    Gl.glEnable(Gl.GL_BLEND);
                    Gl.glBegin(Gl.GL_LINES);
                    for (i = 0; i < NUMBERSTARS; i++)
                    {
                        stars[i].X += stars[i].VX;
                        if (stars[i].X < width)
                        {
                            Gl.glColor4ub(0, 0, 0, 0);
                            Gl.glVertex2i((int)(stars[i].X - stars[i].VX * 3), (int)stars[i].Y);
                            Gl.glColor4ub(255, 255, 255, 255);
                            Gl.glVertex2i((int)stars[i].X, (int)stars[i].Y);
                        }
                        else
                        {
                            stars[i].X = 0;
                        }
                    }
                    Gl.glEnd();
                    Gl.glDisable(Gl.GL_BLEND);
                }

                if (performanceTiming)
                {
                    float  fps = (1.0f / ((float)(end - last) / 1000.0f));
                    string s   = fps.ToString("F1") + " FPS";

                    Gl.glColor3ub(255, 255, 255);
                    Gl.glRasterPos2i(5, 5);
                    foreach (char c in s)
                    {
                        Glut.glutBitmapCharacter(Glut.GLUT_BITMAP_HELVETICA_18, c);
                    }
                    last = start;
                }

                Gl.glEnable(Gl.GL_LIGHTING);
                Gl.glEnable(Gl.GL_DEPTH_TEST);
                Gl.glDepthMask(Gl.GL_TRUE);
                Gl.glMatrixMode(Gl.GL_PROJECTION);
                Gl.glPopMatrix();
                Gl.glMatrixMode(Gl.GL_MODELVIEW);
                Gl.glPopMatrix();
            }

            Gl.glPushMatrix();
            if (texturing)
            {
                Gl.glTexGeni(Gl.GL_S, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP);
                Gl.glTexGeni(Gl.GL_T, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP);
                Gl.glEnable(Gl.GL_TEXTURE_GEN_S);
                Gl.glEnable(Gl.GL_TEXTURE_GEN_T);
                Gl.glEnable(Gl.GL_TEXTURE_2D);
            }

            Gl.glRotatef(spinY, 0, 1, 0);
            Gl.glColor3ub(196, 196, 196);
            Glut.glutSolidTorus(RI, RO, lod, lod);

            step = (int)(360.0 / numberSpheres);
            for (i = 0; i < numberSpheres; i++)
            {
                Gl.glPushMatrix();
                Gl.glRotatef(step * i + spinZ, 0, 0, 1);
                Gl.glTranslatef(0, RO, 0);
                Gl.glRotatef(step * i + spinX, 1, 0, 0);
                Gl.glTranslatef(0, RI + RI, 0);
                Color((byte)i);
                Sphere(i % numberTextures + 1);
                Gl.glPopMatrix();
            }

            if (texturing)
            {
                Gl.glDisable(Gl.GL_TEXTURE_GEN_S);
                Gl.glDisable(Gl.GL_TEXTURE_GEN_T);
                Gl.glDisable(Gl.GL_TEXTURE_2D);
            }
            Gl.glPopMatrix();

            Glut.glutSwapBuffers();

            if (performanceTiming)
            {
                end = Glut.glutGet(Glut.GLUT_ELAPSED_TIME);
            }
        }
Beispiel #19
0
        // функция отрисовки
        private void Draw()
        {
            // очистка буфера цвета и буфера глубины
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);

            Gl.glClearColor(255, 255, 255, 1);
            // очищение текущей матрицы
            Gl.glLoadIdentity();

            // помещаем состояние матрицы в стек матриц, дальнейшие трансформации затронут только визуализацию объекта
            Gl.glPushMatrix();
            // производим перемещение в зависимости от значений, полученных при перемещении ползунков
            Gl.glTranslated(Inter.Camera.X, Inter.Camera.Y, Inter.Camera.Z);



            // поворот по установленной оси
            //Gl.glRotated(Inter.Angle, Inter.Rotation.X, Inter.Rotation.Y, Inter.Rotation.Z);

            //Gl.glRotated()
            Rotating();
            AutoRotating();


            // и масштабирование объекта
            Gl.glScaled(Inter.Camera.Zoom, Inter.Camera.Zoom, Inter.Camera.Zoom);

            // в зависимости от установленного типа объекта
            switch (ObjectComboBox.SelectedIndex)
            {
            // рисуем нужный объект, используя функции библиотеки GLUT
            case 0:
            {
                if (Inter.Wire)                     // если установлен сеточный режим визуализации
                {
                    Glut.glutWireSphere(2, 16, 16); // сеточная сфера
                }
                else
                {
                    Glut.glutSolidSphere(2, 16, 16);         // полигональная сфера
                }
                break;
            }

            case 1:
            {
                if (Inter.Wire)                          // если установлен сеточный режим визуализации
                {
                    Glut.glutWireCylinder(1, 2, 32, 32); // цилиндр
                }
                else
                {
                    Glut.glutSolidCylinder(1, 2, 32, 32);
                }
                break;
            }

            case 2:
            {
                if (Inter.Wire)           // если установлен сеточный режим визуализации
                {
                    Glut.glutWireCube(2); // куб
                }
                else
                {
                    Glut.glutSolidCube(2);
                }
                break;
            }

            case 3:
            {
                if (Inter.Wire)                      // если установлен сеточный режим визуализации
                {
                    Glut.glutWireCone(2, 3, 32, 32); // конус
                }
                else
                {
                    Glut.glutSolidCone(2, 3, 32, 32);
                }
                break;
            }

            case 4:
            {
                if (Inter.Wire)                           // если установлен сеточный режим визуализации
                {
                    Glut.glutWireTorus(0.5, 1.5, 32, 32); // тор
                }
                else
                {
                    Glut.glutSolidTorus(0.5, 1.5, 32, 32);
                }
                break;
            }

            case 5:
            {
                if (Inter.Wire)                  // если установлен сеточный режим визуализации
                {
                    Glut.glutWireDodecahedron(); // Додекайдер
                }
                else
                {
                    Glut.glutSolidDodecahedron();
                }
                break;
            }

            case 6:
            {
                if (Inter.Wire)                 // если установлен сеточный режим визуализации
                {
                    Glut.glutWireIcosahedron(); // исосахедрон
                }
                else
                {
                    Glut.glutSolidIcosahedron();
                }
                break;
            }

            case 7:
            {
                if (Inter.Wire)         // если установлен сеточный режим визуализации
                {
                    Glut.glutWireOctahedron();
                }
                else
                {
                    Glut.glutSolidOctahedron();
                }
                break;
            }

            case 8:
            {
                if (Inter.Wire)         // если установлен сеточный режим визуализации
                {
                    Glut.glutWireRhombicDodecahedron();
                }
                else
                {
                    Glut.glutSolidRhombicDodecahedron();
                }
                break;
            }

            case 9:
            {
                if (Inter.Wire)         // если установлен сеточный режим визуализации
                {
                    Glut.glutWireSierpinskiSponge(3, new double[] { 0.0, 0.2, 0.5 }, 2);
                }
                else
                {
                    Glut.glutSolidSierpinskiSponge(3, new double[] { 0.0, 0.2, 0.5 }, 2);
                }
                break;
            }

            case 10:
            {
                if (Inter.Wire)             // если установлен сеточный режим визуализации
                {
                    Glut.glutWireTeapot(2); // чайник
                }
                else
                {
                    Glut.glutSolidTeapot(2);
                }
                break;
            }

            case 11:
            {
                if (Inter.Wire)                 // если установлен сеточный режим визуализации
                {
                    Glut.glutWireTetrahedron(); // херня
                }
                else
                {
                    Glut.glutSolidTetrahedron();
                }
                break;
            }

            case 12:
            {
                if (Inter.Wire)         // если установлен сеточный режим визуализации
                {
                    Glut.glutWireSierpinskiSponge(1, new double[] { 0.0, 0.3, 0.5 }, 2);
                }
                else
                {
                    Glut.glutSolidSierpinskiSponge(1, new double[] { 0.0, 0.3, 0.5 }, 2);
                }
                break;
            }

            case 13:
            {
                if (Inter.Wire)         // если установлен сеточный режим визуализации
                {
                    Glut.glutWireSierpinskiSponge(7, new double[] { 0.0, 0.3, 0.5, 0.7, 0.9 }, 2);
                }
                else
                {
                    Glut.glutSolidSierpinskiSponge(7, new double[] { 0.0, 0.3, 0.5, 0.7, 0.9 }, 2);
                }
                break;
            }

                /*
                 * case 100:
                 * {
                 *  if (Inter.Wire) // если установлен сеточный режим визуализации
                 *      Glut.glutWire; // херня
                 *  else
                 *      Glut.glutSolid;
                 *  break;
                 * }
                 */
            }

            if (AutoRotateCheckBox.Checked)
            {
                //Inter.Angle = Inter.Angle == 360 ? -360 : Inter.Angle + 1;
                //ValueAngle.Text = Inter.Angle.ToString();
                //TrackBarAngle.Value = (int)Inter.Angle;
            }

            // возвращаем состояние матрицы
            Gl.glPopMatrix();

            // завершаем рисование
            Gl.glFlush();

            // обновляем элемент AnT
            AnT.Invalidate();
        }
Beispiel #20
0
        private void simpleOpenGlControl1_Paint(object sender, PaintEventArgs e)
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();


            Glu.gluLookAt(Radius * Math.Cos(Latitude * DEGREE_TO_RAD)
                          * Math.Sin(Longitude * DEGREE_TO_RAD),
                          Radius * Math.Sin(Latitude * DEGREE_TO_RAD),
                          Radius * Math.Cos(Latitude * DEGREE_TO_RAD)
                          * Math.Cos(Longitude * DEGREE_TO_RAD),
                          0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

            float[] light1_position  = new float[] { -1.0f, 4.7f, 4.2f, 1.0f };//光的位置設在原點
            float[] light1_direction = new float[3] {
                0.0f, -1.0f, 0.0f
            };                                                        //光的方向設定他是往下照


            float[] light2_position = new float[] { -1.0f, 4.7f, -4.2f, 1.0f }; //光的位置設在原點
            float[] light3_position = new float[] { -1.0f, -4.7f, 4.2f, 1.0f }; //光的位置設在原點

            float[] light3_direction = new float[3] {
                0.0f, 1.0f, 0.0f
            };                                                                   //光的方向設定他是往上照

            float[] light4_position = new float[] { -1.0f, -4.7f, -4.2f, 1.0f }; //光的位置設在原點


            Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, light1_position);
            Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_SPOT_DIRECTION, light1_direction);

            Gl.glLightfv(Gl.GL_LIGHT2, Gl.GL_POSITION, light2_position);
            Gl.glLightfv(Gl.GL_LIGHT2, Gl.GL_SPOT_DIRECTION, light1_direction);

            Gl.glLightfv(Gl.GL_LIGHT3, Gl.GL_POSITION, light3_position);
            Gl.glLightfv(Gl.GL_LIGHT3, Gl.GL_SPOT_DIRECTION, light3_direction);

            Gl.glLightfv(Gl.GL_LIGHT4, Gl.GL_POSITION, light4_position);
            Gl.glLightfv(Gl.GL_LIGHT4, Gl.GL_SPOT_DIRECTION, light3_direction);



            //clock外框
            Gl.glColor3ub(145, 200, 255);
            Gl.glPushMatrix();
            Gl.glRotated(90, 0.0, 1.0, 0.0);
            Glut.glutSolidTorus(1, 8, 100, 100);
            Gl.glPopMatrix();

            //clock中間
            Gl.glColor3ub(255, 255, 162);
            Gl.glPushMatrix();
            Gl.glScaled(0.15, 1.0, 1.0);
            Glut.glutSolidSphere(7.5, 15, 15);
            Gl.glPopMatrix();

            int hour   = DateTime.Now.Hour;
            int minute = DateTime.Now.Minute;
            int second = DateTime.Now.Second;


            //分針
            Gl.glColor3ub(102, 51, 0);
            Gl.glPushMatrix();
            Gl.glRotated(minute * 6, 1.0, 0.0, 0.0);
            Gl.glTranslated(-1.5, 2.5, 0.0);
            Gl.glScaled(0.15, 6.0, 0.3);
            Glut.glutSolidCube(1);
            Gl.glPopMatrix();

            //時針
            Gl.glColor3ub(74, 37, 0);
            Gl.glPushMatrix();
            Gl.glRotated((float)(hour + minute / 60.0) * 30.0, 1.0, 0.0, 0.0);
            Gl.glTranslated(-1.3, 1.4, 0.0);
            Gl.glScaled(0.15, 3.6, 0.3);
            Glut.glutSolidCube(1);
            Gl.glPopMatrix();

            //秒針
            Gl.glColor3ub(0, 0, 0);
            Gl.glPushMatrix();
            Gl.glRotated(second * 6, 1.0, 0.0, 0.0);
            Gl.glTranslated(-1.7, 2.5, 0.0);
            Gl.glScaled(0.15, 6.0, 0.2);
            Glut.glutSolidCube(1);
            Gl.glPopMatrix();

            Gl.glColor3ub(153, 197, 22);
            Gl.glPushMatrix();
            allDegree();
            Gl.glPopMatrix();

            label1.Text = hour + ":" + minute + ":" + second;
        }
Beispiel #21
0
        static void display()
        {
            /* World-space positions for light and eye. */
            float[] eyePosition   = { 0, 0, 8, 1 };
            float[] lightPosition = { 5 * (float)Math.Sin(myLightAngle),
                                      1.5f,
                                      5 * (float)Math.Cos(myLightAngle), 1 };

            float[] translateMatrix = new float[16], rotateMatrix = new float[16],
            modelMatrix     = new float[16], invModelMatrix = new float[16], viewMatrix = new float[16],
            modelViewMatrix = new float[16], modelViewProjMatrix = new float[16];
            float[] objSpaceEyePosition = new float[4], objSpaceLightPosition = new float[4];

            Cg.cgSetParameter1f(myCgVertexParam_time, myTime);

            buildLookAtMatrix(eyePosition[0], eyePosition[1], eyePosition[2],
                              0, 0, 0,
                              0, 1, 0,
                              ref viewMatrix);

            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);

            CgGl.cgGLEnableProfile(myCgVertexProfile);
            checkForCgError("enabling vertex profile");

            CgGl.cgGLEnableProfile(myCgFragmentProfile);
            checkForCgError("enabling fragment profile");

            CgGl.cgGLBindProgram(myCgVertexProgram);
            checkForCgError("binding vertex program");

            CgGl.cgGLBindProgram(myCgFragmentProgram);
            checkForCgError("binding fragment program");

            /*** Render green solid bulging sphere ***/

            /* modelView = rotateMatrix * translateMatrix */
            makeRotateMatrix(70f, 1f, 1f, 1f, ref rotateMatrix);
            makeTranslateMatrix(2.2f, 1f, 0.2f, ref translateMatrix);
            multMatrix(ref modelMatrix, translateMatrix, rotateMatrix);

            /* invModelMatrix = inverse(modelMatrix) */
            invertMatrix(ref invModelMatrix, ref modelMatrix);

            /* Transform world-space eye and light positions to sphere's object-space. */
            transform(ref objSpaceEyePosition, invModelMatrix, eyePosition);
            Cg.cgSetParameter3fv(myCgVertexParam_eyePosition, out objSpaceEyePosition[0]);
            transform(ref objSpaceLightPosition, invModelMatrix, lightPosition);
            Cg.cgSetParameter3fv(myCgVertexParam_lightPosition, out objSpaceLightPosition[0]);

            /* modelViewMatrix = viewMatrix * modelMatrix */
            multMatrix(ref modelViewMatrix, viewMatrix, modelMatrix);

            /* modelViewProj = projectionMatrix * modelViewMatrix */
            multMatrix(ref modelViewProjMatrix, myProjectionMatrix, modelViewMatrix);

            /* Set matrix parameter with row-major matrix. */
            Cg.cgSetMatrixParameterfr(myCgVertexParam_modelViewProj, out modelViewProjMatrix[0]);
            Cg.cgSetParameter4f(myCgVertexParam_Kd, 0.1f, 0.7f, 0.1f, 1f);  /* Green */
            Glut.glutSolidSphere(1.0, 40, 40);

            /*** Render red solid bulging torus ***/

            /* modelView = viewMatrix * translateMatrix */
            makeTranslateMatrix(-2f, -1.5f, 0f, ref translateMatrix);
            makeRotateMatrix(55, 1, 0, 0, ref rotateMatrix);
            multMatrix(ref modelMatrix, translateMatrix, rotateMatrix);

            /* invModelMatrix = inverse(modelMatrix) */
            invertMatrix(ref invModelMatrix, ref modelMatrix);

            /* Transform world-space eye and light positions to sphere's object-space. */
            transform(ref objSpaceEyePosition, invModelMatrix, eyePosition);
            Cg.cgSetParameter3fv(myCgVertexParam_eyePosition, out objSpaceEyePosition[0]);
            transform(ref objSpaceLightPosition, invModelMatrix, lightPosition);
            Cg.cgSetParameter3fv(myCgVertexParam_lightPosition, out objSpaceLightPosition[0]);

            /* modelViewMatrix = viewMatrix * modelMatrix */
            multMatrix(ref modelViewMatrix, viewMatrix, modelMatrix);

            /* modelViewProj = projectionMatrix * modelViewMatrix */
            multMatrix(ref modelViewProjMatrix, myProjectionMatrix, modelViewMatrix);

            /* Set matrix parameter with row-major matrix. */
            Cg.cgSetMatrixParameterfr(myCgVertexParam_modelViewProj, out modelViewProjMatrix[0]);
            Cg.cgSetParameter4f(myCgVertexParam_Kd, 0.8f, 0.1f, 0.1f, 1f);  /* Red */
            Glut.glutSolidTorus(0.15, 1.7, 40, 40);

            /*** Render light as emissive yellow ball ***/

            CgGl.cgGLBindProgram(myCgLightVertexProgram);
            checkForCgError("binding light vertex program");

            /* modelView = translateMatrix */
            makeTranslateMatrix(lightPosition[0], lightPosition[1], lightPosition[2],
                                ref modelMatrix);

            /* modelViewMatrix = viewMatrix * modelMatrix */
            multMatrix(ref modelViewMatrix, viewMatrix, modelMatrix);

            /* modelViewProj = projectionMatrix * modelViewMatrix */
            multMatrix(ref modelViewProjMatrix, myProjectionMatrix, modelViewMatrix);

            /* Set matrix parameter with row-major matrix. */
            Cg.cgSetMatrixParameterfr(myCgLightVertexParam_modelViewProj,
                                      out modelViewProjMatrix[0]);
            Glut.glutSolidSphere(0.1, 12, 12);

            CgGl.cgGLDisableProfile(myCgVertexProfile);
            checkForCgError("disabling vertex profile");

            CgGl.cgGLDisableProfile(myCgFragmentProfile);
            checkForCgError("disabling fragment profile");

            Glut.glutSwapBuffers();
        }
Beispiel #22
0
        private void openGLControl_OpenGLDraw(object sender, OpenGLEventArgs args)
        {
            OpenGL gl = openGLControl.OpenGL;

            gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
            gl.MatrixMode(OpenGL.GL_MODELVIEW);     // Задание матричного режима, GL_MODELVIEW - объектно-видовая матрица
            gl.PushMatrix();

            if (Y == 1)
            {
                gl.ClearColor(0.8f, 0.8f, 0.8f, 0.0f);
            }
            else if (Y == 2)
            {
                gl.ClearColor(0.5f, 0.7f, 0.9f, 0.0f);
            }
            else if (Y == 3)
            {
                gl.ClearColor(0.9f, 0.5f, 0.7f, 0.0f);
            }
            else
            {
                gl.ClearColor(0.9f, 0.5f, 0f, 0.0f);
            }

            if (G == 1)
            {
                B8.Content = "Покраска";
            }
            else if (G == 2)
            {
                B8.Content = "Покраска и каркас";
            }
            else
            {
                B8.Content = "Каркас";
            }

            if (U1 == 1)
            {
                B12.Content = "Покраска 1 объекта";
            }
            else if (U1 == 2)
            {
                B12.Content = "Покраска и каркас 1 объекта";
            }
            else
            {
                B12.Content = "Каркас 1 объекта";
            }

            if (U2 == 1)
            {
                B13.Content = "Покраска 2 объекта";
            }
            else if (U2 == 2)
            {
                B13.Content = "Покраска и каркас 2 объекта";
            }
            else
            {
                B13.Content = "Каркас 2 объекта";
            }

            if (U3 == 1)
            {
                B14.Content = "Покраска 3 объекта";
            }
            else if (U3 == 2)
            {
                B14.Content = "Покраска и каркас 3 объекта";
            }
            else
            {
                B14.Content = "Каркас 3 объекта";
            }

            if (F == 1)
            {
                gl.Color(0.9, 0, 0);        // Устанавливаем цвет объекта

                if (G == 2)
                {
                    Glut.glutSolidTeapot(2);            // Отрисовка чайника с помощью библиотеки FreeGLUT
                }
                else if (G == 3)
                {
                    Glut.glutSolidTeapot(2);    // Отрисовка чайника с помощью библиотеки FreeGLUT
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireTeapot(2);

                gl.LoadIdentity();
                gl.Rotate(10, 2.0f, 0.0f, -2.0f);
                gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);
            }
            else if (F == 2)
            {
                gl.LoadIdentity();
                gl.Rotate(20, 1.0f, 0.0f, 0.0f);
                gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);

                gl.Color(0.9, 0, 0);

                if (G == 2)
                {
                    Glut.glutSolidCube(3);
                }
                else if (G == 3)
                {
                    Glut.glutSolidCube(3);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireCube(3);
            }
            else if (F == 3)
            {
                gl.LoadIdentity();
                gl.Rotate(80, -30.0f, 25.0f, 20.0f);
                gl.Rotate(rotation, 0.0f, 0.0f, 1.0f);

                gl.Translate(0, 0, -2);

                gl.Color(0.9, 0, 0);        // Устанавливаем цвет объекта

                gl.Scale(0.4, 0.4, 0.4);
                if (G == 2)
                {
                    Glut.glutSolidCone(2.0, 12.0, 10, 0);
                }
                else if (G == 3)
                {
                    Glut.glutSolidCone(2.0, 12.0, 10, 0);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireCone(2.0, 12.0, 10, 0);
            }
            else if (F == 4)
            {
                gl.LoadIdentity();
                gl.Rotate(0, 1.0f, 1.0f, 0.0f);
                gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);

                gl.Color(0.9, 0, 0);        // Устанавливаем цвет объекта

                gl.Scale(2, 2, 2);
                if (G == 2)
                {
                    Glut.glutSolidIcosahedron();
                }
                else if (G == 3)
                {
                    Glut.glutSolidIcosahedron();
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireIcosahedron();
            }
            else if (F == 5)
            {
                gl.LoadIdentity();
                gl.Rotate(0, 1.0f, 1.0f, 0.0f);
                gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);

                gl.Color(0.9, 0, 0);        // Устанавливаем цвет объекта

                if (G == 2)
                {
                    Glut.glutSolidDodecahedron();
                }
                else if (G == 3)
                {
                    Glut.glutSolidDodecahedron();
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireDodecahedron();

                gl.PopMatrix(); // Возврат сохраненной в стеке матрицы
                gl.Flush();     // Ожидание, пока библиотека OpenGL завершит визуализацию кадра, очистка буфера
            }
            else if (F == 6)
            {
                gl.LoadIdentity();
                gl.Rotate(0, 1.0f, 1.0f, 0.0f);
                gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);

                gl.Color(0.9, 0, 0);        // Устанавливаем цвет объекта

                if (G == 2)
                {
                    Glut.glutSolidSphere(2, 15, 15);
                }
                else if (G == 3)
                {
                    Glut.glutSolidSphere(2, 15, 15);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireSphere(2, 15, 15);

                gl.PopMatrix(); // Возврат сохраненной в стеке матрицы
                gl.Flush();     // Ожидание, пока библиотека OpenGL завершит визуализацию кадра, очистка буфера
            }
            else if (F == 7)
            {
                gl.LoadIdentity();
                gl.Rotate(30, 1, 1, 0);
                gl.Rotate(rotation, 0.0f, 0.0f, 1.0f);

                gl.Scale(1.5, 1.5, 1.5);
                gl.Color(0, 0.9, 0);
                if (U1 == 2)
                {
                    Glut.glutSolidDodecahedron();
                }
                else if (U1 == 3)
                {
                    Glut.glutSolidDodecahedron();
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireDodecahedron();

                gl.Scale(0.4, 0.4, 0.4);
                gl.Color(0, 0, 0.9);
                if (U2 == 2)
                {
                    Glut.glutSolidCube(4);
                }
                else if (U2 == 3)
                {
                    Glut.glutSolidCube(4);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireCube(4);

                gl.Scale(0.7, 0.7, 0.7);
                gl.Color(0.9, 0, 0);
                if (U3 == 2)
                {
                    Glut.glutSolidDodecahedron();
                }
                else if (U3 == 3)
                {
                    Glut.glutSolidDodecahedron();
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireDodecahedron();

                gl.PopMatrix();
                gl.Flush();
            }
            else if (F == 8)
            {
                gl.LoadIdentity();
                gl.Rotate(90, 5, 1, 0);
                gl.Rotate(rotation, 0.0f, 0.0f, 1.0f);

                gl.Color(0.9, 0, 0);

                gl.Scale(0.07, 0.07, 0.07);
                if (U1 == 2)
                {
                    Glut.glutSolidTorus(5, 10, 10, 25);
                }
                else if (U1 == 3)
                {
                    Glut.glutSolidTorus(5, 10, 10, 25);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireTorus(5, 10, 10, 15);

                gl.Translate(-45, -5, -5);

                gl.Color(0.9, 0, 0);

                gl.Color(0.9, 0.9, 0);
                if (U2 == 2)
                {
                    Glut.glutSolidSphere(20, 25, 25);
                }
                else if (U2 == 3)
                {
                    Glut.glutSolidSphere(20, 25, 25);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireSphere(20, 25, 25);

                gl.PopMatrix();
                gl.Flush();
            }
            else
            {
                gl.LoadIdentity();
                gl.Rotate(20, 2.0f, 0.0f, -2.0f);
                gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);

                gl.Color(0.9, 0, 0);

                if (U1 == 2)
                {
                    Glut.glutSolidTeapot(1.5);
                }
                else if (U1 == 3)
                {
                    Glut.glutSolidTeapot(1.5);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireTeapot(1.5);

                gl.Color(0.9, 0.9, 0);
                if (U2 == 2)
                {
                    Glut.glutSolidSphere(3, 15, 15);
                }
                else if (U2 == 3)
                {
                    Glut.glutSolidSphere(3, 15, 15);
                    gl.Color(0, 0, 0);
                }
                Glut.glutWireSphere(3, 15, 15);

                gl.PopMatrix();
                gl.Flush();
            }

            rotation += 3.0f;
        }
        private void ShowSolid(int obj)
        {
            switch (obj)
            {
            // Конус
            case 1:
            {
                Glut.glutSolidCone(0.2, 0.75, 16, 8);
                break;
            }

            // Куб
            case 2:
            {
                Glut.glutSolidCube(0.75);
                break;
            }

            //Цилиндр
            case 3:
            {
                Glut.glutSolidCylinder(0.2, 0.75, 16, 16);
                break;
            }

            // Додекаэдр
            case 4:
            {
                Gl.glScaled(0.5, 0.5, 0.5);
                Glut.glutSolidDodecahedron();
                break;
            }

            // Икосаэдр
            case 5:
            {
                Glut.glutSolidIcosahedron();
                break;
            }

            // Октаэдр
            case 6:
            {
                Glut.glutSolidOctahedron();
                break;
            }

            // Ромбический додекаэдр
            case 7:
            {
                Glut.glutSolidRhombicDodecahedron();
                break;
            }

            //Фрактал Губка Серпиского
            case 8:
            {
                double[] offset = { 0.0 };
                Glut.glutSolidSierpinskiSponge(7, offset, 1);
                break;
            }

            // Сфера
            case 9:
            {
                Glut.glutSolidSphere(0.75, 16, 16);
                break;
            }

            // Чайник
            case 10:
            {
                Glut.glutSolidTeapot(0.5);
                break;
            }

            // Тетраэдр
            case 11:
            {
                Gl.glRotated(180, 0, 1, 0);
                Glut.glutSolidTetrahedron();
                break;
            }

            // Тор
            case 12:
            {
                Glut.glutSolidTorus(0.15, 0.65, 16, 16);
                break;
            }
            }
        }
Beispiel #24
0
        private void simpleOpenGlControl1_Paint(object sender, PaintEventArgs e)
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);

            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            // Glu.gluLookAt(0.0, 30.0, 30.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
            Glu.gluLookAt(0.0, 45.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0);

            float[] mat_ambient  = new float[3];
            float[] mat_diffuse  = new float[3];
            float[] mat_specular = new float[3];
            float   mat_shininess;

            float[] light0_position = new float[4] {
                0.0f, 0.0f, 0.0f, 1.0f
            };
            float[] light0_direction = new float[] { 0.0f, 0.0f, -1.0f };

            /* 製作一個中心球 會發亮
             * Gl.glPushMatrix();
             * Gl.glRotated(light0_rot,0,1,0); //依照Y軸旋轉
             * Gl.glTranslated(0.0, 0.0, 7.5);
             * Gl.glDisable(Gl.GL_LIGHTING); //讓這個球不售光影計算 所以把光影計算關閉
             * Gl.glColor3ub(253, 200, 0);
             * Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, light0_position);
             * Glut.glutSolidSphere(0.3,16,16);
             * Gl.glEnable(Gl.GL_LIGHTING); //打開光影計算
             * Gl.glPopMatrix();*/


            //探照燈
            Gl.glEnable(Gl.GL_COLOR_MATERIAL);
            Gl.glPushMatrix();
            Gl.glRotated(light0_rot, 0.0, 1.0, 0.0);  //let the flashlight rotate
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, light0_position);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_SPOT_DIRECTION, light0_direction);
            Gl.glLightf(Gl.GL_LIGHT0, Gl.GL_SPOT_CUTOFF, (float)(Math.Atan(0.3) * 180.0 / Math.PI));
            Gl.glLightf(Gl.GL_LIGHT0, Gl.GL_SPOT_EXPONENT, 10.0f);
            Gl.glColor3ub(255, 0, 0);
            Gl.glTranslated(0.0, 0.0, -1.0);
            Glut.glutSolidCone(0.3, 1.0, 10, 10);
            Gl.glColor3ub(255, 255, 0);
            Gl.glScaled(1.0, 1.0, 0.01);
            Gl.glDisable(Gl.GL_LIGHTING);
            Glut.glutSolidSphere(0.3, 10, 10);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_COLOR_MATERIAL);


            double x = 10.0;

            Gl.glRotated(rot, 0.0, 1.0, 0.0);


            // Brass 黃銅
            mat_ambient[0] = 0.329412f;
            mat_ambient[1] = 0.223529f;
            mat_ambient[2] = 0.027451f;
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT, mat_ambient);
            mat_diffuse[0] = 0.780392f;
            mat_diffuse[1] = 0.568627f;
            mat_diffuse[2] = 0.113725f;
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, mat_diffuse);
            mat_specular[0] = 0.780392f;
            mat_specular[1] = 0.568627f;
            mat_specular[2] = 0.113725f;
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, mat_specular);
            mat_shininess = 27.8974f;
            Gl.glMaterialf(Gl.GL_FRONT, Gl.GL_SHININESS, mat_shininess);


            Gl.glEnable(Gl.GL_COLOR_MATERIAL);   //打開色彩材質的功能 讓glColor3d的功能出現
            Random rn = new Random(1);

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[0], 1, 0, 0);
            Gl.glRotated(yRot[0], 0, 1, 0);
            Glut.glutSolidSphere(1.0, 20, 20);
            Gl.glPopMatrix();

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(40.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[1], 1, 0, 0);
            Gl.glRotated(yRot[1], 0, 1, 0);
            Glut.glutSolidCube(1.0);
            Gl.glPopMatrix();

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(80.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[2], 1, 0, 0);
            Gl.glRotated(yRot[2], 0, 1, 0);
            Glut.glutSolidCone(0.5, 1.0, 20, 20);
            Gl.glPopMatrix();

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(120.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[3], 1, 0, 0);
            Gl.glRotated(yRot[3], 0, 1, 0);
            Glut.glutSolidTorus(0.5, 1.0, 20, 20);
            Gl.glPopMatrix();

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(160.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[4], 1, 0, 0);
            Gl.glRotated(yRot[4], 0, 1, 0);
            Glut.glutSolidDodecahedron();
            Gl.glPopMatrix();

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(200.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[5], 1, 0, 0);
            Gl.glRotated(yRot[5], 0, 1, 0);
            Glut.glutSolidOctahedron();
            Gl.glPopMatrix();

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(240.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[6], 1, 0, 0);
            Gl.glRotated(yRot[6], 0, 1, 0);
            Glut.glutSolidTetrahedron();
            Gl.glPopMatrix();

            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(280.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[7], 1, 0, 0);
            Gl.glRotated(yRot[7], 0, 1, 0);
            Glut.glutSolidIcosahedron();
            Gl.glPopMatrix();


            Gl.glColor3ub((byte)rn.Next(0, 255), (byte)rn.Next(0, 255), (byte)rn.Next(0, 255));
            Gl.glPushMatrix();
            Gl.glRotated(320.0, 0.0, 1.0, 0.0);
            Gl.glTranslated(0.0, 0.0, x);
            Gl.glRotated(xRot[8], 1, 0, 0);
            Gl.glRotated(yRot[8], 0, 1, 0);
            Gl.glFrontFace(Gl.GL_CW);           //所有圖形裡面 只有茶壺是順時針法則,其他的都是逆時針法則
            Glut.glutSolidTeapot(0.5);
            Gl.glFrontFace(Gl.GL_CCW);          //要把他的狀態改回逆時針法則,不改會影響到其他物件
            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_COLOR_MATERIAL); //關掉色彩材質的功能
        }