Ejemplo n.º 1
0
        private void DrawTetrahedron()
        {
            //рисование тетраэдра с помощью библиотеки 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, -3);                                                                                                            // перенос по Z

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

            if (Wire.Checked)
            {
                Glut.glutWireTetrahedron(); // сеточный режим
            }
            else
            {
                Glut.glutSolidTetrahedron(); //режим с заливкой
            }
            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_LIGHTING); // пересчитываем освещение
            Gl.glFlush();                 // довыполнение предыдущих команд
        }
Ejemplo n.º 2
0
        private void DrawTetrahedron()
        {
            Gl.glDisable(Gl.GL_BLEND);

            Gl.glColor3f(1, 0.7f, 0.23f);

            Gl.glPushMatrix();

            GlutRotation();

            if (checkBoxType.Checked)
            {
                Glut.glutWireTetrahedron();
            }
            else
            {
                Glut.glutSolidTetrahedron();
            }

            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_LIGHTING); // Будем рассчитывать освещенность
            Gl.glFlush();
        }
        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;
            }
            }
        }
Ejemplo n.º 4
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); //關掉色彩材質的功能
        }
Ejemplo n.º 5
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();
        }