Ejemplo n.º 1
0
        //Отображение брусочка длиной в 1А
        private void paintSample()
        {
            float w, h;

            if ((float)ant.Width <= (float)ant.Height)
            {
                w = viewSize;
                h = viewSize * (float)ant.Height / (float)ant.Width;
            }
            else
            {
                w = viewSize * (float)ant.Width / (float)ant.Height;
                h = viewSize;
            }
            Vector sample = new Vector(ant.Width - 10, ant.Height - 20, 0);

            sample.X = (sample.X - ant.Width / 2) * 2 * w / (ant.Width * scale);
            sample.Y = (ant.Height / 2 - sample.Y) * 2 * h / (ant.Height * scale);
            sample.Z = 95 / scale;
            float rad = 10 * 2 * h / (ant.Height * scale);

            Gl.glPushMatrix();
            Gl.glScalef(scale, scale, scale);
            Gl.glTranslatef(sample.X, sample.Y, sample.Z);
            Gl.glRotatef(-90f, 0f, 1f, 0f);
            Gl.glColor3f(0.2f, 0.2f, 1.0f);
            Glut.glutSolidCylinder(rad, 1f, 20, 20);
            Gl.glPopMatrix();
        }
Ejemplo n.º 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();
            }
        }
Ejemplo n.º 3
0
        private void DrawLever()
        {
            int leverHeight = 70;

            textureLoader.LoadTextureForModel("metal.jpg");
            uint metalTexture = textureLoader.GetTextureObj();

            Gl.glEnable(Gl.GL_TEXTURE_2D);
            Gl.glEnable(Gl.GL_TEXTURE_GEN_S);
            Gl.glEnable(Gl.GL_TEXTURE_GEN_T);
            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.glBindTexture(Gl.GL_TEXTURE_2D, metalTexture);

            Gl.glPushMatrix();
            Gl.glRotated(90, 1, 0, 0);
            Gl.glTranslated(0, 0, -leverHeight);
            Glut.glutSolidCylinder(1, leverHeight, 16, 16);

            // отключаем режим текстурирования
            Gl.glDisable(Gl.GL_TEXTURE_2D);
            Gl.glDisable(Gl.GL_TEXTURE_GEN_S);
            Gl.glDisable(Gl.GL_TEXTURE_GEN_T);
            Gl.glDisable(Gl.GL_TEXTURE_2D);

            Gl.glColor3d(1, 0.01, 0.01);
            Glut.glutSolidSphere(2, 16, 16);
            Gl.glPopMatrix();
        }
Ejemplo n.º 4
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();
        }
Ejemplo n.º 5
0
        static void OnDisplay()
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            Gl.glLoadIdentity();
            Glu.gluLookAt(eye_x, eye_y, eye_z, 0, -10, 0, 1, 0, 0);
            Gl.glRotated(aX, 1, 0, 0);
            Gl.glRotated(aY, 0, 1, 0);
            Gl.glRotated(aZ, 0, 0, 1);
            Gl.glTranslated(1.5, 0, 0);

            Gl.glEnable(Gl.GL_TEXTURE_2D);

            //Glu.gluQuadricTexture();

            //основание
            Gl.glTranslated(-1.5, 0, 0);
            Glut.glutSolidSphere(1.1, 50, 50);

            //тело
            Gl.glTranslated(1.6, 0, 0);
            Glut.glutSolidSphere(0.75, 50, 50);

            //голова
            Gl.glTranslated(1.1, 0, 0);
            Glut.glutSolidSphere(0.55, 50, 50);

            //правая рука
            Gl.glTranslated(-1, 0, 0);
            Gl.glRotated(20, 0, 1, 0);
            Glut.glutSolidCylinder(0.05, 2.5, 50, 50);

            //левая рука
            Gl.glRotated(-140, 0, -1, 0);
            Glut.glutSolidCylinder(0.05, 2.5, 50, 50);

            //шляпа
            Gl.glTranslated(-1.3, 0, 0.47);
            Gl.glRotated(290, 0, 1, 0);
            Glut.glutSolidCone(0.5, 0.75, 50, 50);

            //нос
            Gl.glTranslated(0, 0.3, -0.4);
            Gl.glRotated(275, 1, 0, 0);
            Glut.glutSolidCone(0.07, 0.75, 50, 50);

            //правый глаз
            Gl.glTranslated(-0.2, -0.25, 0.15);
            Glut.glutSolidSphere(0.05, 50, 50);

            //левый глаз
            Gl.glTranslated(0.4, 0, 0);
            Glut.glutSolidSphere(0.05, 50, 50);

            //рот
            Gl.glTranslated(-0.47, 0.4, 0.0175);
            Gl.glRotated(90, 0, 1, 0);
            Glut.glutSolidCylinder(0.05, 0.5, 50, 50);

            Glut.glutSwapBuffers();
        }
Ejemplo n.º 6
0
        private void Line()
        {
            Gl.glPushMatrix();
            Gl.glTranslated(0f, -1.0f, 0f);
            Gl.glRotated(-90, 1f, 0f, 0f);
            Gl.glColor3ub(200, 200, 200);
            Gl.glPushMatrix();
            Gl.glTranslated(0f, 0.75f, 0f);
            Glut.glutSolidCylinder(0.05f, 1.2f, 20, 1);
            Gl.glPopMatrix();
            Gl.glPushMatrix();
            Gl.glTranslated(0f, -0.75f, 0f);
            Glut.glutSolidCylinder(0.05f, 1.2f, 20, 1);
            Gl.glPopMatrix();
            Gl.glPushMatrix();
            Gl.glTranslated(-0.75f, 0f, 0f);
            Glut.glutSolidCylinder(0.05f, 1.2f, 20, 1);
            Gl.glPopMatrix();
            Gl.glPushMatrix();
            Gl.glTranslated(0.75f, 0f, 0f);
            Glut.glutSolidCylinder(0.05f, 1.2f, 20, 1);
            Gl.glPopMatrix();

            Gl.glTranslated(0f, 0.0f, 0.1f);
            DrawCircle(1, 20);

            //bottom
            Gl.glColor3ub(220, 180, 155);
            Gl.glTranslated(0f, 0.0f, -0.102f);
            Glut.glutSolidCylinder(1f, 0.1f, 20, 1);

            Gl.glPopMatrix();
        }
Ejemplo n.º 7
0
        public void Draw()
        {
            var x = 30;
            Gl.glPushMatrix();
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, color);
            Gl.glTranslated(position.x, position.y, position.z);
            Gl.glRotated(rot_angle, rotation.x, rotation.y, rotation.z);
            Glut.glutSolidCylinder( radius, height, 6, 6);
            Gl.glPopMatrix(); 
            float[] MatrixColorOX = { 1, 0, 0, 1 };
            

        }
Ejemplo n.º 8
0
        private void DrawCylinder()
        {
            //рисование цилиндра с помощью библиотеки 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.3f, -2);                                                                                                        // перенос по Y,Z
            RotationGlut();                                                                                                                       // поворот

            if (Wire.Checked)
            {
                Glut.glutWireCylinder(0.2, 0.75, 16, 16);// сеточный режим
            }
            else
            {
                Glut.glutSolidCylinder(0.2, 0.75, 16, 16);//режим с заливкой
            }
            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_LIGHTING); // пересчитываем освещение
            Gl.glFlush();                 // довыполнение предыдущих команд
        }
Ejemplo n.º 9
0
        public override void Draw()
        {
            Gl.glPushMatrix();
            {
                Normalize();
                Gl.glScaled(this.Size, this.Size, this.Size);
                DrawingService.PickTexture(frontTexture);
                DrawPanel(Side.Back);

                DrawingService.PickTexture(TextureNames.Body);
                DrawBody(Side.Front);
                DrawPanel(Side.Front);


                DrawBody(Side.Back);

                Gl.glPushMatrix();
                Gl.glRotated(90, 0, 0, 1);
                Gl.glTranslated(0.5, -0.5, 0);
                DrawPanel(Side.Front);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glRotated(-90, 0, 0, 1);
                Gl.glTranslated(-0.5, -0.5, 0);
                DrawPanel(Side.Front);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glRotated(90, 0, 1, 0);
                Gl.glTranslated(0.5, 0.5, 0.5);
                Gl.glColor3f(1, 0, 0);
                DrawingService.PickTexture(TextureNames.Metal);
                Glut.glutSolidCylinder(0.25, 0.25, 25, 25);
                Gl.glPopMatrix();
            }
            Gl.glPopMatrix();
        }
Ejemplo n.º 10
0
        private void DrawCylinder()
        {
            Gl.glDisable(Gl.GL_BLEND);

            Gl.glColor3f(0.5f, 0.84f, 1f);

            Gl.glPushMatrix();

            GlutRotation();

            if (checkBoxType.Checked)
            {
                Glut.glutWireCylinder(0.2, 0.75, 16, 16);
            }
            else
            {
                Glut.glutSolidCylinder(0.2, 0.75, 16, 16);
            }

            Gl.glPopMatrix();
            Gl.glDisable(Gl.GL_LIGHTING); // Будем рассчитывать освещенность
            Gl.glFlush();
        }
Ejemplo n.º 11
0
        private void DrawApple()
        {
            float[] color1 = new float[4] {
                1, 0, 0, 1
            };
            float[] color2 = new float[4] {
                0, 0, 0, 1
            };
            float[] color3 = new float[4] {
                0, 1, 0, 1
            };
            float[] shininess = new float[1] {
                30
            };

            /*if (wire)
             * {
             *
             *  Gl.glTranslated(xold, yold, -d);
             *  Gl.glTranslated(left * d - right * d, up * d - down * d, 0);
             *  Glut.glutWireSphere(d / 2, 16, 16);
             *  Gl.glTranslated(0, 0, -d);
             *  Glut.glutWireCylinder((double)(d * 0.05), (double)(d * 0.7), 8, 8);
             *  Gl.glTranslated(0, -d * 0.5, d * 0.3);
             *  Gl.glRotated(0, 0, 1, 0);
             *  Glut.glutWireCylinder((double)(d * 0.7), (double)(d * 0.1), 4, 1);
             *  xold = xold + left * d - right * d;
             *  yold = yold + up * d - down * d;
             *
             *
             * }
             * else
             */
            {
                Gl.glTranslated(xold, yold, -d);
                Gl.glTranslated(left * d - right * d, up * d - down * d, 0);

                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, color1);
                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, color1);
                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SHININESS, shininess);

                Glut.glutSolidSphere(d / 2, 16, 16);
                Gl.glTranslated(0, 0, -d);

                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, color2);
                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, color2);
                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SHININESS, shininess);

                Glut.glutSolidCylinder((double)(d * 0.05), (double)(d * 0.7), 8, 8);
                Gl.glTranslated(0, -d * 0.5, d * 0.3);
                Gl.glRotated(30, 0, 1, 0);

                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, color3);
                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, color3);
                Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SHININESS, shininess);

                Glut.glutSolidCylinder((double)(d * 0.5), (double)(d * 0.1), 4, 1);
                xold = xold + left * d - right * d;
                yold = yold + up * d - down * d;
            }
        }
Ejemplo n.º 12
0
        private void paintBonds()
        {
            Vector disp = new Vector(molecule.Center.X,
                                     molecule.Center.Y, molecule.Center.Z); // displacement - смещение молекулы от центра

            for (int i = 0; i < molecule.K; i++)
            {
                foreach (Bond bond in molecule.getAtom(i).Bonds)
                {
                    if (!bond.IsPainted && bond.BondWith > -1)
                    {
                        Vector vi = new Vector(molecule.getAtom(i).X,
                                               molecule.getAtom(i).Y, molecule.getAtom(i).Z);
                        Vector vj = new Vector(molecule.getAtom(bond.BondWith).X,
                                               molecule.getAtom(bond.BondWith).Y, molecule.getAtom(bond.BondWith).Z);
                        Vector v2 = new Vector(vj.X - vi.X,
                                               vj.Y - vi.Y, vj.Z - vi.Z);
                        Vector     v1 = new Vector(0, 0, vi & vj);
                        Quaternion p  = v1 | v2;

                        /*
                         * if (molecule.getAtom(i).Transparency < 255)
                         * {
                         *  Gl.glEnable(Gl.GL_ALPHA_TEST);
                         *  Gl.glAlphaFunc(Gl.GL_ALWAYS, 0.5f); //???
                         *  Gl.glEnable(Gl.GL_BLEND);
                         *  Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
                         *  Gl.glDisable(Gl.GL_DEPTH_TEST);
                         * }
                         * */
                        Gl.glPushMatrix();
                        Gl.glColor4f(0.85f, 0.85f, 0.85f, 0.3f);
                        Gl.glTranslatef(vi.X - disp.X,
                                        vi.Y - disp.Y, vi.Z - disp.Z);
                        double alfa = 2 * Math.Acos(p.W);
                        //Gl.glRotatef((float)(a * 180 / 3.14), cp.X, cp.Y, cp.Z);
                        Gl.glRotatef((float)(alfa * 180 / 3.14), (float)(p.X / Math.Sin(alfa / 2)),
                                     (float)(p.Y / Math.Sin(alfa / 2)), (float)(p.Z / Math.Sin(alfa / 2)));
                        Glut.glutSolidCylinder(0.1f, vi & vj, 20, 20);
                        Gl.glPopMatrix();

                        /*
                         * if (molecule.getAtom(i).Transparency < 255)
                         * {
                         *  Gl.glDisable(Gl.GL_BLEND);
                         *  Gl.glDisable(Gl.GL_ALPHA_TEST);
                         *  Gl.glEnable(Gl.GL_DEPTH_TEST);
                         * }
                         */

                        //Теперь помечаем эту связь в обоих атомах
                        //как уже отрисованную
                        bond.IsPainted = true;
                        foreach (Bond bnd in molecule.getAtom(bond.BondWith).Bonds)
                        {
                            if (bnd.BondWith == i)
                            {
                                bnd.IsPainted = true;
                            }
                        }
                    }
                }
            }
            molecule.resetBonds();
        }
Ejemplo n.º 13
0
        private void DrawRail()
        {
            textureLoader.LoadTextureForModel("metal.jpg");
            uint metalTexture = textureLoader.GetTextureObj();

            textureLoader.LoadTextureForModel("wood.jpg");
            uint woodTexture = textureLoader.GetTextureObj();

            Gl.glEnable(Gl.GL_TEXTURE_2D);
            Gl.glEnable(Gl.GL_TEXTURE_GEN_S);
            Gl.glEnable(Gl.GL_TEXTURE_GEN_T);
            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.glPushMatrix();
            Gl.glRotated(90, 1, 0, 0);
            //Gl.glRotated(45, 0, 0, 1);

            int[,] segmentsRot =
            {
                { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 10, 0, 0 }, { 30, 0, -15 }
            };

            int railSize      = 3;
            int segmentsCount = segmentsRot.Length / 3;
            int segmentLength = fieldSize / segmentsCount;


            int    x = -fieldSize / 2;
            int    currentRotation = 0;
            double width           = segmentLength / 2;

            int step = segmentLength / 4;

            for (int i = 0; i < segmentsCount; i++)
            {
                Gl.glBindTexture(Gl.GL_TEXTURE_2D, metalTexture);
                Gl.glPushMatrix();
                Gl.glTranslated(x + i * segmentLength, 0, 0);
                Gl.glRotated(90, 0, 1, 0);
                if (i == 0)
                {
                    Gl.glRotated(-30, 1, 0, 0);
                    Gl.glTranslated(0, 2, width - 4);
                }

                Gl.glPushMatrix();
                Gl.glTranslated(0, 0, -railSize * 2);
                Glut.glutSolidCylinder(railSize, segmentLength, 16, 16);
                Gl.glPushMatrix();
                Gl.glTranslated(0, -width, 0);
                Glut.glutSolidCylinder(railSize, segmentLength, 16, 16);
                Gl.glPopMatrix();
                Gl.glPopMatrix();


                Gl.glPushMatrix();
                Gl.glTranslated(0, 0, -railSize);
                Glut.glutSolidCylinder(railSize * 0.8, segmentLength, 16, 16);
                Gl.glPushMatrix();
                Gl.glTranslated(0, -width, 0);
                Glut.glutSolidCylinder(railSize * 0.8, segmentLength, 16, 16);
                Gl.glPopMatrix();
                Gl.glPopMatrix();


                Gl.glBindTexture(Gl.GL_TEXTURE_2D, woodTexture);

                Gl.glPushMatrix();
                Gl.glRotated(90, 1, 0, 0);
                Gl.glTranslated(0, 5, 0);

                for (int j = 0; j < segmentLength - step; j += step)
                {
                    Gl.glTranslated(0, step, 0);
                    Gl.glPushMatrix();
                    Gl.glRotated(45, 0, 0, 1);
                    Glut.glutSolidCylinder(railSize, width, 4, 4);
                    Gl.glPopMatrix();
                }

                Gl.glPopMatrix();
                Gl.glPopMatrix();

                currentRotation += segmentsRot[i, 0];
            }

            Gl.glPopMatrix();

            // отключаем режим текстурирования
            Gl.glDisable(Gl.GL_TEXTURE_2D);
            Gl.glDisable(Gl.GL_TEXTURE_GEN_S);
            Gl.glDisable(Gl.GL_TEXTURE_GEN_T);
            Gl.glDisable(Gl.GL_TEXTURE_2D);
        }
Ejemplo n.º 14
0
        private void DrawFig()
        {
            AnT.MakeCurrent();
            double x = L * Math.Cos(ToRad(180 + ToGr(-FI))),
                   y = L * Math.Sin(ToRad(180 + ToGr(-FI)));

            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            Gl.glClearColor(255, 255, 255, 1);
            Gl.glLoadIdentity();
            Gl.glPushMatrix();

            Gl.glTranslated(0, AnT.Height / 30, -30);

            Gl.glScaled(zoom, zoom, zoom);

            Gl.glRotated(angle, 0, 1, 0);

            Gl.glBegin(Gl.GL_LINES);

            Gl.glVertex2d(0, -AnT.Height);
            Gl.glVertex2d(0, AnT.Height);

            Gl.glEnd();

            Gl.glRotated(180, 0, 1, 0);

            Gl.glRotated(90, 1, 0, 0);
            Gl.glRotated(ToGr(-FI), 0, 1, 0);
            Glut.glutSolidCylinder(0.05, L, 32, 32);
            Gl.glRotated(-90, 1, 0, 0);

            Gl.glBegin(Gl.GL_LINE_STRIP);

            Gl.glVertex2d(0, -L);
            Gl.glVertex2d(0, -L + 3);
            Gl.glVertex2d(0.25, 2.5 - L);
            Gl.glVertex2d(0, 3 - L);
            Gl.glVertex2d(-0.25, 2.5 - L);

            Gl.glEnd();

            Gl.glRotated(90, 1, 0, 0);
            Gl.glRotated(-ToGr(-FI), 0, 1, 0);
            Gl.glRotated(-90, 1, 0, 0);

            Gl.glRotated(90, 0, 0, 1);

            Gl.glTranslated(x, y, 0);


            Gl.glBegin(Gl.GL_LINE_STRIP);

            Gl.glVertex2d(0, 0);
            Gl.glVertex2d(-3, 0);

            Gl.glVertex2d(-2.5, 0.25);
            Gl.glVertex2d(-3, 0);
            Gl.glVertex2d(-2.5, -0.25);

            Gl.glEnd();

            Glut.glutSolidSphere(rad, 32, 32);

            Gl.glRotated(-90, 0, 0, 1);
            Gl.glRotated(90, 0, 1, 0);
            PrintText2D(1f, -3, "Fmg");
            Gl.glRotated(-90, 0, 1, 0);
            Gl.glRotated(90, 0, 0, 1);

            Gl.glTranslated(-x, -y, 0);

            //Gl.glTranslated(-3, 0.5, 0);
            //PrintText2D(0, 0, "Fmg");

            Gl.glRotated(-90, 0, 0, 1);
            Gl.glRotated(90, 0, 1, 0);
            Gl.glRotated(-ToGr(-FI), 1, 0, 0);
            PrintText2D(0.5f, 3 - L, "T");
            Gl.glRotated(ToGr(-FI), 1, 0, 0);
            Gl.glRotated(-90, 0, 1, 0);
            Gl.glRotated(90, 0, 0, 1);

            Gl.glPopMatrix();
            Gl.glFlush();
            AnT.Invalidate();
        }
Ejemplo n.º 15
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();
        }
        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.º 17
0
        private void DrawAllMatrix()
        {
            if (Correct_Height != AnT.Size.Height || Correct_Width != AnT.Size.Width)
            {
                if (Correct_Height != AnT.Size.Height)
                {
                    Correct_Height = AnT.Size.Height;
                }
                if (Correct_Width != AnT.Size.Width)
                {
                    Correct_Width = AnT.Size.Width;
                }
                Gl.glViewport(0, 0, AnT.Width, AnT.Height);
            }

            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            Glu.gluPerspective(45, (float)AnT.Width / (float)AnT.Height, 0.1, 200);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);

            Gl.glClearColor(0.7f * 1.2f, 0.999f * 1.2f, 0.568f * 1.2f, 1.0f);//фон редактить здесь
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);

            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);
            Gl.glEnable(Gl.GL_COLOR_MATERIAL);

            Gl.glColor3d(0.31, 0.31, 0.31);
            Gl.glRotated(-90, 1, 0, 0);
            Gl.glRotated(90, 0, 0, 1);

            Shtativ.DrawModel();
            DrawGround();//КАТЯ, СТОЛ УБИРАЕТСЯ ЗДЕСЬ!!!
            Gl.glRotated(-90, 0, 0, 1);
            Gl.glRotated(90, 1, 0, 0);
            Gl.glColor3d(0.31, 0.31, 0.31);
            Gl.glPushMatrix();
            Gl.glRotatef(-90, 1, 0, 0);
            Gl.glTranslatef(0, 0, 1);
            Gl.glRotated(Angle, 0, -1, 0);
            Gl.glTranslatef(0, 0, -1);

            if (TopMount_radioButton.Checked == true)
            {
                Gl.glTranslatef(0, 0, 1 - Object3.Get_Height() / 10);
                Glut.glutSolidCylinder(0.01d, 1, 200, 1);
                Gl.glColor3d(0, 0.0, 0.0);
                for (int i = 1; i < 20; i++)
                {
                    Gl.glTranslatef(0, 0, 0.05f);
                    Glut.glutSolidCylinder(0.0101d, 0.002, 200, 1);
                }
                Gl.glTranslatef(0, 0, -0.95f);
                Gl.glColor3d(0.75, 0, 0);
                Glut.glutSolidCylinder(0.0120d, 0.025, 200, 1);
                Gl.glColor3d(0.31, 0.31, 0.31);
            }
            if (BottomMount_radioButton.Checked == true)
            {
                Gl.glTranslatef(0, 0, 1 + Object4.Get_Height() / 10);
                Gl.glRotatef(-180, 1, 0, 0);
                Glut.glutSolidCylinder(0.01d, 1, 200, 1);
                Gl.glColor3d(0, 0.0, 0.0);
                for (int i = 1; i < 20; i++)
                {
                    Gl.glTranslatef(0, 0, 0.05f);
                    Glut.glutSolidCylinder(0.0101d, 0.002, 200, 1);
                }
                Gl.glColor3d(0.75, 0, 0);
                Gl.glTranslatef(0, 0, 0.025f);
                Glut.glutSolidCylinder(0.0120d, 0.025, 200, 1);
                Gl.glTranslatef(0, 0, -0.975f);
                Gl.glColor3d(0.31, 0.31, 0.31);
            }

            Gl.glColor3d(0.31, 0.31, 0.31);
            Gl.glDisable(Gl.GL_COLOR_MATERIAL);
            Gl.glPushMatrix();


            Object1.Drawobject();
            Object2.Drawobject();
            Object3.Drawobject(false);
            Object4.Drawobject(true);
            Gl.glPopMatrix();
            Gl.glPopMatrix();

            Gl.glDisable(Gl.GL_DEPTH_TEST);
            Gl.glDisable(Gl.GL_LIGHTING);
            Gl.glDisable(Gl.GL_LIGHT0);
            Gl.glLoadIdentity();

            Gl.glRotated(camXRot, 1, 0, 0);
            Gl.glRotated(camYRot, 0, 1, 0);
            Gl.glTranslated(camXPos, camYPos, camZPos);
            Gl.glTranslated(0, -0.5, -2.5);
            Gl.glFlush();//?
            AnT.Invalidate();
        }