//*****************************************************
//
// PrimeiroPrograma.cpp
// Um programa OpenGL simples que abre uma janela GLUT
// e desenha uma casinha no centro que pode ser 
// transladada. Também permite fazer zoom-in, zoom-out
// e pan.
//
// Isabel H. Manssour e Marcelo Cohen
// 
//*****************************************************

#include <stdlib.h>
#include <GL/glut.h>

// Variáveis que controlam o deslocamento da casinha
GLfloat tx, ty, win, panX, panY; 
// Variávei que armazenam o tamanho da viewport
GLsizei largura, altura;

// Função callback de redesenho da janela de visualização
void Desenha(void)
{
	// Limpa a janela de visualização com a cor branca
	glClearColor(1,1,1,0);
	glClear(GL_COLOR_BUFFER_BIT);

	// Carrega a matriz identidade
	glLoadIdentity();

	// Define a cor de desenho: preto
	glColor3f(0,0,0);
	
	glLineWidth(1); 

	// Desenha os eixos coordenados
	glBegin(GL_LINES);
		glVertex2f(-1,0);
		glVertex2f(1,0);
		glVertex2f(0,-1);
		glVertex2f(0,1);
	glEnd();

	// Define a cor de desenho: vermelho
	glColor3f(1,0,0);
	
	// Desenha uma casinha no centro da janela
	glLineWidth(3); 

	glTranslatef(tx, ty, 0); 
    glBegin(GL_TRIANGLES);
          glColor3f(0.0f, 0.0f, 1.0f);                   
          glVertex2f(-0.2,0.1);
          glColor3f(1.0f, 0.0f, 0.0f);                     
          glVertex2f(0.0,0.22);
          glColor3f(0.0f, 0.0f, 1.0f);                     
          glVertex2f(0.2,0.1);
    glEnd();               
    
    glBegin(GL_LINE_LOOP);
          glVertex2f(-0.2,-0.2);                   
          glVertex2f(-0.2,0.1);
          glVertex2f(0.2,0.1);
          glVertex2f(0.2,-0.2);            
    glEnd();
	
	
	//Executa os comandos OpenGL 
	glFlush();
}

// Função callback chamada para gerenciar eventos de teclas
void Teclado (unsigned char key, int x, int y)
{
	if (key == 27)
		exit(0);

	if (key == 'L' || key == 'l') // Left
		panX += 0.2;
	if (key == 'R' || key == 'r') // Right
		panX -= 0.2;

	if (key == 'T' || key == 't') // Top
		panY -= 0.2;
	if (key == 'B' || key == 'b') // Bottom
		panY += 0.2;

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if (largura <= altura) 
		gluOrtho2D (-win+panX, win+panX, -win*altura/largura+panY, win*altura/largura+panY);
	else 
		gluOrtho2D (-win*largura/altura+panX, win*largura/altura+panX, -win+panY, win+panY);
	glMatrixMode(GL_MODELVIEW);
	glutPostRedisplay();
}

// Função callback chamada para gerenciar eventos do mouse
void GerenciaMouse(int button, int state, int x, int y)
{
    if (button == GLUT_LEFT_BUTTON)
         if (state == GLUT_DOWN) {
			win-=0.05;
         }
    if (button == GLUT_RIGHT_BUTTON)
         if (state == GLUT_DOWN) {
			win+=0.05;
         }
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if (largura <= altura) 
		gluOrtho2D (-win+panX, win+panX, -win*altura/largura+panY, win*altura/largura+panY);
	else 
		gluOrtho2D (-win*largura/altura+panX, win*largura/altura+panX, -win+panY, win+panY);
	glMatrixMode(GL_MODELVIEW);
	glutPostRedisplay();
}

void TeclasEspeciais(int key, int x, int y)
{
    switch (key)
    {
		case GLUT_KEY_UP:	ty += 0.1;
							break; 
    	case GLUT_KEY_DOWN:	ty -= 0.1;
							break; 
    	case GLUT_KEY_LEFT: tx -= 0.1;
							break; 
		case GLUT_KEY_RIGHT:tx += 0.1; 
							break; 
    }
    glutPostRedisplay();
}


// Função callback chamada quando o tamanho da janela é alterado 
void AlteraTamanhoJanela(GLsizei w, GLsizei h)
{ 
	// Evita a divisao por zero
	if(h == 0) h = 1;

	// Atualiza as variáveis
	largura = w;
	altura = h;

	// Especifica as dimensões da Viewport
	glViewport(0, 0, largura, altura);

	// Inicializa o sistema de coordenadas
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	// Estabelece a janela de seleção (esquerda, direita, inferior, 
	// superior) mantendo a proporção com a janela de visualização
	if (largura <= altura) 
		gluOrtho2D (-win+panX, win+panX, -win*altura/largura+panY, win*altura/largura+panY);
	else 
		gluOrtho2D (-win*largura/altura+panX, win*largura/altura+panX, -win+panY, win+panY);

	glMatrixMode(GL_MODELVIEW);
}


// Função responsável por inicializar parâmetros e variáveis
void Inicializa(void)
{
	// Define a janela de visualização 2D
	glMatrixMode(GL_PROJECTION);
	gluOrtho2D(-win,win,-win,win);
	glMatrixMode(GL_MODELVIEW);
	tx = ty = 0;
	win = 1;
	panX = panY = 0;
}

// Programa Principal 
int main(void)
{
	// Define do modo de operação da GLUT
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); 
 
	// Especifica o tamanho inicial em pixels da janela GLUT
	glutInitWindowSize(400,400); 
 
	// Cria a janela passando como argumento o título da mesma
	glutCreateWindow("Casinha");
 
	// Registra a função callback de redesenho da janela de visualização
	glutDisplayFunc(Desenha);

	// Registra a função callback para tratamento das teclas ASCII
	glutKeyboardFunc (Teclado);

	// Registra a função callback para tratamento das teclas especiais
	glutSpecialFunc(TeclasEspeciais); 

	// Registra a função callback para tratamento dos eventos de mouse
	glutMouseFunc(GerenciaMouse);

	glutReshapeFunc(AlteraTamanhoJanela);

	// Chama a função responsável por fazer as inicializações 
	Inicializa();
 
	// Inicia o processamento e aguarda interações do usuário
	glutMainLoop();
 
	return 0;
}