using System;
using System.Drawing;
using System.IO;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;

namespace openTk2
{
 public class GlShader : IDisposable
 {
 int ShaderProgram;
 int vertex_shader;
 int fragment_shader;
 
 private void ReleaseUnmanagedResources()
 {
 GL.UseProgram(0);
 GL.DeleteShader(vertex_shader);
 GL.DeleteShader(fragment_shader);
 GL.DeleteProgram(ShaderProgram);
 }
//Освобождение ресурсов шейдера
 public void Dispose()
 {
 ReleaseUnmanagedResources();
 GC.SuppressFinalize(this);
 }

 ~GlShader()
 {
 ReleaseUnmanagedResources();
 }

 public int loadFiles(string vertex_file_name, string fragment_file_name)
 {
 vertex_shader = loadSourcefile(vertex_file_name, ShaderType.VertexShader);
 fragment_shader = loadSourcefile(fragment_file_name, ShaderType.FragmentShader);

 linkProgram();

 return ShaderProgram;
 }

 private int loadSourcefile(string file_name, ShaderType type)
 {
 var source = File.ReadAllText(file_name);
 return compileSource(source, type);
 }

 public int load(string vertex_source, string fragment_source)
 {
 vertex_shader = compileSource(vertex_source, ShaderType.VertexShader);
 fragment_shader = compileSource(fragment_source, ShaderType.FragmentShader);

 linkProgram();
 return ShaderProgram;
 }

 private int compileSource(string source, ShaderType type)
 {
 //! Создаем фрагментный шейдер
 int shader = GL.CreateShader(type);
 //! Передаем исходный код
 GL.ShaderSource(shader, source);
 //! Компилируем шейдер
 GL.CompileShader(shader);
 return shader;
 }

 //! Функция печати лога шейдера
 private static void ShaderLog(string tag, int shader)
 {
 var infoLog = "";

 GL.GetShaderInfoLog(shader, out infoLog);

 if (infoLog.Length > 1)
 Console.WriteLine(tag + " InfoLog: " + infoLog + "\n\n\n");
 }

 private void linkProgram()
 {
 if (vertex_shader == 0 || fragment_shader == 0)
 {
 ShaderProgram = 0;
 return;
 }

 ShaderProgram = GL.CreateProgram();
 GL.AttachShader(ShaderProgram, vertex_shader);
 GL.AttachShader(ShaderProgram, fragment_shader);

 GL.LinkProgram(ShaderProgram);
 string log = GL.GetProgramInfoLog(ShaderProgram);
 if (string.IsNullOrEmpty(log) == false)
 Console.WriteLine(log);
 }

 public void use()
 {
 GL.UseProgram(ShaderProgram);
 }

 //---------------------------------------------------

 //! Attribute get
 public int getAttribLocation(string name)
 {
 int location = -1;
 location = GL.GetAttribLocation(ShaderProgram, name);
 if (location == -1)
 Console.WriteLine("Could not bind attribute {0}", name); 

 return location;
 }
 
 //! Attribute get
 public int getUniformLocation(string name)
 {
 int location = -1;
 location = GL.GetUniformLocation(ShaderProgram, name);
 if (location == -1)
 Console.WriteLine("Could not bind attribute {0}", name); 

 return location;
 }

 public void setUniform(int unifMatrix, Matrix4 matrixProjection)
 {
 GL.UniformMatrix4(unifMatrix, false, ref matrixProjection);
 }
 }

 class Game : GameWindow
 {
 private GlShader shader = new GlShader();

 //! ID атрибута вершин
 int Attrib_vertex;
 //! ID атрибута цветов
 int Attrib_color;
 //! ID юниформ матрицы проекции
 int Unif_matrix;
 //! ID Vertex Buffer Object
 int VBO_vertex;
 //! ID Vertex Buffer Object
 int VBO_color;
 //! ID VBO for element indices
 int VBO_element;

 //! Вершина
 public struct Vertex
 {
 public float x;
 public float y;
 public float z;
 };
 
 //! Количество индексов
 int Indices_count;
 //! Матрица проекции
 Matrix4 Matrix_projection;

 public Game()
 : base(640, 480, new GraphicsMode(new ColorFormat(32), 16), "Simple shaders on OpenTK!")
 {

 }

 protected override void OnLoad(EventArgs e)
 {
 base.OnLoad(e);

 GL.ClearColor(Color.Black);

 //! Инициализация
 initGL();
 initVBO();
 initShader();
 }

 protected override void OnUnload(EventArgs e)
 {
 base.OnUnload(e);

 //! Освобождение ресурсов
 freeVBO();
 shader.Dispose();
 }

 //! Функция печати лога шейдера
 static void ShaderLog(string tag, int shader)
 {
 string infoLog;

 GL.GetShaderInfoLog(shader, out infoLog);

 if (infoLog.Length > 1)
 Console.WriteLine(tag + " InfoLog: " + infoLog + "\n\n\n");
 }

 //! Проверка ошибок OpenGL, если есть то вывод в консоль тип ошибки
 static void CheckOpenGLerror()
 {
 ErrorCode errCode = GL.GetError();
 if (errCode != ErrorCode.NoError)
 {
 Console.WriteLine("OpenGl error! - {0}", errCode);
 Console.WriteLine(System.Environment.StackTrace);
 }
 }
 
 void initGL()
 {
 GL.ClearColor(0, 0, 0, 0);
 GL.Enable(EnableCap.DepthTest);
 }

 //! Инициализация шейдеров
 private void initShader()
 {
 //! Исходный код шейдеров
 const string vsSource = 
 @"attribute vec3 coord;
 attribute vec3 color;
 varying vec3 var_color;
 uniform mat4 matrix;
 void main() {
 gl_Position = matrix * vec4(coord, 1.0);
 var_color = color;
 }";
 const string fsSource = 
 @"varying vec3 var_color;
 void main() {
 gl_FragColor = vec4(var_color, 1.0);
 }";
 
 if(shader.load(vsSource, fsSource) == -1)
 {
 Console.WriteLine("error load shader");
 return;
 }
 
 CheckOpenGLerror();

 //! Вытягиваем ID атрибута из собранной программы 
 Attrib_vertex = shader.getAttribLocation("coord");
 
 CheckOpenGLerror();

 //! Вытягиваем ID юниформ
 Attrib_color = shader.getAttribLocation("color");
 
 CheckOpenGLerror();

 //! Вытягиваем ID юниформ матрицы проекции
 Unif_matrix = shader.getUniformLocation("matrix");

 CheckOpenGLerror();
 }

//! Инициализация VBO_vertex
 void initVBO()
 {
 //! Вершины куба
 Vertex [] vertices = { 
 new Vertex {x = -1.0f,y = -1.0f,z = -1.0f},
 new Vertex {x = 1.0f, y =-1.0f, z =-1.0f},
 new Vertex {x = 1.0f, y = 1.0f, z =-1.0f},
 new Vertex {x = -1.0f,y = 1.0f, z =-1.0f},
 new Vertex {x = -1.0f,y = -1.0f,z = 1.0f},
 new Vertex {x = 1.0f, y =-1.0f, z = 1.0f},
 new Vertex {x = 1.0f, y = 1.0f, z = 1.0f},
 new Vertex {x = -1.0f,y = 1.0f,z = 1.0f}
 };
 //! Цвета куба без альфа компонента(RGB)
 Vertex [] colors = { 
 new Vertex {x = 1.0f,y = 0.5f,z = 1.0f},
 new Vertex {x = 1.0f,y = 0.5f,z = 0.5f},
 new Vertex {x = 0.5f,y = 0.5f,z = 1.0f},
 new Vertex {x = 0.0f,y = 1.0f,z = 1.0f},
 new Vertex {x = 1.0f,y = 0.0f,z = 1.0f},
 new Vertex {x = 1.0f,y = 1.0f,z = 0.0f},
 new Vertex {x = 1.0f,y = 0.0f,z = 1.0f},
 new Vertex {x = 0.0f,y = 1.0f,z = 1.0f}
 };
 //! Индексы вершин, общие и для цветов
 uint [] indices = {
 0, 4, 5, 0, 5, 1,
 1, 5, 6, 1, 6, 2,
 2, 6, 7, 2, 7, 3,
 3, 7, 4, 3, 4, 0,
 4, 7, 6, 4, 6, 5,
 3, 0, 1, 3, 1, 2
 };

 // Создаем буфер для вершин
 GL.GenBuffers(1, out VBO_vertex);
 GL.BindBuffer(BufferTarget.ArrayBuffer, VBO_vertex);
 GL.BufferData(BufferTarget.ArrayBuffer, vertices.Length * Vector3.SizeInBytes, vertices, BufferUsageHint.StaticDraw);

 // Создаем буфер для цветов вершин
 GL.GenBuffers(1, out VBO_color);
 GL.BindBuffer(BufferTarget.ArrayBuffer, VBO_color);
 GL.BufferData(BufferTarget.ArrayBuffer, colors.Length * Vector3.SizeInBytes, colors, BufferUsageHint.StaticDraw);

 // Создаем буфер для индексов вершин
 GL.GenBuffers(1, out VBO_element);
 GL.BindBuffer(BufferTarget.ElementArrayBuffer, VBO_element);
 GL.BufferData(BufferTarget.ElementArrayBuffer, indices.Length * sizeof(int), indices, BufferUsageHint.StaticDraw);

 Indices_count = indices.Length;

 CheckOpenGLerror();
 }

 void freeVBO()
 {
 GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
 GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
 
 GL.DeleteBuffers(1, ref VBO_element);
 GL.DeleteBuffers(1, ref VBO_element);
 GL.DeleteBuffers(1, ref VBO_color);
 }

 protected override void OnRenderFrame(FrameEventArgs e)
 {
 base.OnRenderFrame(e);

 GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

 //! Устанавливаем шейдерную программу текущей
 shader.use();
 //! Передаем матрицу в шейдер
 shader.setUniform(Unif_matrix, Matrix_projection);
 
 //! Подключаем буфер с индексами вершин общий для цветов и их вершин
 GL.BindBuffer(BufferTarget.ElementArrayBuffer, VBO_element);

 //! ВЕРШИНЫ
 //! Включаем массив атрибутов для вершин
 GL.EnableVertexAttribArray(Attrib_vertex);
 //! Подключаем VBO
 GL.BindBuffer(BufferTarget.ArrayBuffer, VBO_vertex);
 //! Указывая pointer 0 при подключенном буфере, мы указываем что данные в VBO
 GL.VertexAttribPointer(Attrib_vertex, 3, VertexAttribPointerType.Float, false, 0, 0);

 //! ЦВЕТА
 //! Включаем массив атрибутов для цветов
 GL.EnableVertexAttribArray(Attrib_color);
 GL.BindBuffer(BufferTarget.ArrayBuffer, VBO_color);
 GL.VertexAttribPointer(Attrib_color, 3, VertexAttribPointerType.Float, false, 0, 0);


 //! Передаем данные на видеокарту(рисуем)
 GL.DrawElements(BeginMode.Triangles, Indices_count, DrawElementsType.UnsignedInt, 0);

 //! Отключаем массив атрибутов
 GL.DisableVertexAttribArray(Attrib_vertex);

 //! Отключаем массив атрибутов
 GL.DisableVertexAttribArray(Attrib_color);

 CheckOpenGLerror();

 SwapBuffers();
 }

 protected override void OnResize(EventArgs e)
 {
 base.OnResize(e);

 GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height);

 var height = ClientRectangle.Height > 0 ? ClientRectangle.Height : 1;
 float aspectRatio = (float)ClientRectangle.Width/(float)height;

 Matrix_projection = Matrix4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(45.0f), aspectRatio, 1.0f, 200.0f);
 
 // Перемещаем центр нашей оси координат для того чтобы увидеть куб
 Matrix_projection = Matrix4.Mult(Matrix4.CreateTranslation(new Vector3(0.0f, 0.0f, -10.0f)), Matrix_projection);
 // Поворачиваем ось координат(тоесть весь мир), чтобы развернуть отрисованное
 Matrix_projection = Matrix4.Mult(Matrix4.CreateFromAxisAngle(new Vector3(1.0f, 1.0f, 0.0f), MathHelper.DegreesToRadians(60.0f)), Matrix_projection);
 }
 }

 class Program
 {
 static void Main(string[] args)
 {
 var g = new Game();
 g.Run(30.0f);
 }
 }
}

using System.Net.Sockets;
using System.Collections.Generic;

namespace EsateServer
{
 public class Client
 {
 // Статический список клиентов, подключенных в данный момент
 public static List<Client> CLIENTSLIST = new List<Client>();
 public static uint NEXT_ID
 {
 get
 {
 uint id = 1;
 while (CLIENTSLIST.Find(client => client.ID == id) != null) id++;
 return id;
 }
 }
 public TcpClient TCPClient = null;
 public uint ID = 0;
 public bool IS_CONNECTED = false;
 // Имя файла, полученного от клиента
 public string FILE_NAME = string.Empty;

 public Client(uint id, TcpClient tcpclient)
 {
 // Подключение
 ID = id;
 TCPClient = tcpclient;
 IS_CONNECTED = true;

 // Добавляем клиента в список текущих клиентов
 CLIENTSLIST.Add(this);
 }

 public void Disconnect()
 {
 // Отключение
 IS_CONNECTED = false;
 if (TCPClient != null)
 {
 TCPClient.Close();
 TCPClient = null;
 }

 // Убираем клиента из списка текущих клиентов
 CLIENTSLIST.Remove(this);
 }
 }
} 

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

namespace EsateServer
{
 public static class DataWrapper
 {
 // Рекурсивный метод получения данных из потока
 private static async Task<bool> ReceiveDataLoop(Client client, byte[] buffer, int received = 0)
 {
 // Недополученные байты
 int difference = buffer.Length - received;
 // Смещение индекса
 int offset = buffer.Length - difference;
 try
 {
 // Полученные байты
 received += await client.TCPClient.GetStream().ReadAsync(buffer, offset, difference);
 }
 catch
 {
 // Если что-то пошло не так
 return false;
 }
 // Если получили не все байты
 if (received < buffer.Length)
 {
 // Продолжаем заполнять буффер
 return await ReceiveDataLoop(client, buffer, received);
 }
 else
 {
 // Все прошло успешно
 return true;
 }
 }

 public static async Task<byte[]> GetData(Client client)
 {
 byte[] buffer = new byte[4];
 // Получаем длинну имени
 if (!await ReceiveDataLoop(client, buffer)) return null;
 // Получаем имя
 buffer = new byte[Program.BytesToInt(buffer)];
 if (!await ReceiveDataLoop(client, buffer)) return null;
 client.FILE_NAME = Encoding.UTF8.GetString(buffer);
 // Получаем длинну файла
 buffer = new byte[4];
 if (!await ReceiveDataLoop(client, buffer)) return null;
 // Получаем файл
 buffer = new byte[Program.BytesToInt(buffer)];
 if (!await ReceiveDataLoop(client, buffer)) return null;

 // Возвращаем файл
 return buffer;
 }

 public static async Task SendData(Client client, byte[] data)
 {
 // Пишем данные в поток
 await client.TCPClient.GetStream().WriteAsync(data, 0, data.Length);
 }

 public static byte[] CreatePack(string filename, byte[] data)
 {
 // Создаем пакет для отправки
 List<byte> packList = new List<byte>();
 // Переводим строку в массив UTF8 байт
 byte[] name_bytes = Encoding.UTF8.GetBytes(filename);
 // Добавляем длинну строки
 packList.AddRange(BitConverter.GetBytes(name_bytes.Length));
 // Добавляем байты строки
 packList.AddRange(name_bytes);
 // Добавляем количество байт файла
 packList.AddRange(BitConverter.GetBytes(data.Length));
 // Добавляем байты файла
 packList.AddRange(data);

 // Возвращаем пакет для отправки
 return packList.ToArray();
 }
 }
}

using System;
using System.Net;
using System.Net.Sockets;

namespace EsateServer
{
 public class EsateServer
 {
 // Public variables
 public bool IS_RUNNING;
 // Private variables
 private static int PORT;
 private TcpListener TCPServer;

 // Constructor
 public EsateServer(int port = 1100)
 {
 PORT = port;
 IS_RUNNING = false;
 }

 //Public methods
 public void Start()
 {
 // Слушаем весь диапазон IP на заданном порту
 TCPServer = new TcpListener(IPAddress.Any, PORT);
 TCPServer.Start();
 IS_RUNNING = true;

 // Запускаем прослушивание клиентов
 AcceptClient();
 }
 public void Stop()
 {
 IS_RUNNING = false;

 try
 {
 while (Client.CLIENTSLIST.Count > 0)
 {
 Client.CLIENTSLIST[0].Disconnect();
 Client.CLIENTSLIST.RemoveAt(0);
 }
 }
 catch { }

 Client.CLIENTSLIST.Clear();
 TCPServer.Stop();
 }

 //Private methods
 private async void AcceptClient()
 {
 // Пока сервер запущен
 while (IS_RUNNING)
 {
 try
 {
 // Принимаем клиента
 TcpClient TCPClient = await TCPServer.AcceptTcpClientAsync();
 // Создаем экземпляр клиента
 var client = new Client(Client.NEXT_ID, TCPClient);

 // Дожидаемся данных от клиента и пишем их в массив
 byte[] data = await DataWrapper.GetData(client);
 // Если данные пришли
 if (data != null)
 {
 // Отправляем полученные данные клиенту обратно
 await DataWrapper.SendData(client, DataWrapper.CreatePack(client.FILE_NAME, data));
 }
 else
 {
 // Если что-то пошло не так
 System.Windows.Forms.MessageBox.Show("Файл не получен!", "Внимание!", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
 }

 // Отключаем клиента
 client.Disconnect();
 }
 catch (ObjectDisposedException) { return; }
 catch (Exception) { return; }
 }
 }
 }
}

 private EsateServer server;

 public MainForm()
 {
 InitializeComponent();
 server = new EsateServer();
 }

 private void btnConnect_Click(object sender, EventArgs e)
 {
 if (server.IS_RUNNING)
 {
 // Остановка сервера
 server.Stop();
 btnConnect.Text = "Запустить";
 txtLog.AppendText($"{DateTime.Now}: Сервер остановлен\r\n");
 }
 else
 {
 // Запуск сервера
 server.Start();
 btnConnect.Text = "Остановить";
 txtLog.AppendText($"{DateTime.Now}: Сервер запущен\r\n");
 }
 }

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);
} 

 [Flags]
    public enum Lib3dsTextureMapFlags
    {
        LIB3DS_TEXTURE_DECALE = 0x0001,
        LIB3DS_TEXTURE_MIRROR = 0x0002,
        LIB3DS_TEXTURE_NEGATE = 0x0008,
        LIB3DS_TEXTURE_NO_TILE = 0x0010,
        LIB3DS_TEXTURE_SUMMED_AREA = 0x0020,
        LIB3DS_TEXTURE_ALPHA_SOURCE = 0x0040,
        LIB3DS_TEXTURE_TINT = 0x0080,
        LIB3DS_TEXTURE_IGNORE_ALPHA = 0x0100,
        LIB3DS_TEXTURE_RGB_TINT = 0x0200
    }
 public class Lib3dsTextureMap
    {
        //public uint user_id;
        //public object user_ptr;
        public string name = "";
        public Lib3dsTextureMapFlags flags;
        public float percent;
        public float blur;
        public float[] scale = new float[2];
        public float[] offset = new float[2];
        public float rotation;
        public float[] tint_1 = new float[3];
        public float[] tint_2 = new float[3];
        public float[] tint_r = new float[3];
        public float[] tint_g = new float[3];
        public float[] tint_b = new float[3];
    }
public class Lib3dsMaterial
    {
        //public uint user_id;
        //public object user_ptr;
        public string name = "";                                  // Material name
        public float[] ambient = new float[3];    // Material ambient reflectivity
        public float[] diffuse = new float[3];    // Material diffuse reflectivity
        public float[] specular = new float[3];   // Material specular reflectivity
        public float shininess;                                 // Material specular exponent
        public float shin_strength;
        public bool use_blur;
        public float blur;
        public float transparency;
        public float falloff;
        public bool is_additive;
        public bool self_illum_flag;
        public float self_illum;
        public bool use_falloff;
        public int shading;
        public bool soften;
        public bool face_map;
        public bool two_sided;                  // Material visible from back
        public bool map_decal;
        public bool use_wire;
        public bool use_wire_abs;
        public float wire_size;
        public Lib3dsTextureMap texture1_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap texture1_mask = new Lib3dsTextureMap();
        public Lib3dsTextureMap texture2_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap texture2_mask = new Lib3dsTextureMap();
        public Lib3dsTextureMap opacity_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap opacity_mask = new Lib3dsTextureMap();
        public Lib3dsTextureMap bump_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap bump_mask = new Lib3dsTextureMap();
        public Lib3dsTextureMap specular_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap specular_mask = new Lib3dsTextureMap();
        public Lib3dsTextureMap shininess_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap shininess_mask = new Lib3dsTextureMap();
        public Lib3dsTextureMap self_illum_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap self_illum_mask = new Lib3dsTextureMap();
        public Lib3dsTextureMap reflection_map = new Lib3dsTextureMap();
        public Lib3dsTextureMap reflection_mask = new Lib3dsTextureMap();
        public uint autorefl_map_flags;
        public int autorefl_map_anti_alias; // 0=None, 1=Low, 2=Medium, 3=High
        public int autorefl_map_size;
        public int autorefl_map_frame_step;
    }
 public class Lib3dsMesh
    {
        //public uint user_id;
        //public object user_ptr;
        public string name = "";                                  // Mesh name. Don't use more than 8 characters
        public Lib3dsObjectFlags object_flags;  // see Lib3dsObjectFlags
        public byte color;                                              // Index to editor palette [0..255]
        public float[,] matrix = new float[4, 4]; // Transformation matrix for mesh data
        public ushort nvertices;                                // Number of vertices in vertex array (max. 65535)
        public List<Lib3dsVertex> vertices;
        public List<Lib3dsTexturecoordinate> texcos;
        public List<ushort> vflags;
        public ushort nfaces;                                   // Number of faces in face array (max. 65535)
        public List<Lib3dsFace> faces;
        public string box_front = "";
        public string box_back = "";
        public string box_left = "";
        public string box_right = "";
        public string box_top = "";
        public string box_bottom = "";
        public Lib3dsMapType map_type;
        public float[] map_pos = new float[3];
        public float[,] map_matrix = new float[4, 4];
        public float map_scale;
        public float[] map_tile = new float[2];
        public float[] map_planar_size = new float[2];
        public float map_cylinder_height;
    }

SimpleOpenGlControl GLCGraph,Vid;

GLCGraph.InitializeContexts();
Vid.InitializeContexts();

Vid.InitializeContexts();
 GLCGraph.InitializeContexts();

 Vid.InitializeContexts();
 GLCGraph.InitializeContexts();
 Vid.InitializeContexts();

Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);

Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_CLAMP_TO_EDGE);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_CLAMP_TO_EDGE);

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;
// для работы с библиотекой OpenGL 
using Tao.OpenGl;
// для работы с библиотекой FreeGLUT 
using Tao.FreeGlut;
// для работы с элементом управления SimpleOpenGLControl 
using Tao.Platform.Windows;

namespace View3D
{
    public partial class Form1 : Form
    {
        int x, y;
        double AlphaX,AlphaY;
        bool MouseIsDown;
        public Form1()
        {
            AlphaX = 45;
            AlphaY = 45;
            
            InitializeComponent();
            AnT.InitializeContexts();

            Init();
            Draw();
            
            Gl.glFlush();
            AnT.Invalidate();
        }

        private void Init()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Gl.glClearColor(0, 0, 0, 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);
            Glu.gluLookAt(10, 10, 10, 0, 0, 0, 0, 0, 1); 
        }

        private void Draw()
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            Gl.glLoadIdentity();
            Gl.glColor3f(1, 1, 1);
            Gl.glPushMatrix();
            Gl.glTranslated(0, 0, -6);
            Gl.glRotated(AlphaX, 1, 0, 0);
            Gl.glRotated(AlphaY, 0, 1, 0);

            Glut.glutWireCube(2);
            Gl.glColor3f(1, 0, 0);

            DrawAxes(0.5);
            Gl.glPopMatrix();
        }
        private void DrawAxes(double Length)
        {
            Gl.glColor3f(1, 0, 0);
            Gl.glBegin(Gl.GL_LINES);
                Gl.glVertex3d(0,0,0);
                Gl.glVertex3d(Length, 0, 0);
            Gl.glEnd();
            Gl.glColor3f(0, 1, 0);
            Gl.glBegin(Gl.GL_LINES);
                Gl.glVertex3d(0, 0, 0);
                Gl.glVertex3d(0, Length, 0);
            Gl.glEnd();
            Gl.glColor3f(0, 0, 1);
            Gl.glBegin(Gl.GL_LINES);
                Gl.glVertex3d(0, 0, 0);
                Gl.glVertex3d(0, 0, Length);
            Gl.glEnd();
        }

        private void AnT_DragDrop(object sender, DragEventArgs e)
        {
            
        }

        private void AnT_MouseDown_1(object sender, MouseEventArgs e)
        {
            x = e.X;
            y = e.Y;
            MouseIsDown = true;
        }

        private void AnT_MouseUp_1(object sender, MouseEventArgs e)
        {
            MouseIsDown = false;
        }

        private void AnT_MouseMove_1(object sender, MouseEventArgs e)
        {
            if (MouseIsDown)
            {
                AlphaX += Convert.ToDouble(x - e.X);
                AlphaY += Convert.ToDouble(y - e.Y);
                x = e.X;
                y = e.Y;
                Init();
                Draw();
            }
        }
    }
}

    class Cubic
    {
        public double x, y, z,size,r,g,b;
        public Cubic(double x, double y, double z)
        {

        }
        public void Draw()
        {
            Gl.glPushMatrix();
            Gl.glTranslated(x,y,z);
            Gl.glRotated(45, 1, 0, 1);
            Gl.glColor3d(r, g, b);
            Gl.glBegin(Gl.GL_POLYGON);
                Gl.glVertex3d(size, size, size);
                Gl.glVertex3d(-size, size, size);
                Gl.glVertex3d(-size, -size, size);
                Gl.glVertex3d(size, -size, size);
            Gl.glEnd();
            Gl.glBegin(Gl.GL_POLYGON);
                Gl.glVertex3d(size, size, -size);
                Gl.glVertex3d(size, -size, -size);
                Gl.glVertex3d(-size, -size, -size);
                Gl.glVertex3d(-size, size, -size);
            Gl.glEnd();
            Gl.glBegin(Gl.GL_POLYGON);
                Gl.glVertex3d(-size, size, size);
                Gl.glVertex3d(-size, size, -size);
                Gl.glVertex3d(-size, -size, -size);
                Gl.glVertex3d(-size, -size, size);
            Gl.glEnd();
            Gl.glBegin(Gl.GL_POLYGON);
                Gl.glVertex3d(size, size, size);
                Gl.glVertex3d(size, -size, size);
                Gl.glVertex3d(size, -size, -size);
                Gl.glVertex3d(size, size, -size);
            Gl.glEnd();
            Gl.glBegin(Gl.GL_POLYGON);
                Gl.glVertex3d(-size, size, -size);
                Gl.glVertex3d(-size, size, size);
                Gl.glVertex3d(size, size, size);
                Gl.glVertex3d(size, size, -size);
            Gl.glEnd();
            Gl.glBegin(Gl.GL_POLYGON);
                Gl.glVertex3d(-size, -size, -size);
                Gl.glVertex3d(size, -size, -size);
                Gl.glVertex3d(size, -size, size);
                Gl.glVertex3d(-size, -size, size);
            Gl.glEnd();
            Gl.glPopMatrix();
        }
    }

          Glu.gluLookAt(Position.x, Position.y, Position.z, //Позиция самой камеры
                        View.x, View.y, View.z,             //Куда смотрим
                        Up.x, Up.y, Up.z);                  //Верх камеры

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Tao.FreeGlut;
using Tao.OpenGl;
using Tao.Platform.Windows;

namespace Engine
{
    class Camera
    {
        private struct Vector3D
        {
            public float x, y, z;
        };
    }
}

Objects[] mObject = new Objects[999];

intcreatedObjects; 

void glutSolidCylinder   (    GLdouble    radius,
GLdouble    height,
GLint    slices,
GLint    stacks
)    
    
Draw a solid cylinder.

Parameters:
radius    Radius of the cylinder.
height    Z height.
slices    Divisions around z axis.
stacks    Divisions along z axis.

Glut.glutSolidCylinder(1,2,32,32);