// template.cpp: define el punto de entrada de la aplicación de consola.
//


#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

// El orden importa, primero es Glew y luego glfw

//GLEW
#define GLEW_STATIC // vamos a usar las cosas experimentales, o sea todo lo que tiene que ver con shaders
#include "GL\glew.h"

//GLFW
#include "GLFW\glfw3.h"

//GLM
#include "glm\glm.hpp"
#include "glm\gtc\matrix_transform.hpp"



using namespace std;
using namespace glm;

//Nuestro codigo de shader
#include "shader.hpp"
#include "cargarbmp.hpp"

GLFWwindow * window; // Apuntador llamado window de tipo GLFWwin
GLuint vertexArrayID; // después le meteremos valores para hacer un triangulo
GLuint programaID;
GLuint MatrizID;

GLuint vertexBufferID;
GLuint uvBufferID;

GLfloat textura;
GLuint texturaShaderID;

glm::mat4 mvp;
// en ese orden se deben multiplicar
glm::mat4 proyeccion;
glm::mat4 vista;
glm::mat4 modelo;
glm::vec3 posicionCamara = glm::vec3(4, 4, 4); // le ponemos glm para saber que viene de la libreria glm
glm::vec3 direccionCamara = glm::vec3(0, 0, 0);
glm::vec3 rotacionModelo = glm::vec3(0, 0, 0);


// declarar funciones globales
void moverCamara();
void dibujar();
void moverModelo();

void moverModelo(){

	if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS){
		const glm::vec3 ejeY = glm::vec3(1, 1, 0); // afecta nada al eje X, todo al Y and nada al Z
		modelo = glm::rotate(modelo, 0.001f, ejeY);
		mvp = proyeccion * vista * modelo;
	}
}

void moverCamara(){

		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS){

		direccionCamara.y += 0.01f;
	}

		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS){

		direccionCamara.y -= 0.01f;

	}

	if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS){

		direccionCamara.x += 0.01f;

	}

		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS){

		direccionCamara.x -= 0.01f;

	}

	if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS){

		posicionCamara.x += 0.01f;

	}

	if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS){

		posicionCamara.x -= 0.01f;

	}

	if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS){

		posicionCamara.y += 0.01f;
		}

	if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS){

		posicionCamara.y -= 0.01f;
	}

	vista = glm::lookAt(
		posicionCamara, // donde esta
		direccionCamara, // a donde mira
		glm::vec3(0, 1, 0));

	mvp = proyeccion * vista * modelo;

}

void dibujar(){

	moverCamara();

	moverModelo();

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glUseProgram(programaID);
	// donde encontrar al parametro que queremos usar en los shaders,
	glUniformMatrix4fv(MatrizID, 1, GL_FALSE, &mvp[0][0]);

	//Activando la primera textura de OpenGL
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, textura);
	//Mapeo con el shader
	glUniform1i(texturaShaderID, 0);

	// vamos a trabajar en la primer variable del shader del vertice (o sea posicionVertice)
	glEnableVertexAttribArray(0);
	//Estamos diciendo a OpenGl que vamos a usar este buffer de aqui en adelante
	glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
	// el primero el indice del atributo (location = 0 ), y luego el numero de vertices...GL_FLOAT...GL_FALSE..
	// el cuarto (strike) valor es de donde empieza a tomar valores, si pones 3, toma los ultimos 3 valores...
	// el quinto es el espacio de memoria de cada uno de los elementos que te saltas en el Strike
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

	//Vamos a trabajar con verticeUV (por eso le indicamos el 1
	glEnableVertexAttribArray(1);
	glBindBuffer(GL_ARRAY_BUFFER, uvBufferID);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)0); //porque es el atributo numero 1 osea vertice uv
								//el 2 hace referencia al numero de cordenadas que quieres mandar (en este caso U y V)




	// el tres del segundo parametro de abajo indica que cada 3 valores van a ser un vec 3 (hablando de los 36 valores de color)
	// el void del final significa que se va a usar todo el arreglo completo.
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

	// el cero es de donde empiezas a trabajar y el 3  el final
	glDrawArrays(GL_TRIANGLES, 0, 36);
	glDisableVertexAttribArray(0); // ya no vamos a trabajar con el atributo posicionVertice (localizado en 0)

	//tenemos dos buffers, cambio de buffer
	// Al crear un contexto, en ese moment se establecen los buffers
	// pero nosotros no creamos los buffers que se estan cambiando
	// Por default tenemos dos buffers

	glfwSwapBuffers(window);
	glfwPollEvents();
}



//vamos a hacer una matriz de transformacion con glm

int _tmain(int argc, _TCHAR* argv[])
{
	//verificar que se inició bien
	if (!glfwInit()){
		printf("No se pude inicializar GLFW");
		getchar();
		return -1;

	}

	// Validaciones de compatibilidad con la version de opengl que corre la maquina
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //nuestra version de openGL es la 3
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //No queremos OpenGL viejos, va a marcar error

	//HORA DE CREAR LA VENTANA
	int ancho = 1024;
	int alto = 768;

	window = glfwCreateWindow(ancho, alto, "Título", NULL, NULL); // Crear ventana

	//Poner en contexto la ventana, o sea, todo lo que haga OpenGL va a ser dentro de esta ventana.
	//window es una direccion de memoria que lleva a un espacio de memoria que tiene una ventana.
	//Por eso no le pusimos AMPERSON, porque lo declaramos como un apuntador.
	glfwMakeContextCurrent(window);

	glewExperimental = true; //las funciones experimentales nos permiten cargar los shaders

	if (glewInit() != GLEW_OK){

		printf("No se pudo inicializar GLEW");
		getchar();
		return -1;
	}



	glGenVertexArrays(1, &vertexArrayID);
	glBindVertexArray(vertexArrayID); //le dice a openGL que vamos a utilizar este vertex array

	// aqui tenemos la direccion de memoria de nuestro programa de3  shaderes
	programaID = CargarShaders("textura.vertexshader", "textura.fragmentshader");

	// matrizID es la direccion de memoria de la matriz mvp que es la combinacion de la matriz vista * proyection * modelo..etc.
	MatrizID = glGetUniformLocation(programaID, "MVP"); // va a representar a MVP
	//yo quiero una matriz que se localiza en programaID

	proyeccion = glm::perspective(glm::radians(45.0f), (float)ancho / alto, 0.1f, 100.0f); // ya tengo una matriz
	// de proyeccion que va a emular una vision acorde a los parametros de aqui arriba

		vista = glm::lookAt(//matriz de vista

		posicionCamara, //donde está la cam
		direccionCamara,//hacia donde apunta la camara
		glm::vec3(0, 1, 0)//cual es tu vector de arriba

		);

	// multiplicar matriz projection por la de la vista por la del modelo

	modelo = glm::mat4(1.0f); // es una matriz identidad

	mvp = proyeccion * vista * modelo;

	textura = cargarBmp("uvtemplate.bmp"); // cargar bmp
	texturaShaderID = glGetUniformLocation(programaID, "textura"); // texturashader id representa
	//el espacio de memoria que representa a sampler2D (que es el tipo de dato que usa el shader para las imagenes)



	// CONCEPTO: buffer es un espacio de memoria que se manda completo al GPU

	GLfloat vertex_buffer_data[] = {  // esta cura ya sabe que hará un triangulo porque aqui se lo indicamos: glDrawArrays(GL_TRIANGLES, 0, 3);
		// el tres indica que son tres vertices (cada uno con x, y and z)
		/*
		-1.0f, -1.0f, 0.0f, // posiciones x, y and z de el punto 1
		1.0f, -1.0f, 0.0f, //posiciones x, y and z de el punto 2
		0.0f, 1.0f, 0.0f //posiciones x, y and z de el punto 3
		*/

		// Lo siguiente es un cubo hecho de triangulos

		-1.0f, -1.0f, -1.0f,
		-1.0f, -1.0f, 1.0f,
		-1.0f, 1.0f, 1.0f,
		1.0f, 1.0f, -1.0f,
		-1.0f, -1.0f, -1.0f,
		-1.0f, 1.0f, -1.0f,
		1.0f, -1.0f, 1.0f,
		-1.0f, -1.0f, -1.0f,
		1.0f, -1.0f, -1.0f,
		1.0f, 1.0f, -1.0f,
		1.0f, -1.0f, -1.0f,
		-1.0f, -1.0f, -1.0f,
		-1.0f, -1.0f, -1.0f,
		-1.0f, 1.0f, 1.0f,
		-1.0f, 1.0f, -1.0f,
		1.0f, -1.0f, 1.0f,
		-1.0f, -1.0f, 1.0f,
		-1.0f, -1.0f, -1.0f,
		-1.0f, 1.0f, 1.0f,
		-1.0f, -1.0f, 1.0f,
		1.0f, -1.0f, 1.0f,
		1.0f, 1.0f, 1.0f,
		1.0f, -1.0f, -1.0f,
		1.0f, 1.0f, -1.0f,
		1.0f, -1.0f, -1.0f,
		1.0f, 1.0f, 1.0f,
		1.0f, -1.0f, 1.0f,
		1.0f, 1.0f, 1.0f,
		1.0f, 1.0f, -1.0f,
		-1.0f, 1.0f, -1.0f,
		1.0f, 1.0f, 1.0f,
		-1.0f, 1.0f, -1.0f,
		-1.0f, 1.0f, 1.0f,
		1.0f, 1.0f, 1.0f,
		-1.0f, 1.0f, 1.0f,
		1.0f, -1.0f, 1.0f
	};

	static const GLfloat uv_buffer_data[] = { // Cordenadas UV
		0.000059f, 1.0f - 0.000004f,
		0.000103f, 1.0f - 0.336048f,
		0.335973f, 1.0f - 0.335903f,
		1.000023f, 1.0f - 0.000013f,
		0.667979f, 1.0f - 0.335851f,
		0.999958f, 1.0f - 0.336064f,
		0.667979f, 1.0f - 0.335851f,
		0.336024f, 1.0f - 0.671877f,
		0.667969f, 1.0f - 0.671889f,
		1.000023f, 1.0f - 0.000013f,
		0.668104f, 1.0f - 0.000013f,
		0.667979f, 1.0f - 0.335851f,
		0.000059f, 1.0f - 0.000004f,
		0.335973f, 1.0f - 0.335903f,
		0.336098f, 1.0f - 0.000071f,
		0.667979f, 1.0f - 0.335851f,
		0.335973f, 1.0f - 0.335903f,
		0.336024f, 1.0f - 0.671877f,
		1.000004f, 1.0f - 0.671847f,
		0.999958f, 1.0f - 0.336064f,
		0.667979f, 1.0f - 0.335851f,
		0.668104f, 1.0f - 0.000013f,
		0.335973f, 1.0f - 0.335903f,
		0.667979f, 1.0f - 0.335851f,
		0.335973f, 1.0f - 0.335903f,
		0.668104f, 1.0f - 0.000013f,
		0.336098f, 1.0f - 0.000071f,
		0.000103f, 1.0f - 0.336048f,
		0.000004f, 1.0f - 0.671870f,
		0.336024f, 1.0f - 0.671877f,
		0.000103f, 1.0f - 0.336048f,
		0.336024f, 1.0f - 0.671877f,
		0.335973f, 1.0f - 0.335903f,
		0.667969f, 1.0f - 0.671889f,
		1.000004f, 1.0f - 0.671847f,
		0.667979f, 1.0f - 0.335851f
	};



	vertexBufferID;
	// qué tantos buffers, y donde quiero guardarlo
	glGenBuffers(1, &vertexBufferID);
	glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
	// GLarraybuffer indica que será un buffer que contiene un arreglo
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_buffer_data), vertex_buffer_data, GL_STATIC_DRAW);

	glGenBuffers(1, &uvBufferID);
	glBindBuffer(GL_ARRAY_BUFFER, uvBufferID);
	// GLarraybuffer indica que será un buffer que contiene un arreglo
	glBufferData(GL_ARRAY_BUFFER, sizeof(uv_buffer_data), uv_buffer_data, GL_STATIC_DRAW);

	glClearColor(0.5, 0.5, 0.5, 1.0); // Cambia el color de fondo
	glfwPollEvents(); //checa si hay eventos

	// Activar funciones de profundidad
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS); // Solo rendereamelo si está más adelante de lo que ya está rendereado

	//Ciclo de dibujo
	while (glfwGetKey(window, GLFW_KEY_ESCAPE) !=GLFW_PRESS && !glfwWindowShouldClose(window)){ // si la ventana no está cerrada y no se presiona escape continúa con el ciclo

		dibujar();

	}

	// El siguiente buffer manda cosas al buffer que se "swapea"
	glDeleteBuffers(1, &vertexBufferID); // primero, cuantos buffers queremos borrar, y luego la direccion de memoria de donde lo queremos borrar
	glDeleteShader(programaID); // Recuerda que programaID es la combinación del fragment y vertex Shader
	glDeleteVertexArrays(1, &vertexArrayID);
	glfwTerminate();

	return 0;
}