C# + OpenGL тела вращения

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
using Tao.OpenGl;
using Tao.FreeGlut;
using Tao.Platform.Windows;
using Tao.DevIl;
 
namespace telo_vras2_b_
{
    public partial class vras : Form
    {
        public vras()
        {
            InitializeComponent();
            AnT.InitializeContexts();
        }
 
        // размеры окна
        double ScreenW, ScreenH;
        private bool click = false;
        private bool perenos = false;
 
        
        // отношения сторон окна ви
        // отношения сторон окна визуализации
        // для корректного перевода координат мыши в координаты,
        // принятые в программе
        int a = 0, c = 0, d = 0, v = 0, n=0;
        private float devX;
        private float devY;
 
 
        // массив, который будет хранить значения x,y точек графика
 
 
        double[] koord = new double[500];
        // количество элементов в массиве
        private int elements = 0;
 
        // вспомогательные переменные для построения линий от курсора мыши к координатным осям
        float lineX, lineY;
 
        // текущение координаты курсора мыши
        float Mcoord_X = 0, Mcoord_Y = 0;
 
        private void Form1_Load(object sender, EventArgs e)
        {
            Glut.glutInit();
            // инициализация режима экрана
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE);
 
            // установка цвета очистки экрана (RGBA)
            Gl.glClearColor(0, 0, 0, 0);
 
            // установка порта вывода
            Gl.glViewport(0, 0, AnT.Width, AnT.Height);
 
            // активация проекционной матрицы
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            // очистка матрицы
            Gl.glLoadIdentity();
 
            // определение параметров настройки проекции, в зависимости от размеров сторон элемента AnT.
            if ((float)AnT.Width <= (float)AnT.Height)
            {
 
                ScreenW = 30.0;
                ScreenH = 30.0 * (float)AnT.Height / (float)AnT.Width;
 
                Glu.gluOrtho2D(0.0, ScreenW, 0.0, ScreenH);
 
            }
            else
            {
 
                ScreenW = 30.0 * (float)AnT.Width / (float)AnT.Height;
                ScreenH = 30.0;
 
                Glu.gluOrtho2D(0.0, 30.0 * (float)AnT.Width / (float)AnT.Height, 0.0, 30.0);
 
            }
 
            // сохранение коэфицентов, которые нам необходимы для перевода координат указателя в оконной системе, в координаты
            // принятые в нашей OpenGL сцене
            devX = (float)ScreenW / (float)AnT.Width;
            devY = (float)ScreenH / (float)AnT.Height;
 
            // установка объектно-видовой матрицы
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
 
            // старт щетчика, отвечающего за выхов функции визуализации сцены
            PointInGrap.Start();
        }
 
        private void PointInGrap_Tick(object sender, EventArgs e)
        {
            Draw();
        }
 
        private void AnT_MouseMove(object sender, MouseEventArgs e)
        {
            // созраняем координаты мыши
            Mcoord_X = e.X;
            Mcoord_Y = e.Y;
 
            // вычисляем параметры для будующей дорисовке линий от указателя мыши к координатным осям.
            lineX = devX * e.X;
            lineY = (float)(ScreenH - devY * e.Y);
        }
        private void PrintText2D(float x, float y, string text)
        {
 
            // устанавливаем позицию вывода растровых символов
            // в переданных координатах x и y.
            Gl.glRasterPos2f(x, y);
 
            // в цикле foreach перебираем значения из массива text,
            // который содержит значение строки для визуализации
            foreach (char char_for_draw in text)
            {
 
                // визуализируем символ c, с помощью функции glutBitmapCharacter, используя шрифт GLUT_BITMAP_9_BY_15.
                Glut.glutBitmapCharacter(Glut.GLUT_BITMAP_9_BY_15, char_for_draw);
 
            }
 
        }
        private void Draw()
        {
 
            // очистка буфера цвета и буфера глубины
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
 
            // очищение текущей матрицы
            Gl.glLoadIdentity();
 
            // утснаовка серого цвета
            Gl.glColor3d(0.308, 0.304, 0.304);
 
            // помещаем состояние матрицы в стек матриц
            Gl.glPushMatrix();
 
            // выполняем перемещение в прострастве по осям X и Y
            Gl.glTranslated(15, 15, 0);
            // активируем режим рисования, каждые 2 последовательно вызванные комманды glVertex
            // объединяются в линии
 
            Gl.glBegin(Gl.GL_LINES);
            for (int ax = -15; ax < 16; ax++)
            {
 
                Gl.glVertex2d(ax, -15);
                Gl.glVertex2d(ax, 15);
            }
            for (int ax = -15; ax < 16; ax++)
            {
 
                Gl.glVertex2d(-15, ax);
                Gl.glVertex2d(15, ax);
            }
            Gl.glColor3d(0.9, 0.9, 0);
 
            // далее мы рисуем координатные оси и стрекли на их концах
            Gl.glVertex2d(0, -15);
            Gl.glVertex2d(0, 15);
 
            Gl.glVertex2d(-15, 0);
            Gl.glVertex2d(15, 0);
 
            // вертикальная стрелка
            Gl.glVertex2d(0, 15);
            Gl.glVertex2d(0.1, 14.5);
            Gl.glVertex2d(0, 15);
            Gl.glVertex2d(-0.1, 14.5);
 
 
            // горизонтальная трелка
            Gl.glVertex2d(15, 0);
            Gl.glVertex2d(14.5, 0.1);
            Gl.glVertex2d(15, 0);
            Gl.glVertex2d(14.5, -0.1);
 
            // завершаем режим рисования
            Gl.glEnd();
 
            // выводим подписи осей "x" и "y"
            PrintText2D(15.5f, 0, "X");
            PrintText2D(0.5f, 14.5f, "Y");
 
 
 
            // возвращаем матрицу из стека
            Gl.glPopMatrix();
 
            // выводим текст со значением координат возле курсора
            PrintText2D(devX * Mcoord_X + 0.2f, (int)ScreenH - devY * Mcoord_Y + 0.4f, "[X:" + ((Math.Floor(((devX * Mcoord_X - 15)) * 10)) / 10).ToString() + "; Y :" + ((Math.Floor(((int)ScreenH - devY * Mcoord_Y - 15) * 10)) / 10).ToString() + "]");
 
 
            // устанавливаем красный цвет
            Gl.glColor3f(255, 0, 0);
 
            // включаем режим рисования линий, для того чтобы нарисовать
            // линии от курсора мыши к координатным осям
            Gl.glBegin(Gl.GL_LINES);
 
            Gl.glVertex2d(lineX, 15);
            Gl.glVertex2d(lineX, lineY);
            Gl.glVertex2d(15, lineY);
            Gl.glVertex2d(lineX, lineY);
 
            Gl.glEnd();
            if (click == true)
            {
                //Gl.glVertex2d(((Math.Floor(((devX * Mcoord_X - 15)) * 10)) / 10), ((Math.Floor(((int)ScreenH - devY * Mcoord_Y - 15) * 10)) / 10));
                koord[a] = Math.Floor(((devX * Mcoord_X - 15)) * 10) / 10;
                label4.Text = koord[a].ToString();
                a++;
                koord[a] = Math.Floor(((int)ScreenH - devY * Mcoord_Y - 15) * 10) / 10;
                label5.Text = koord[a].ToString();
                a++;
                elements = elements + 2;
                click = false;
            }
            c = 0;
            d = 1;
            if (elements == 2)
            {
                v = 1;
            }
            for (int b = elements / 2 - 1 + v; b >= 1; b--)
            {
                Gl.glPointSize(3);
                if (perenos == false)
                {
                    Gl.glTranslated(15, 15, 0);
                    perenos = true;
                }
                Gl.glBegin(Gl.GL_POINTS);
                Gl.glColor3f(0, 1, 0);
                Gl.glVertex2d(koord[c], koord[d]);
                Gl.glEnd();
                Gl.glColor3f(255, 0, 0);
                if (elements >= 4)
                {
                    Gl.glBegin(Gl.GL_LINE_STRIP);
                    if (elements >= 6)
                    {
                        Gl.glVertex2d(koord[c], koord[d]);
                        c = c + 2;
                        d = d + 2;
                        Gl.glVertex2d(koord[c], koord[d]);
                    }
                    else
                    {
                        Gl.glVertex2d(koord[c], koord[d]);
                        c = c + 2;
                        d = d + 2;
                        Gl.glVertex2d(koord[c], koord[d]);
                    }
                    Gl.glEnd();
                }
                else
                {
                    Gl.glColor3f(0, 1, 0);
                    Gl.glBegin(Gl.GL_POINTS);
                    Gl.glVertex2d(koord[c], koord[d]);
                    Gl.glEnd();
                }
            }
            v = 0;
            perenos = false;
            // дожидаемся завершения визуализации кадра
            Gl.glFlush();
 
            // сигнал для обновление элемента реализующего визуализацию.
            AnT.Invalidate();
 
        }
 
        private void AnT_Click(object sender, EventArgs e)
        {
            click = true;
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            elements = 0;
            a = 0;
            teloob.Stop();
            PointInGrap.Start();
            Gl.glClearColor(0, 0, 0, 0);
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            if (elements >= 4)
            {
                PointInGrap.Stop();
                teloob.Start();
            }
        }
 
        private void teloob_Tick(object sender, EventArgs e)
        {
            // очистка буфера цвета и буфера глубины
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);// Очистка экрана и буфера глубины
            Gl.glLoadIdentity();                               // Сброс просмотра
 
  
           
            // очищение текущей матрицы
            Gl.glLoadIdentity();
            Gl.glClearColor(0, 0, 0, 0);
            // утснаовка серого цвета
            Gl.glColor3f(255, 0, 0);
            Gl.glTranslated(15, 15, 0);
            // помещаем состояние матрицы в стек матриц
            Gl.glBegin(Gl.GL_LINE_STRIP);
            c = 0;
            d = 1;
            if (elements == 2)
            {
                v = 1;
            }
            for (int b = elements / 2 - 1 + v; b >= 1; b--)
            {
                Gl.glPointSize(3);
                if (perenos == false)
                {
                    Gl.glTranslated(15, 15, 0);
                    perenos = true;
                }
                Gl.glBegin(Gl.GL_POINTS);
                Gl.glColor3f(0, 1, 0);
                Gl.glVertex2d(koord[c], koord[d]);
                Gl.glEnd();
                Gl.glColor3f(255, 0, 0);
                if (elements >= 4)
                {
                    Gl.glBegin(Gl.GL_LINE_STRIP);
                    if (elements >= 6)
                    {
                        Gl.glVertex2d(koord[c], koord[d]);
                        c = c + 2;
                        d = d + 2;
                        Gl.glVertex2d(koord[c], koord[d]);
                    }
                    else
                    {
                        Gl.glVertex2d(koord[c], koord[d]);
                        c = c + 2;
                        d = d + 2;
                        Gl.glVertex2d(koord[c], koord[d]);
                    }
                    Gl.glEnd();
                }
                else
                {
                    Gl.glColor3f(0, 1, 0);
                    Gl.glBegin(Gl.GL_POINTS);
                    Gl.glVertex2d(koord[c], koord[d]);
                    Gl.glEnd();
                }
            }
            v = 0;
            perenos = false;
         
            Gl.glEnd();
            Gl.glPushMatrix();
            Gl.glFlush();
 
            // сигнал для обновление элемента реализующего визуализацию.
            AnT.Invalidate();
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
using Tao.FreeGlut;
using Tao.OpenGl;
using Tao.Platform.Windows;
 
namespace Camera
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            AnT.InitializeContexts();
        }
        bool mouseRotate, mouseMove = false;
        int myMouseYcoord, myMouseXcoord, myMouseXcoordVar, myMouseYcoordVar;
        float rot_cam_X;
        double a=0,b=0,c=0;
 
        Camer1 cam = new Camer1();
        private void InitGL()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
 
            Gl.glClearColor(255, 255, 255, 1);
 
            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.glLoadIdentity();
 
            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);
 
            Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
            Gl.glHint(Gl.GL_LINE_SMOOTH_HINT, Gl.GL_NICEST);
            Gl.glEnable(Gl.GL_BLEND);
            Gl.glEnable(Gl.GL_LINE_SMOOTH);
            Gl.glLineWidth(1.0f);
 
            cam.Position_Camera(0, 6, -15, 0, 3, 0, 0, 1, 0); //Вот тут в инициализации
            //укажем начальную позицию камеры,взгляда и вертикального вектора.
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            InitGL();
            timer1.Start();
        }
        private void Draw()
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
 
            Gl.glLoadIdentity();
            Gl.glColor3i(255, 0, 0);
           
            cam.Look(); //Обновляем взгляд камеры
             float[] MatrixColorOX = {1,0,1,1};
            Gl.glPushMatrix();
            DrawGrid(15, 1);//Нарисуем сетку
            Gl.glBegin(Gl.GL_LINE_STRIP);
           
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, MatrixColorOX);
           
            Gl.glVertex3d(2, 0, 0);
            Gl.glVertex3d(0, 2, 0);
 
            Gl.glEnd();
            Gl.glPopMatrix();
 
            Gl.glFlush();
 
            AnT.Invalidate();
        }
        private void DrawGrid(int x, double quad_size) 
        {
            float[] MatrixColorOX = {1,0,0,1};
            float[] MatrixColorOY = {0,1,0,1};
            float[] MatrixColorOZ = {0,0,1,1};
            float[] MatrixColorOT = {0,0,0,1};
            //x - количество или длина сетки, quad_size - размер клетки
            Gl.glPushMatrix(); //Рисуем оси координат, цвет объявлен в самом начале
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, MatrixColorOX);
            Gl.glTranslated((-x * 2) / 2, 0, 0);
            Gl.glRotated(90, 0, 1, 0);
            Glut.glutSolidCylinder(0.02, x * 2, 12, 12);
            Gl.glPopMatrix();
 
            Gl.glPushMatrix();
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, MatrixColorOZ);
            Gl.glTranslated(0, 0, (-x * 2) / 2);
            Glut.glutSolidCylinder(0.02, x * 2, 12, 12);
            Gl.glPopMatrix();
 
            Gl.glPushMatrix();
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, MatrixColorOY);
            Gl.glTranslated(0, x / 2, 0);
            Gl.glRotated(90, 1, 0, 0);
            Gl.glBegin(Gl.GL_LINES);
                Gl.glVertex3d(0, 0, 22);
                Gl.glVertex3d(0, 0, -8);
            Gl.glEnd();
            Gl.glPopMatrix();
            Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, MatrixColorOT);
            Gl.glBegin(Gl.GL_LINES);
 
          
 
            // Рисуем сетку 1х1 вдоль осей
            for (double i = -x; i <= x; i += 1)
            {
                Gl.glBegin(Gl.GL_LINES);
                // Ось Х
                Gl.glVertex3d(-x * quad_size, 0, i * quad_size);
                Gl.glVertex3d(x * quad_size, 0, i * quad_size);
 
                // Ось Z
                Gl.glVertex3d(i * quad_size, 0, -x * quad_size);
                Gl.glVertex3d(i * quad_size, 0, x * quad_size);
                Gl.glEnd();
            }
 
        }
 
        private void AnT_MouseDown(object sender, MouseEventArgs e)
        {
 
            if (e.Button == MouseButtons.Left)
                mouseRotate = true; //Если нажата левая кнопка мыши
 
            if (e.Button == MouseButtons.Middle)
                mouseMove = true; //Если нажата средняя кнопка мыши
 
            myMouseYcoord = e.X; //Передаем в нашу глобальную переменную позицию мыши по Х
            myMouseXcoord = e.Y;
 
        }
 
        private void AnT_MouseUp(object sender, MouseEventArgs e)
        {
            mouseRotate = false;
            mouseMove = false;
 
        }
 
        private void AnT_MouseMove(object sender, MouseEventArgs e)
        {
            myMouseXcoordVar = e.Y;
            myMouseYcoordVar = e.X;
 
 
        }
        private void mouse_Events()
        {
            if (mouseRotate == true) //Если нажата левая кнопка мыши
            {
                AnT.Cursor = System.Windows.Forms.Cursors.SizeAll; //меняем указатель
 
                cam.Rotate_Position((float)(myMouseYcoordVar - myMouseYcoord), 0,1,0); //крутим камеру, в моем случае это от 3го лица
 
                rot_cam_X = rot_cam_X + (myMouseXcoordVar - myMouseXcoord);
                if ((rot_cam_X > -40) && (rot_cam_X < 40))
                    cam.upDown(((float)(myMouseXcoordVar - myMouseXcoord)) / 1);
 
                myMouseYcoord = myMouseYcoordVar;
                myMouseXcoord = myMouseXcoordVar;
            }
            else
            {
                if (mouseMove == true)
                {
                    AnT.Cursor = System.Windows.Forms.Cursors.SizeAll;
 
                    cam.Move_Camera((float)(myMouseXcoordVar - myMouseXcoord) / 50);
                    cam.Strafe(-((float)(myMouseYcoordVar - myMouseYcoord) / 50));
 
                    myMouseYcoord = myMouseYcoordVar;
                    myMouseXcoord = myMouseXcoordVar;
 
                }
                else
                {
                    AnT.Cursor = System.Windows.Forms.Cursors.Default;//возвращаем курсор
                };
            };
        }
        private void timer1_Tick(object sender, EventArgs e)
        {
            mouse_Events();
            cam.update();
            Draw();
        }
 
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
using Tao.FreeGlut;
using Tao.OpenGl;
using Tao.Platform.Windows;
 
 
namespace Camera
{
    class Camer1
    {
        private struct Vector3D
        {
            public float x, y, z;
        };
        private Vector3D mPos;   //Вектор позиции камеры
        private Vector3D mView;  //Куда смотрит камера
        private Vector3D mUp;    //Вектор верхнего направления
        private Vector3D mStrafe;//Вектор для стрейфа (движения влево и вправо) камеры.
        private Vector3D Cross(Vector3D vV1, Vector3D vV2, Vector3D vVector2)
        {
            Vector3D vNormal;
            Vector3D vVector1;
            vVector1.x = vV1.x - vV2.x;
            vVector1.y = vV1.y - vV2.y;
            vVector1.z = vV1.z - vV2.z;
 
            // Если у нас есть 2 вектора (вектор взгляда и вертикальный вектор), 
            // у нас есть плоскость, от которой мы можем вычислить угол в 90 градусов.
            // Рассчет cross'a прост, но его сложно запомнить с первого раза. 
            // Значение X для вектора = (V1.y * V2.z) - (V1.z * V2.y)
            vNormal.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y));
 
            // Значение Y = (V1.z * V2.x) - (V1.x * V2.z)
            vNormal.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z));
 
            // Значение Z = (V1.x * V2.y) - (V1.y * V2.x)
            vNormal.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x));
 
            // *ВАЖНО* Вы не можете менять этот порядок, иначе ничего не будет работать.
            // Должно быть именно так, как здесь. Просто запомните, если вы ищите Х, вы не
            // используете значение X двух векторов, и то же самое для Y и Z. Заметьте,
            // вы рассчитываете значение из двух других осей, и никогда из той же самой.
 
            // Итак, зачем всё это? Нам нужно найти ось, вокруг которой вращаться. Вращение камеры
            // влево и вправо простое - вертикальная ось всегда (0,1,0). 
            // Вращение камеры вверх и вниз отличается, так как оно происходит вне 
            // глобальных осей. Достаньте себе книгу по линейной алгебре, если у вас 
            // её ещё нет, она вам пригодится.
 
            // вернем результат.
            return vNormal;
        }
 
        private float Magnitude(Vector3D vNormal)
        {
            // Это даст нам величину нашей нормали, 
            // т.е. длину вектора. Мы используем эту информацию для нормализации
            // вектора. Вот формула: magnitude = sqrt(V.x^2 + V.y^2 + V.z^2)   где V - вектор.
 
            return (float)Math.Sqrt((vNormal.x * vNormal.x) +
                    (vNormal.y * vNormal.y) +
                    (vNormal.z * vNormal.z));
        }
        private Vector3D Normalize(Vector3D vVector)
        {
            // Вы спросите, для чего эта ф-я? Мы должны убедиться, что наш вектор нормализирован.
            // Вектор нормализирован - значит, его длинна равна 1. Например,
            // вектор (2,0,0) после нормализации будет (1,0,0).
 
            // Вычислим величину нормали
            float magnitude = Magnitude(vVector);
 
            // Теперь у нас есть величина, и мы можем разделить наш вектор на его величину.
            // Это сделает длинну вектора равной единице, так с ним будет легче работать.
            vVector.x = vVector.x / magnitude;
            vVector.y = vVector.y / magnitude;
            vVector.z = vVector.z / magnitude;
 
            return vVector;
        }
        public void Position_Camera(float pos_x, float pos_y, float pos_z,
            float view_x, float view_y, float view_z,
            float up_x, float up_y, float up_z)
        {
            mPos.x = pos_x;//Позиция камеры
            mPos.y = pos_y;//
            mPos.z = pos_z;//
            mView.x = view_x;//Куда смотрит, т.е. взгляд
            mView.y = view_y;//
            mView.z = view_z;//
            mUp.x = up_x;//Вертикальный вектор камеры
            mUp.y = up_y;//
            mUp.z = up_z;//
        }
 
        public void Rotate_View(float speed)
        {
            Vector3D vVector;// Полчим вектор взгляда
            vVector.x = mView.x - mPos.x;
            vVector.y = mView.y - mPos.y;
            vVector.z = mView.z - mPos.z;
 
 
 
            mView.z = (float)(mPos.z + Math.Sin(speed) * vVector.x + Math.Cos(speed) * vVector.z);
            mView.x = (float)(mPos.x + Math.Cos(speed) * vVector.x - Math.Sin(speed) * vVector.z);
        }
        public void Rotate_Position(float angle, float x, float y, float z)
        {
            mPos.x = mPos.x - mView.x;
            mPos.y = mPos.y - mView.y;
            mPos.z = mPos.z - mView.z;
 
            Vector3D vVector = mPos;
            Vector3D AVector;
 
            float SinA = (float)Math.Sin(Math.PI * angle / 180.0);
            float CosA = (float)Math.Cos(Math.PI * angle / 180.0);
 
            // Найдем новую позицию X для вращаемой точки 
            AVector.x = (CosA + (1 - CosA) * x * x) * vVector.x;
            AVector.x += ((1 - CosA) * x * y - z * SinA) * vVector.y;
            AVector.x += ((1 - CosA) * x * z + y * SinA) * vVector.z;
 
            // Найдем позицию Y 
            AVector.y = ((1 - CosA) * x * y + z * SinA) * vVector.x;
            AVector.y += (CosA + (1 - CosA) * y * y) * vVector.y;
            AVector.y += ((1 - CosA) * y * z - x * SinA) * vVector.z;
 
            // И позицию Z 
            AVector.z = ((1 - CosA) * x * z - y * SinA) * vVector.x;
            AVector.z += ((1 - CosA) * y * z + x * SinA) * vVector.y;
            AVector.z += (CosA + (1 - CosA) * z * z) * vVector.z;
 
            mPos.x = mView.x + AVector.x;
            mPos.y = mView.y + AVector.y;
            mPos.z = mView.z + AVector.z;
        }
        public void Move_Camera(float speed) //Задаем скорость
        {
            Vector3D vVector; //Получаем вектор взгляда
            vVector.x = mView.x - mPos.x;
            vVector.y = mView.y - mPos.y;
            vVector.z = mView.z - mPos.z;
 
            vVector.y = 0.0f; // Это запрещает камере подниматься вверх
            vVector = Normalize(vVector);
 
            mPos.x += vVector.x * speed;
            mPos.z += vVector.z * speed;
            mView.x += vVector.x * speed;
            mView.z += vVector.z * speed;
        }
        public void Strafe(float speed)
        {
            // добавим вектор стрейфа к позиции
            mPos.x += mStrafe.x * speed;
            mPos.z += mStrafe.z * speed;
 
            // Добавим теперь к взгляду
            mView.x += mStrafe.x * speed;
            mView.z += mStrafe.z * speed;
        }
        public void update()
        {
            Vector3D vCross = Cross(mView, mPos, mUp);
 
            //Нормализуем вектор стрейфа
            mStrafe = Normalize(vCross);
        }
        public void upDown(float speed)
        {
            mPos.y += speed;
        }
        public void Look()
        {
            Glu.gluLookAt(mPos.x, mPos.y, mPos.z, //Нами ранее обсуждаемая команда =)
                          mView.x, mView.y, mView.z,
                          mUp.x, mUp.y, mUp.z);
        }
        public double getPosX() //Возвращает позицию камеры по Х
        {
            return mPos.x;
        }
 
        public double getPosY() //Возвращает позицию камеры по Y
        {
            return mPos.y;
        }
 
        public double getPosZ() //Возвращает позицию камеры по Z
        {
            return mPos.z;
        }
 
        public double getViewX() //Возвращает позицию взгляда по Х
        {
            return mView.x;
        }
 
        public double getViewY() //Возвращает позицию взгляда по Y
        {
            return mView.y;
        }
 
        public double getViewZ() //Возвращает позицию взгляда по Z
        {
            return mView.z;
        }
    }
 
}