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;
using Tao.DevIl;

namespace Lab_2___LightMove
{
    public partial class Form1 : Form
    {
        
        class Light
        {
            public Tao.Platform.Windows.SimpleOpenGlControl AnT;

            public double Zoom = 1;

            public int AngleX, AngleY;
           
            public int Angle = 0;

            private bool textureIsLoad = false;
            // имя текстуры 
            public string texture_name = "";
            // идентификатор текстуры
            public int imageId = 0;
            public uint mGlTextureObject = 0;

            public Light(Tao.Platform.Windows.SimpleOpenGlControl glControl)
            {
                AnT = glControl;

                Il.ilInit();
                Il.ilEnable(Il.IL_ORIGIN_SET);

                Glut.glutInit();

                Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
               
               
               
                Gl.glClearColor(100, 0, 255, 0.5f);

                ReloadMatrix();
               
            }

            public void ReloadMatrix()
            {
                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, 100);
               
                Gl.glMatrixMode(Gl.GL_MODELVIEW);
                Gl.glLoadIdentity();

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

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

               

            }

            public void Draw()
            {

                Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
                Gl.glClearColor(40, 150, 255, 0.9f);
            
                Gl.glLoadIdentity();

                Gl.glTranslated(0, 0, -5);
               
                Gl.glRotated(AngleX, 1, 0, 0);
                Gl.glRotated(AngleY, 0, 1, 0);

               
                Gl.glScaled(Zoom, Zoom, Zoom);

                Glut.glutSolidCube(1.3);
                Glut.glutWireTorus(0.2, 2.2, 32, 32); // тор 
                Glut.glutSolidCone(2, 3, 32, 32);
              

                Gl.glPopMatrix();

                Gl.glFlush();

                AnT.Invalidate();
            }

            public void Texture()
            {
                Il.ilGenImages(1, out imageId);
                // делаем изображение текущим 
                Il.ilBindImage(imageId);
                // адрес изображения полученный с помощью окна выбора файла 
                string url = "img2.png";
                // пробуем загрузить изображение 
                if ( Il.ilLoadImage(url))
                {
                    // если загрузка прошла успешно
                    // сохраняем размеры изображения 
                    int width = Il.ilGetInteger( Il.IL_IMAGE_WIDTH);
                    int height = Il.ilGetInteger( Il.IL_IMAGE_HEIGHT);
                    // определяем число бит на пиксель 
                    int bitspp = Il.ilGetInteger( Il.IL_IMAGE_BITS_PER_PIXEL);
                    switch (bitspp) // в зависимости от полученного результата
                    {
                        // создаем текстуру, используя режим GL_RGB или GL_RGBA 
                        case 24:
                            mGlTextureObject = MakeGlTexture( Gl.GL_RGB, Il.ilGetData(), width, height);
                            break ;
                        case 32:
                            mGlTextureObject =  MakeGlTexture( Gl.GL_RGBA, Il.ilGetData(), width, height);
                            break ;
                    } // активируем флаг, сигнализирующий загрузку текстуры 
                    textureIsLoad = true ;
                    // очищаем память 
                    Il.ilDeleteImages(1, ref imageId);
                }
               
            }

            public void DrawTexture()
            {
                if (textureIsLoad)
                {
                   

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

                    Gl.glEnable(Gl.GL_TEXTURE_2D);
                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, mGlTextureObject);

                    Gl.glPushMatrix();

                    Gl.glTranslated(0, -1, -5);
                    Gl.glRotated(35, 0, 1, 0);

                    Gl.glBegin(Gl.GL_QUADS);

                    Gl.glVertex3d(1, 1, 0);
                    Gl.glTexCoord2f(0, 0);
                    Gl.glVertex3d(1, 0, 0);
                    Gl.glTexCoord2f(1, 0);
                    Gl.glVertex3d(0, 0, 0);
                    Gl.glTexCoord2f(1, 1);
                    Gl.glVertex3d(0, 1, 0);
                    Gl.glTexCoord2f(0, 1);

                    Gl.glEnd();

                    Gl.glPopMatrix();
                    Gl.glDisable(Gl.GL_TEXTURE_2D);

                    AnT.Invalidate();
                }
            }

            private static uint MakeGlTexture(int Format, IntPtr pixels, int w, int h)
            {
                uint texObject;

                Gl.glGenTextures(1, out texObject);

                Gl.glPixelStorei(Gl.GL_UNPACK_ALIGNMENT, 1);

                Gl.glBindTexture(Gl.GL_TEXTURE_2D, texObject);

                Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
                Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
                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.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_REPLACE);

                switch (Format)
                {
                    case Gl.GL_RGB:
                        Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB, w, h, 0, Gl.GL_RGB, Gl.GL_UNSIGNED_BYTE, pixels);
                        break;

                    case Gl.GL_RGBA:
                        Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA, w, h, 0, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, pixels);
                        break;
                }

                return texObject;
            }
        }


        public Form1()
        {

            InitializeComponent();
            AnT.InitializeContexts();
          
            AnT.MouseWheel += new MouseEventHandler(this.Ant_MouseWheel);
        }

        
        Light light;

        private void Form1_Load(object sender, EventArgs e)
        {
            light = new Light(AnT);
            RenderTimer.Start();
            light.Texture();

        }

        private void RenderTimer_Tick(object sender, EventArgs e)
        {
            //light.Draw();
            light.DrawTexture();
        }

 

        private void Ant_MouseWheel(object sender, MouseEventArgs e)
        {
           if (e.Delta > 0)
            {
                light.Zoom+=0.1;
            }
           else
            {
                light.Zoom-=0.1;
            }
        }
        private void AnT_KeyPress(object sender, KeyPressEventArgs e)
        {
            
            switch(e.KeyChar)
            {
                case (char)119:
                    {
                        //light.osY++;
                       
                        light.AngleX++;
                        break;
                    }
                case (char)115:
                    {
                        //light.osY--;
                       
                        light.AngleX--;
                        break;
                    }
                case (char)97:
                    {
                        //light.osX++;
                       
                        light.AngleY++;
                        break;
                    }
                case (char)100:
                    {
                        //light.osX--;
                        
                        light.AngleY--;
                        break;
                    }
            }
           
           
        }
    }
}