using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace Camera
{
    class Camera
    {
        public enum CameraType
        {
            LANDOBJECT,
            AIRCRAFT
        };

        public CameraType cameraType;
        Vector3 _cam_pos = new Vector3( 0, -1.97f, -90.0f );

        // углы, задающие ориентацию камеры
        float _cam_yaw = 90;
        float _cam_pitch = -45;

        // оси камеры в мировых координатах
        Vector3 _cam_dir = new Vector3(0.0f, 0.0f, 1.0f);
        Vector3 _cam_right= new Vector3(1.0f, 0, 0);
        Vector3 _cam_up= new Vector3(0, 1.0f, 0.0f);

        Vector3 _arc_rotate_center =new Vector3( 0, 0, 0 ); // в мировых координатах



        public Camera()
        {
            cameraType = CameraType.AIRCRAFT;
        }
        public Camera(CameraType _cameraType)
        {
            cameraType = _cameraType;

        }
        public Matrix GetViewMatrix(Matrix v)
        {
            _cam_dir.Normalize();
            _cam_up = Vector3.Cross(_cam_dir, _cam_right);
            _cam_up.Normalize();
            _cam_right = Vector3.Cross(_cam_up, _cam_dir);
            _cam_right.Normalize();

       
            v.M11 = _cam_right.X;
            v.M12 = _cam_up.X;
            v.M13 = _cam_dir.X;
            v.M14 = 0.0f;

            v.M21 = _cam_right.Y;
            v.M22 = _cam_up.Y;
            v.M23 = _cam_dir.Y  ;
            v.M24 = 0.0f;

            v.M31 = _cam_right.Z;
            v.M32 = _cam_up.Z;
            v.M33 = _cam_dir.Z;
            v.M34 = 0.0f;

            v.M41 = -Vector3.Dot(_cam_right, _cam_pos);
            v.M42 = -Vector3.Dot(_cam_up, _cam_pos);
            v.M43 = -Vector3.Dot(_cam_dir, _cam_pos);//расстояние по оси Z
            v.M44 = 1.0f;
            return v;

        }

        private void calc_cam_axes()
        {
            _cam_dir.X = (float)Math.Cos(radFromDeg(_cam_pitch)) * (float)Math.Cos(radFromDeg(_cam_yaw));
            _cam_dir.Y = (float)Math.Cos(radFromDeg(_cam_pitch)) * (float)Math.Sin(radFromDeg(_cam_yaw));
            _cam_dir.Z = (float)Math.Sin(radFromDeg(_cam_pitch));

            _cam_right.X = (float)Math.Cos(radFromDeg(_cam_yaw - 90));
            _cam_right.Y = (float)Math.Sin(radFromDeg(_cam_yaw - 90));
            _cam_right.Z = 0;

            _cam_up = Vector3.Cross(_cam_right, _cam_dir);
        }
       
        private Vector3 rotate(Vector3 point_on_axis, Vector3 dir, float angle, Vector3 point)
        {
            Vector3 r = point - point_on_axis;
            dir.Normalize();
            float a = angle * (float)(Math.PI / 180.0f);
            return point_on_axis + (float)Math.Cos(a) * r + ((1 - (float)Math.Cos(a)) * Vector3.Dot(dir, r)) * dir + (float)Math.Sin(a) * Vector3.Cross(dir, r);           
        }
        
        private float radFromDeg(float angle)
        {
            return angle * (float)(Math.PI / 180);
        }
        public void arcRotate(int move_x, int move_y)
        {
            if (move_x != 0)
            {
                float yaw_diff = move_x;
                _cam_pos = rotate(_arc_rotate_center, new Vector3(0, 0, 1), yaw_diff, _cam_pos);
                _cam_yaw += yaw_diff;
                calc_cam_axes();
                
            }
            if (move_y != 0)
            {
                float pitch_diff = -move_y;
                _cam_pos = rotate(_arc_rotate_center,_cam_right, pitch_diff, _cam_pos);
                _cam_pitch += pitch_diff;
                calc_cam_axes();
            }
        }
       
    }
}

 using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using System.Collections;
using System.Threading;



namespace WindowsFormsApplication1
{
    
    public partial class Form1 : Form
    {
        private Device device;
        private float angle;      
        private Panel viewportScreen1;       
               
        CustomVertex.TransformedColored[] vertsColumn;
        CustomVertex.TransformedColored[] vertsColumnPlus;
        CustomVertex.TransformedColored[] vertsColumnMinus;

        CustomVertex.TransformedColored[] vertsStrings;
        CustomVertex.TransformedColored[] vertsStringsPlus;
        CustomVertex.TransformedColored[] vertsStringsMinus;

       private int ColumnsCount = 21;//Количество колонок и строк в координатной сетке
        Color colorOfCoordMesh = Color.Gray;
        private Matrix v;
        
        private Thread g_mainThread;
        public bool g_running;
        private Camera camera=new Camera();

        private VertexBuffer vb = null;

        
        public Form1()
        {
         //   this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
            InitializeComponent();
            
        }

      
        private void Form1_Load(object sender, EventArgs e)
        {

        }

        public void InitializeGraphics()
        {
            viewportScreen1 = panel1;
           // viewportScreen2 = panel12;

            PresentParameters pp= new PresentParameters();
            pp.Windowed = true;
            pp.SwapEffect = SwapEffect.Discard;
            pp.EnableAutoDepthStencil = true;
            pp.AutoDepthStencilFormat = DepthFormat.D16;
            pp.DeviceWindow = this.panel1;
            device = new Device(0, DeviceType.Hardware, this.panel1.Handle, CreateFlags.SoftwareVertexProcessing, pp);
            device.DeviceReset += new EventHandler(device_DeviceReset);
           device.RenderState.Ambient = Color.Blue;
          

           vb = new VertexBuffer(typeof(CustomVertex.PositionColored),
                              6,
                              device,
                              Usage.Dynamic | Usage.WriteOnly,
                              CustomVertex.PositionColored.Format,
                              Pool.Default);
           vb.Created += new EventHandler(vb_Created);
           vb_Created(vb, null); 
           g_running = true;
           g_mainThread = new Thread(new ThreadStart(MainLoop));
           g_mainThread.Name = "Main loop thread";
           g_mainThread.Start();
           FillArrayOfCoordMesh();
         
            
            

        }
        void vb_Created(object sender, EventArgs e)
        {
            VertexBuffer buffer = (VertexBuffer)sender;
            CustomVertex.PositionColored[] verts = new
                CustomVertex.PositionColored[6];
            // Задняя грань: треугольник 2-0-1 (невидимая сторона - обход левый)
            verts[0] = new CustomVertex.PositionColored(0.0F, 0.0F, 0.0F, Color.Red.ToArgb());
            verts[1] = new CustomVertex.PositionColored(0.0F, -10.0F, 0.0F, Color.Red.ToArgb());
            verts[2] = new CustomVertex.PositionColored(0.0F, 0.0F, 0.0F, Color.Blue.ToArgb());
            verts[3] = new CustomVertex.PositionColored(10.0F, 0.0F, 0.0F, Color.Blue.ToArgb());
            verts[4] = new CustomVertex.PositionColored(0.0F, 0.0F, 0.0F, Color.DeepPink.ToArgb());
            verts[5] = new CustomVertex.PositionColored(0.0F, 0.0F, 10.0F, Color.DeepPink.ToArgb());


            // Заполнить вершинный буфер данными треугольников
            buffer.SetData(verts, 0, LockFlags.None);
        }

        void device_DeviceReset(object sender, EventArgs e)
        {
            
        }

        private void MainLoop()
        {
            while (g_running)
            {
                
                RenderScene();
            }
        }

        

       
        private void SetupCamera()
        {
            device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, (float)viewportScreen1.Width / (float)viewportScreen1.Height, 1.0f, 100.0f);
            v = camera.GetViewMatrix(v);
            device.SetTransform(TransformType.View, v);          
            device.RenderState.Lighting = false;           
            device.RenderState.PointSize = 5.0f;
            angle += 0.1f;
            device.Lights[0].Type = LightType.Directional;
            device.Lights[0].Diffuse = Color.Red;
            device.Lights[0].Direction = new Vector3(0, -1, 0);
            device.Lights[0].Enabled = true;
            
        }


       protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
       }

      



     

       private void FillArrayOfCoordMesh()
       {
           float step = 1;
           float firstCoord = (step * (ColumnsCount/2))*-1;
           
           
           float marginCoord = 10;//Крайняя координата колонки
            vertsColumnPlus = new CustomVertex.TransformedColored[ColumnsCount];
            vertsColumnMinus = new CustomVertex.TransformedColored[ColumnsCount];

            vertsStringsPlus = new CustomVertex.TransformedColored[ColumnsCount];
            vertsStringsMinus = new CustomVertex.TransformedColored[ColumnsCount];
         
           for (int i = 0; i < ColumnsCount; i++)
           {   //Колонки
               vertsColumnPlus[i].Position = new Vector4(firstCoord, 0, marginCoord, 1.0F);
               vertsColumnPlus[i].Color = colorOfCoordMesh.ToArgb();

               vertsColumnMinus[i].Position = new Vector4(firstCoord, 0, marginCoord * -1, 1.0F);
               vertsColumnMinus[i].Color = colorOfCoordMesh.ToArgb();
              //Строки
               vertsStringsPlus[i].Position = new Vector4(marginCoord, 0, firstCoord, 1.0F);
               vertsStringsPlus[i].Color = colorOfCoordMesh.ToArgb();

               vertsStringsMinus[i].Position = new Vector4(marginCoord * -1, 0, firstCoord, 1.0F);
               vertsStringsMinus[i].Color = colorOfCoordMesh.ToArgb();



               firstCoord += step;
           }


       }
       private void DrawCoordMesh()
       {

           device.RenderState.PointSize = 5.0f;
           device.VertexFormat = CustomVertex.PositionColored.Format;

           Material boxM = new Material();
           boxM.Ambient = colorOfCoordMesh;
           boxM.Diffuse = Color.White;
           device.Material = boxM;

                     
           for (int i = 0; i < ColumnsCount; i++)
           {
               vertsColumn = new CustomVertex.TransformedColored[2];
               vertsColumn[0].Position=vertsColumnPlus[i].Position;
               vertsColumn[0].Color = vertsColumnPlus[i].Color;

               vertsColumn[1].Position = vertsColumnMinus[i].Position;
               vertsColumn[1].Color = vertsColumnMinus[i].Color;

               device.Transform.World = Matrix.Translation(0, 0, 1.0f);
               device.DrawUserPrimitives(PrimitiveType.LineList, 1, vertsColumn);

               vertsStrings = new CustomVertex.TransformedColored[2];
               vertsStrings[0].Position = vertsStringsPlus[i].Position;
               vertsStrings[0].Color = vertsStringsPlus[i].Color;

               vertsStrings[1].Position = vertsStringsMinus[i].Position;
               vertsStrings[1].Color = vertsStringsMinus[i].Color;

               device.Transform.World = Matrix.Translation(0, 0, 1.0f);
               device.DrawUserPrimitives(PrimitiveType.LineList, 1, vertsStrings);
               
           }
           device.VertexFormat = CustomVertex.PositionColored.Format;
           device.SetStreamSource(0, vb, 0);
           device.DrawPrimitives(PrimitiveType.LineList, 0, 3);           
       }

      
       private void RenderScene()
       {
           device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Aquamarine, 1.0f, 0);
           SetupCamera();
           device.BeginScene();
           DrawCoordMesh();
                 
           device.EndScene();
           device.Present();      

       }    

       private void Form1_FormClosing(object sender, FormClosingEventArgs e)
       {
           g_running = false;
       }
     
           private void Form1_KeyDown(object sender, KeyEventArgs e)
           {
               switch (e.KeyCode)
               {
                   case Keys.W:
                       camera.arcRotate(0, 5);
                       break;
                   case Keys.S:
                       camera.arcRotate(0, -5);
                       break;
                   case Keys.D:
                       camera.arcRotate(5, 0);
                       break;
                   case Keys.A:
                       camera.arcRotate(-5, 0);
                       break;               
               }                             
           }       
    }   
}

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace WindowsFormsApplication1
{
    class Camera
    {
        public enum CameraType
        {
            LANDOBJECT,
            AIRCRAFT
        };

        public CameraType cameraType;
        public Vector3 _cam_pos = new Vector3(5.0f, -5.97f, -32.0f);
        // public Vector3 _cam_pos = new Vector3(10, -1, -43.0f);
        // углы, задающие ориентацию камеры
        public float _cam_yaw = 90;
        public float _cam_pitch = 80;
        //public float _cam_pitch = -45;

        // оси камеры в мировых координатах
        Vector3 _cam_dir;
        Vector3 _cam_right;
        Vector3 _cam_up;

        Vector3 _arc_rotate_center = new Vector3(0, 0, 0); // в мировых координатах



        public Camera()
        {
            cameraType = CameraType.AIRCRAFT;
            calc_cam_axes();
        }
        public Camera(CameraType _cameraType)
        {
            cameraType = _cameraType;

        }
        public Matrix GetViewMatrix(Matrix v)
        {

            v.M11 = _cam_right.X;
            v.M12 = _cam_up.X;
            v.M13 = _cam_dir.X;
            v.M14 = 0.0f;

            v.M21 = _cam_right.Y;
            v.M22 = _cam_up.Y;
            v.M23 = _cam_dir.Y;
            v.M24 = 0.0f;

            v.M31 = _cam_right.Z;
            v.M32 = _cam_up.Z;
            v.M33 = _cam_dir.Z;
            v.M34 = 0.0f;

            v.M41 = -Vector3.Dot(_cam_right, _cam_pos);
            v.M42 = -Vector3.Dot(_cam_up, _cam_pos);
            v.M43 = -Vector3.Dot(_cam_dir, _cam_pos);//расстояние по оси Z
            v.M44 = 1.0f;
            return v;

        }

        private void calc_cam_axes()
        {
            _cam_dir.X = (float)Math.Cos(radFromDeg(_cam_pitch)) * (float)Math.Cos(radFromDeg(_cam_yaw));
            _cam_dir.Y = (float)Math.Cos(radFromDeg(_cam_pitch)) * (float)Math.Sin(radFromDeg(_cam_yaw));
            _cam_dir.Z = (float)Math.Sin(radFromDeg(_cam_pitch));

            _cam_right.X = (float)Math.Cos(radFromDeg(_cam_yaw - 90));
            _cam_right.Y = (float)Math.Sin(radFromDeg(_cam_yaw - 90));
            _cam_right.Z = 0;

            _cam_up = Vector3.Cross(_cam_right, _cam_dir);
        }

        private Vector3 rotate(Vector3 point_on_axis, Vector3 dir, float angle, Vector3 point)
        {
            Vector3 r = point - point_on_axis;
            dir.Normalize();
            float a = angle * (float)(Math.PI / 180.0f);
            return point_on_axis + (float)Math.Cos(a) * r + ((1 - (float)Math.Cos(a)) * Vector3.Dot(dir, r)) * dir + (float)Math.Sin(a) * Vector3.Cross(dir, r);
        }

        private float radFromDeg(float angle)
        {
            return angle * (float)(Math.PI / 180);
        }
        public void arcRotate(int move_x, int move_y)
        {
            if (move_x != 0)
            {
                float yaw_diff = move_x;
                _cam_pos = rotate(_arc_rotate_center, new Vector3(0, 0, 1), yaw_diff, _cam_pos);
                _cam_yaw += yaw_diff;
                calc_cam_axes();

            }
            if (move_y != 0)
            {
                float pitch_diff = -move_y;
                _cam_pos = rotate(_arc_rotate_center, _cam_right, pitch_diff, _cam_pos);
                _cam_pitch += pitch_diff;
                calc_cam_axes();
            }
        }
    

    }
}