/**
*******************************************************************************

  @file /gui/engine/Camera.cpp
  @brief Kamera


  @author Vajicek
  @version 0.1
 
******************************************************************************/
#include <GL/gl.h>
#include <GL/glu.h>
//
#include "gui/engine/Camera.h"
#include "common/Log.h"
#include "gui/engine/Scene.h"
#include "gui/GUI.h"

namespace gui{

void TCamera::calculateCamVectors(){
	P4F pos;
	//
	SETP4(pos,0,0,0,1);
	ApplyVectorMX4(pos.p,mx4Pos,p4fPos.p);
	SETP4(pos,0,0,-1,1);
	ApplyVectorMX4(pos.p,mx4Pos,p4fDir.p);
	SETP4(pos,0,1,0,1);
	ApplyVectorMX4(pos.p,mx4Pos,p4fUp.p);
	//
	SubV3(p4fDir.p,p4fPos.p);
	SubV3(p4fUp.p,p4fPos.p);
	//
}

void TCamera::pushLocation()
{
  int min = 0;
  for(  std::vector<TCameraLocation*>::iterator it = locations.begin();
        it != locations.end();
        it++)
  {
    if( min < (*it)->id )
      min = (*it)->id;
  }
  storeLocation(min+1);
}

void TCamera::storeLocation(int id)
{
  TCameraLocation* loc = NULL;
  //
  for(  std::vector<TCameraLocation*>::iterator it = locations.begin();
        it != locations.end();
        it++)
  {
    if((*it)->id == id){
      loc = (*it);
      break;
    }
  }
  if(!loc)
    loc = (TCameraLocation*)KMemAlloc(sizeof(TCameraLocation));
  //
  loc->id = id;
  CopyV4(loc->p4fPos.p, p4fPos.p);
  CopyV4(loc->p4fDir.p, p4fDir.p);
  CopyV4(loc->p4fUp.p, p4fUp.p);
  locations.push_back(loc);
}

void TCamera::recallLocation(int id)
{
  TCameraLocation* loc = NULL;
  //
  for(  std::vector<TCameraLocation*>::iterator it = locations.begin();
        it != locations.end();
        it++)
  {
    if((*it)->id == id){
      loc = (*it);
      CopyV4(p4fPos.p, loc->p4fPos.p);
      CopyV4(p4fDir.p, loc->p4fDir.p);
      CopyV4(p4fUp.p, loc->p4fUp.p);
      break;
    }
  }
}

void TCamera::clearLocations()
{
  for(  std::vector<TCameraLocation*>::iterator it = locations.begin();
        it != locations.end();
        it++)
    KMemFree((*it));
}

void TCamera::deleteLocation(int id)
{
  TCameraLocation* loc = NULL;
  //
  for(  std::vector<TCameraLocation*>::iterator it = locations.begin();
        it != locations.end();
        it++)
  {
    if((*it)->id == id){
      locations.erase(it);
      KMemFree((*it));
      break;
    }
  }
}

void TCamera::positionUpdated(){
  TSceneObject::positionUpdated();
	calculateCamVectors();
  CopyV4toV3(aabbCenter.p, p4fPos.p);
}

void TCamera::moveForward(float step)
{
  MX4 trm,m;
  SetTransMX4(trm,0,0,step);
  MulMatrixMX4(m,mx4Pos,trm);
  //
  CopyMX4(mx4Pos,m);
  //
  positionUpdated();
}

void TCamera::moveBackward(float step)
{
	moveForward(-step);
}

void TCamera::rotateLeft(float ang)
{
	P3F up;
	QUATER q;
	MX4 mr,m;
	//
	CopyV4toV3(up.p,p4fUp.p);
	//
	AATOQ(&up,ang,&q);
	QTOMX4(&q,mr);
	//
	MulMatrixMX4(m,mx4Pos,mr);
	//
	CopyMX4(mx4Pos,m);
  positionUpdated();
}

void TCamera::rotateRight(float ang)
{
	rotateLeft(-ang);
}


void TCamera::initCam(){
}

void TCamera::setCam(){
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(fViewAngle,fRatio,fNear,fFar);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
  //
	gluLookAt(p4fPos.x,p4fPos.y,p4fPos.z,
				    p4fDir.x+p4fPos.x,p4fDir.y+p4fPos.y,p4fDir.z+p4fPos.z,
				    p4fUp.x,p4fUp.y,p4fUp.z);
  //
  positionUpdated();
}

void TCamera::setupPerspective(float av,float ar,float n,float f){
	fViewAngle=av;
	fRatio=ar;
	fNear=n;
	fFar=f;
}

TCamera::TCamera(float av, float ar, float n, float f){
	setupPerspective(av, ar, n, f);
	SetIdentityMX4(mx4Pos);
  positionUpdated();
}

void TCamera::calculateMatrix(){
  P3F bn;
  P3F up;
  P3F dir;
  //
  VectMulV3(bn.p, p4fDir.p, p4fUp.p);
  VectMulV3(up.p, bn.p, p4fDir.p);
  CopyV3(dir.p, p4fDir.p);
  //
  NormalizeV3(bn.p);
  NormalizeV3(up.p);
  NormalizeV3(dir.p);
  //
  SetMX4( mx4Pos,
          bn.x,     bn.y,     bn.z,     0,
          up.x,     up.y,     up.z,     0,
          -dir.x, -dir.y, -dir.z, 0,
          p4fPos.x, p4fPos.y, p4fPos.z, 1);
  //
}

void TCamera::lookAt( float eyex, float eyey, float eyez, 
                      float centerx, float centery, float centerz, 
                      float upx, float upy, float upz)
{
  P4F bn;
  //
  SETV4(p4fPos.p, eyex, eyey, eyez, 1);
  SETV4(p4fDir.p, centerx-eyex, centery-eyey, centerz-eyez, 1);
  SETV4(p4fUp.p , upx, upy, upz, 1);
  //
  NormalizeV3(p4fDir.p);
  VectMulV3(bn.p, p4fUp.p, p4fDir.p);
  VectMulV3(p4fUp.p, p4fDir.p, bn.p);
  NormalizeV3(p4fUp.p);
  //
  calculateMatrix();
}

void TCamera::getFrustum(TFrustum *fr)
{
	P3F temp;

	CopyV4toV3(fr->dir.p, p4fDir.p);
	NormalizeV3(fr->dir.p);
	CopyV4toV3(fr->pos.p, p4fPos.p);

	// fr->up = up - <dir, up> dir / <dir, dir>
	CopyV4toV3(fr->up.p, p4fUp.p);
	float co = ScalMulV3(fr->dir.p, fr->up.p);
	CopyV3(temp.p, fr->dir.p);
	MulV3(temp.p, co);
	SubV3(fr->up.p, temp.p);

	// up = up/|up|*sin(dViewAngle/2)
	float alfa;
	alfa = (float)Deg2Rad(fViewAngle/2.0f);
	NormalizeV3(fr->up.p);
	MulV3(fr->up.p, tan(alfa));

	// down = -up
	CopyV3(fr->down.p,fr->up.p);
	MulV3(fr->down.p, (-1));

	// left = up x dir
	VectMulV3(fr->left.p, fr->up.p, fr->dir.p);
	NormalizeV3(fr->left.p);
	MulV3(fr->left.p, (tan(alfa)*fRatio));

	// right = -left
	CopyV3(fr->right.p,fr->left.p);
	MulV3(fr->right.p, (-1));

	// nastaveni orezavacich ploch
	fr->near_clip = fNear;
	fr->far_clip = fFar;

	fr->calculateAABB();
  fr->calculatePlanes();
}

void TCamera::getViewMatrix(MX4 m){
	glMatrixMode(GL_MODELVIEW);
  glPushMatrix();  
	glLoadIdentity();
	gluLookAt(p4fPos.x,p4fPos.y,p4fPos.z,
				    p4fDir.x+p4fPos.x,p4fDir.y+p4fPos.y,p4fDir.z+p4fPos.z,
				    p4fUp.x,p4fUp.y,p4fUp.z);
	glGetFloatv(GL_MODELVIEW_MATRIX,m);
  glPopMatrix();
}

void TCamera::getProjectionMatrix(MX4 m){
	glMatrixMode(GL_PROJECTION);
  glPushMatrix();  
	glLoadIdentity();
	gluPerspective(fViewAngle,fRatio,fNear,fFar);
	glGetFloatv(GL_PROJECTION_MATRIX,m);
  glPopMatrix();
}



//DUMP
////////////////////////////////////////////////////////////////////////////////

void TCamera::dumpModelMatrix(){
	double m[16];

	glGetDoublev(GL_MODELVIEW_MATRIX,m);

	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
			GLOBALLOG("%8.3f",m[j*4+i]);
		}
		GLOBALLOG("\n");
	}

}

void TCamera::dumpProjectionMatrix(){
	double m[16];

	glGetDoublev(GL_PROJECTION_MATRIX,m);

	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
			GLOBALLOG("%8.3f",m[j*4+i]);
		}
		GLOBALLOG("\n");
	}
}

}//namespace
/*****************************************************************************/