// **********************************************************************
//	MultipleScreen1.cpp   --   Exemplo de multiplas telas em OpenGL
//
//	Autor: Márcio Serolli Pinho
//	Email: pinho@inf.pucrs.br		
//
// **********************************************************************

#include <windows.h>
#include <stdio.h>
#include <math.h>

#include <gl\gl.h>
#include <gl\glu.h>
#include <glut.h>


float xrot;
float yrot;
float zrot;
float ratio;
float ViewAngle = 90;
double ConvRad;
float ObsX=0;
typedef struct
{
	unsigned X, Y, TamX, TamY;
	int JanId;
} TTile;


int Tiles[9];

int jan1, jan2, jan3;

// **********************************************************************
//  void RemoveBorder(int janId)
//
// **********************************************************************
void RemoveBorder(int janId)
{
	LONG style;
	HWND janela;
	char aux[50];

	sprintf(aux, "TCG - Janela %d", janId);
	janela = FindWindow(NULL, aux);

	style =   WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS 
             | WS_CLIPCHILDREN;

	SetWindowLong (janela, GWL_STYLE, style );

}

// **********************************************************************
//  void DefineLuz(void)
//
// **********************************************************************
void DefineLuz(void)
{
  GLfloat LuzAmbiente[]   = {0.24725f, 0.1995f, 0.07f } ;
  GLfloat LuzDifusa[]   = {0.75164f, 0.60648f, 0.22648f, 1.0f };
  GLfloat LuzEspecular[] = {0.626281f, 0.555802f, 0.366065f, 1.0f };
  GLfloat PosicaoLuz0[]  = {3.0f, 3.0f, 0.0f, 1.0f };
  GLfloat PosicaoLuz1[]  = {-3.0f, -3.0f, 0.0f, 1.0f };
  GLfloat Especularidade[] = {1.0f, 1.0f, 1.0f, 1.0f };

   // Habilita o uso de iluminação
  glEnable(GL_LIGHTING);

  // Ativa o uso da luz ambiente
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LuzAmbiente);
  // Define os parametros da Luz número Zero
  glLightfv(GL_LIGHT0, GL_AMBIENT, LuzAmbiente);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, LuzDifusa  );
  glLightfv(GL_LIGHT0, GL_SPECULAR, LuzEspecular  );
  glLightfv(GL_LIGHT0, GL_POSITION, PosicaoLuz1 );
  glEnable(GL_LIGHT0);

  // Ativa o "Color Tracking"
  glEnable(GL_COLOR_MATERIAL);

  // Define a reflectancia do material
  glMaterialfv(GL_FRONT,GL_SPECULAR, Especularidade);

  // Define a concentração do brilho.
  // Quanto maior o valor do Segundo parametro, mais
  // concentrado será o brilho. (Valores válidos: de 0 a 128)
  glMateriali(GL_FRONT,GL_SHININESS,20);

}


// **********************************************************************
//  void init(void)
//		Inicializa os parâmetros globais de OpenGL
//
// **********************************************************************
void init(void)
{
	glShadeModel(GL_SMOOTH);							// Enable Smooth Shading
	glClearColor(1.0f, 1.0f, 1.0f, 0.0f);				// Black Background
	glEnable(GL_DEPTH_TEST); // habilita ZBuffer
	
}
// **********************************************************************
//  void SetObs()
//
//
// **********************************************************************
void SetObs()
{
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(ObsX, 0, 5,
		      ObsX,0,0,
			  0.0f,1.0f,0.0f);
}
// **********************************************************************
//  void SetViewFrustum()
//  
//
// **********************************************************************
void SetViewFrustum()
{
	float Near, left, right, TileWidth; 
	float ViewAngleRad;

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	ViewAngleRad = ViewAngle * 3.14f/180;

	Near = 1;
	left = -Near * tan(ViewAngleRad/2);
	right = -left;
	TileWidth =  (right - left)/3;

	if (glutGetWindow() == jan1)
	{
		glFrustum(left, left+TileWidth, left, right, Near, 100);
	}
	if (glutGetWindow() == jan2)
	{
		glFrustum(left+TileWidth, left+TileWidth*2,left,right, Near, 100);
	}
	if (glutGetWindow() == jan3)
	{
		glFrustum(left+TileWidth*2, left+TileWidth*3,left,right, Near, 100);
	}
	glMatrixMode(GL_MODELVIEW);

	SetObs();
}

// **********************************************************************
//  void reshape( int w, int h )
//		trata o redimensionamento da janela OpenGL
//
// **********************************************************************
void reshape( int w, int h )
{

	if(h == 0)
		h = 1;

	ratio = 1.0f * w / h;

	// Reset the coordinate system before modifying
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	
	// Set the viewport to be the entire window
    glViewport(0, 0, w, h);

	// Set the clipping volume
	SetViewFrustum();
}
// **********************************************************************
//  void DrawCube()
//
//
// **********************************************************************
void DrawCube()
{

	glBegin ( GL_QUADS );
		// Front Face
		glColor3f(1,1,0);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		// Back Face
		glColor3f(0,0,1);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		// Top Face
		glColor3f(1,0,1);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		// Bottom Face
		glColor3f(1,1,1);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glVertex3f(-1.0f, -1.0f, 1.0f);
		// Right face
		glColor3f(0,0.4f,0);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		// Left Face
		glColor3f(1,0,0);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
	glEnd();

}
// **********************************************************************
//  void display( void )
//
//
// **********************************************************************
void display( void )
{
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	DefineLuz();
	glLoadIdentity ( );

	SetObs();

	glPushMatrix();
		glTranslatef ( -1.0, 0.0, -5.0 );
		glRotatef ( xrot, 1.0, 0.0, 0.0 );
		glRotatef ( yrot, 0.0, 1.0, 0.0 );
		glRotatef ( zrot, 0.0, 0.0, 1.0 );
		DrawCube();
	glPopMatrix();
	glPushMatrix();
		glTranslatef ( +1.0f, 0.0, -5.0 );
		glRotatef ( xrot, 1.0, 0.0, 0.0 );
		glRotatef ( yrot, 0.0, 1.0, 0.0 );
		glRotatef ( -zrot, 0.0, 0.0, 1.0 );
		DrawCube();
	
	glPopMatrix();
	if (glutGetWindow() == jan3)
	{
		xrot+=1.0f;
		yrot+=0.6f;
		zrot+=0.4f;
	}
	glutSwapBuffers();
}
// **********************************************************************
//  void RefreshAll()
//
//
// **********************************************************************
void RefreshAll()
{
	glutSetWindow (jan1);
	SetViewFrustum();
	glutPostRedisplay();
	
	glutSetWindow (jan2);
	SetViewFrustum();
	glutPostRedisplay();

	glutSetWindow (jan3);
	SetViewFrustum();
	glutPostRedisplay();

}
// **********************************************************************
//  void keyboard ( unsigned char key, int x, int y )
//
//
// **********************************************************************
void keyboard ( unsigned char key, int x, int y )  
{
	switch ( key ) 
	{
    case 27:        
		exit ( 0 ); 
		break;      
	case 'a':
		ViewAngle +=2;
		if (ViewAngle > 178)
			ViewAngle = 178;
		break;
	case 's':
		ViewAngle -=2;
		if (ViewAngle < 3 )
			ViewAngle = 3;
		break;
	case 'z':
		ObsX -=0.5f;
		break;
	case 'x':
		ObsX +=0.5f;
		break;
    default:
      break;
  }
printf("Viewing angle %f\n", ViewAngle);
}

// **********************************************************************
//  void arrow_keys ( int a_keys, int x, int y )  
//
//
// **********************************************************************
void arrow_keys ( int a_keys, int x, int y )  
{
	switch ( a_keys ) 
	{
		case GLUT_KEY_UP:     // When Up Arrow Is Pressed...
			glutFullScreen ( ); // Go Into Full Screen Mode
			break;
	    case GLUT_KEY_DOWN:               // When Down Arrow Is Pressed...
			glutInitWindowSize  ( 700, 500 ); 
			break;
		default:
			break;
	}
}

void InitCallbacks(void)
{
	glutDisplayFunc ( display );  
	glutReshapeFunc ( reshape );
	glutKeyboardFunc ( keyboard );
	glutSpecialFunc ( arrow_keys );

}
// **********************************************************************
//  void main ( int argc, char** argv )
//
//
// **********************************************************************
void main ( int argc, char** argv )   
{
	glutInit            ( &argc, argv ); 
	glutInitDisplayMode ( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA ); 


	int Larg=250;
	ConvRad =  (2.0 * asin(1)) / 180.0;
	glutInitWindowPosition (0,100);
	glutInitWindowSize  ( Larg, Larg); 
	jan1 = glutCreateWindow ( "TCG - Janela 1"); 

	glutInitWindowPosition (Larg,100);
	glutInitWindowSize ( Larg, Larg ); 
	jan2 = glutCreateWindow ("TCG - Janela 2"); 

	glutInitWindowPosition (Larg*2,100);
	glutInitWindowSize ( Larg, Larg); 
	jan3 = glutCreateWindow ("TCG - Janela 3"); 

	glutSetWindow(jan1);
	InitCallbacks();
	init ();

	glutSetWindow(jan2);
	InitCallbacks();
	init ();

	glutSetWindow(jan3);
	InitCallbacks();
	init ();

	glutIdleFunc ( RefreshAll );	
		
	//RemoveBorder(1);
	//RemoveBorder(2);
	//RemoveBorder(3);
	glutMainLoop ( );          
}