//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements a camera for the 3D view.
//
// $NoKeywords: $
//=============================================================================//

#include <windows.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include "Camera.h"
#include "hammer_mathlib.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

//
// Indices of camera axes.
//
#define CAMERA_RIGHT		0
#define CAMERA_UP			1
#define CAMERA_FORWARD		2
#define CAMERA_ORIGIN		3

#define MIN_PITCH		-90.0f
#define MAX_PITCH		90.0f


static void DBG(char *fmt, ...)
{
    char ach[128];
    va_list va;

    va_start(va, fmt);
    vsprintf(ach, fmt, va);
    va_end(va);
    OutputDebugString(ach);
}


//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
CCamera::CCamera(void)
{
	m_ViewPoint.Init();

	m_fPitch = 0.0;
	m_fRoll = 0.0;
	m_fYaw = 0.0;

	m_fHorizontalFOV = 90;
	m_fNearClip = 1.0;
	m_fFarClip = 5000;

    m_fZoom = 1.0f;
	m_bIsOrthographic = false;

	m_fScaleHorz = m_fScaleVert = 1;
	m_nViewWidth = m_nViewHeight = 100;

	BuildViewMatrix();
	BuildProjMatrix();
}


//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
CCamera::~CCamera(void)
{
}

void CCamera::SetViewPort( int width, int height )
{
	if ( m_nViewWidth != width || m_nViewHeight != height )
	{
		m_nViewWidth = width;
		m_nViewHeight = height;
		BuildProjMatrix();
	}
}

void CCamera::GetViewPort( int &width, int &height )
{
	width = m_nViewWidth;
	height = m_nViewHeight;
}

//-----------------------------------------------------------------------------
// Purpose: Returns the current value of the camera's pitch.
//-----------------------------------------------------------------------------
float CCamera::GetPitch(void)
{
	return(m_fPitch);
}


//-----------------------------------------------------------------------------
// Purpose: Returns the current value of the camera's roll.
//-----------------------------------------------------------------------------
float CCamera::GetRoll(void)
{
	return(m_fRoll);
}


//-----------------------------------------------------------------------------
// Purpose: Returns the current value of the camera's yaw.
//-----------------------------------------------------------------------------
float CCamera::GetYaw(void)
{
	return(m_fYaw);
}


//-----------------------------------------------------------------------------
// Purpose: returns the camera angles
// Output : returns the camera angles
//-----------------------------------------------------------------------------
QAngle CCamera::GetAngles()
{
	return QAngle( m_fPitch, m_fYaw, m_fRoll );
}


//-----------------------------------------------------------------------------
// Purpose: Moves the camera along the camera's right axis.
// Input  : fUnits - World units to move the camera.
//-----------------------------------------------------------------------------
void CCamera::MoveRight(float fUnits)
{
	if (fUnits != 0)
	{
		m_ViewPoint[0] += m_ViewMatrix[CAMERA_RIGHT][0] * fUnits;
		m_ViewPoint[1] += m_ViewMatrix[CAMERA_RIGHT][1] * fUnits;
		m_ViewPoint[2] += m_ViewMatrix[CAMERA_RIGHT][2] * fUnits;
		BuildViewMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Moves the camera along the camera's up axis.
// Input  : fUnits - World units to move the camera.
//-----------------------------------------------------------------------------
void CCamera::MoveUp(float fUnits)
{
	if (fUnits != 0)
	{
		m_ViewPoint[0] += m_ViewMatrix[CAMERA_UP][0] * fUnits;
		m_ViewPoint[1] += m_ViewMatrix[CAMERA_UP][1] * fUnits;
		m_ViewPoint[2] += m_ViewMatrix[CAMERA_UP][2] * fUnits;
		BuildViewMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Moves the camera along the camera's forward axis.
// Input  : fUnits - World units to move the camera.
//-----------------------------------------------------------------------------
void CCamera::MoveForward(float fUnits)
{
	if (fUnits != 0)
	{
		m_ViewPoint[0] -= m_ViewMatrix[CAMERA_FORWARD][0] * fUnits;
		m_ViewPoint[1] -= m_ViewMatrix[CAMERA_FORWARD][1] * fUnits;
		m_ViewPoint[2] -= m_ViewMatrix[CAMERA_FORWARD][2] * fUnits;
		BuildViewMatrix();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Returns the camera's viewpoint.
//-----------------------------------------------------------------------------
void CCamera::GetViewPoint(Vector& ViewPoint) const
{
	ViewPoint = m_ViewPoint;
}

//-----------------------------------------------------------------------------
// Purpose: Returns a vector indicating the camera's forward axis.
//-----------------------------------------------------------------------------
void CCamera::GetViewForward(Vector& ViewForward) const
{
	ViewForward[0] = -m_ViewMatrix[CAMERA_FORWARD][0];
	ViewForward[1] = -m_ViewMatrix[CAMERA_FORWARD][1];
	ViewForward[2] = -m_ViewMatrix[CAMERA_FORWARD][2];
}


//-----------------------------------------------------------------------------
// Purpose: Returns a vector indicating the camera's up axis.
//-----------------------------------------------------------------------------
void CCamera::GetViewUp(Vector& ViewUp) const
{
	ViewUp[0] = m_ViewMatrix[CAMERA_UP][0];
	ViewUp[1] = m_ViewMatrix[CAMERA_UP][1];
	ViewUp[2] = m_ViewMatrix[CAMERA_UP][2];
}


//-----------------------------------------------------------------------------
// Purpose: Returns a vector indicating the camera's right axis.
//-----------------------------------------------------------------------------
void CCamera::GetViewRight(Vector& ViewRight) const
{
	ViewRight[0] = m_ViewMatrix[CAMERA_RIGHT][0];
	ViewRight[1] = m_ViewMatrix[CAMERA_RIGHT][1];
	ViewRight[2] = m_ViewMatrix[CAMERA_RIGHT][2];
}

//-----------------------------------------------------------------------------
// Purpose: Returns the horizontal field of view in degrees.
//-----------------------------------------------------------------------------
float CCamera::GetFOV(void)
{
	return(m_fHorizontalFOV);
}


//-----------------------------------------------------------------------------
// Purpose: Returns the distance from the camera to the near clipping plane in world units.
//-----------------------------------------------------------------------------
float CCamera::GetNearClip(void)
{
	return(m_fNearClip);
}


//-----------------------------------------------------------------------------
// Purpose: Returns the distance from the camera to the far clipping plane in world units.
//-----------------------------------------------------------------------------
float CCamera::GetFarClip(void)
{
	return(m_fFarClip);
}

//-----------------------------------------------------------------------------
// Purpose: Sets up fields of view & clip plane distances for the view frustum.
// Input  : fHorizontalFOV - 
//			fVerticalFOV - 
//			fNearClip - 
//			fFarClip - 
//-----------------------------------------------------------------------------
void CCamera::SetPerspective(float fHorizontalFOV, float fNearClip, float fFarClip)
{
	m_bIsOrthographic = false;
	m_fHorizontalFOV = fHorizontalFOV;
	m_fNearClip = fNearClip;
	m_fFarClip = fFarClip;
	BuildProjMatrix();
}

void CCamera::SetOrthographic(float fZoom, float fNearClip, float fFarClip)
{
	m_fZoom = fZoom;
	m_fNearClip = fNearClip;
	m_fFarClip = fFarClip;
	m_bIsOrthographic = true;
	BuildProjMatrix();
}

void CCamera::GetFrustumPlanes( Vector4D Planes[6] )
{
	// TODO check for FrustumPlanesFromMatrix, maybe we can use that

	Vector ViewForward;
	GetViewForward(ViewForward);

	VMatrix CameraMatrix = m_ProjMatrix * m_ViewMatrix;

	//
	// Now the plane coefficients can be pulled directly out of the the camera
	// matrix as follows:
	//
	// Right :  first_column  - fourth_column
	// Left  : -first_column  - fourth_column
	// Top   :  second_column - fourth_column
	// Bottom: -second_column - fourth_column
	// Front : -third_column  - fourth_column
	// Back  :  third_column  + fourth_column
	//
	// dvs: My plane constants should be coming directly from the matrices,
	//		but they aren't (for some reason). Instead I calculate the plane
	//		constants myself. Sigh.
	//
	Planes[0][0] = CameraMatrix[0][0] - CameraMatrix[3][0];
	Planes[0][1] = CameraMatrix[0][1] - CameraMatrix[3][1];
	Planes[0][2] = CameraMatrix[0][2] - CameraMatrix[3][2];
	VectorNormalize(Planes[0].AsVector3D());
	Planes[0][3] = DotProduct(m_ViewPoint, Planes[0].AsVector3D());

	Planes[1][0] = -CameraMatrix[0][0] - CameraMatrix[3][0];
	Planes[1][1] = -CameraMatrix[0][1] - CameraMatrix[3][1];
	Planes[1][2] = -CameraMatrix[0][2] - CameraMatrix[3][2];
	VectorNormalize(Planes[1].AsVector3D());
	Planes[1][3] = DotProduct(m_ViewPoint, Planes[1].AsVector3D());

	Planes[2][0] = CameraMatrix[1][0] - CameraMatrix[3][0];
	Planes[2][1] = CameraMatrix[1][1] - CameraMatrix[3][1];
	Planes[2][2] = CameraMatrix[1][2] - CameraMatrix[3][2];
	VectorNormalize(Planes[2].AsVector3D());
	Planes[2][3] = DotProduct(m_ViewPoint, Planes[2].AsVector3D());

	Planes[3][0] = -CameraMatrix[1][0] - CameraMatrix[3][0];
	Planes[3][1] = -CameraMatrix[1][1] - CameraMatrix[3][1];
	Planes[3][2] = -CameraMatrix[1][2] - CameraMatrix[3][2];
	VectorNormalize(Planes[3].AsVector3D());
	Planes[3][3] = DotProduct(m_ViewPoint, Planes[3].AsVector3D());

	Planes[4][0] = -CameraMatrix[2][0] - CameraMatrix[3][0];
	Planes[4][1] = -CameraMatrix[2][1] - CameraMatrix[3][1];
	Planes[4][2] = -CameraMatrix[2][2] - CameraMatrix[3][2];
	VectorNormalize(Planes[4].AsVector3D());
	Planes[4][3] = DotProduct(m_ViewPoint + ViewForward * m_fNearClip, Planes[4].AsVector3D());

	Planes[5][0] = CameraMatrix[2][0] + CameraMatrix[3][0];
	Planes[5][1] = CameraMatrix[2][1] + CameraMatrix[3][1];
	Planes[5][2] = CameraMatrix[2][2] + CameraMatrix[3][2];
	VectorNormalize(Planes[5].AsVector3D());
	Planes[5][3] = DotProduct(m_ViewPoint + ViewForward * m_fFarClip, Planes[5].AsVector3D());
}

bool CCamera::IsOrthographic()
{
	return m_bIsOrthographic;
}

void CCamera::BuildProjMatrix()
{
	memset( &m_ProjMatrix,0,sizeof(m_ProjMatrix) );
	VMatrix &m = m_ProjMatrix;

	if ( m_bIsOrthographic )
	{
		// same as D3DXMatrixOrthoRH
		float w = (float)m_nViewWidth / m_fZoom;
		float h = (float)m_nViewHeight / m_fZoom;
	
		m[0][0] = 2/w;
		m[1][1] = 2/h;

		m[2][2] = 1/(m_fNearClip-m_fFarClip);
		m[2][3] = m_fNearClip/(m_fNearClip-m_fFarClip);

		m[3][3] = 1;
	}
	else
	{
		// same as D3DXMatrixPerspectiveRH
		float w = 2 * m_fNearClip * tan( m_fHorizontalFOV * M_PI / 360.0 );
		float h = ( w * float(m_nViewHeight) ) / float(m_nViewWidth);

		m[0][0] = 2*m_fNearClip/w;
		m[1][1] = 2*m_fNearClip/h;

		m[2][2] = m_fFarClip/(m_fNearClip-m_fFarClip);
		m[2][3] = (m_fNearClip*m_fFarClip)/(m_fNearClip-m_fFarClip);

		m[3][2] = -1;
	}

	m_ViewProjMatrix = m_ProjMatrix * m_ViewMatrix;
	m_ViewProjMatrix.InverseGeneral( m_InvViewProjMatrix );
}


//-----------------------------------------------------------------------------
// Purpose: Sets the distance from the camera to the near clipping plane in world units.
//-----------------------------------------------------------------------------
void CCamera::SetNearClip(float fNearClip)
{
	if ( m_fNearClip != fNearClip )
	{
		m_fNearClip = fNearClip;
		BuildProjMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the distance from the camera to the far clipping plane in world units.
//-----------------------------------------------------------------------------
void CCamera::SetFarClip(float fFarClip)
{
	if ( m_fFarClip != fFarClip )
	{
		m_fFarClip = fFarClip;
		BuildProjMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the pitch in degrees, from [MIN_PITCH..MAX_PITCH]
//-----------------------------------------------------------------------------
void CCamera::SetPitch(float fDegrees)
{
	if (m_fPitch != fDegrees)
	{
		m_fPitch = fDegrees;

		if (m_fPitch > MAX_PITCH)
		{
			m_fPitch = MAX_PITCH;
		}
		else if (m_fPitch < MIN_PITCH)
		{
			m_fPitch = MIN_PITCH;
		}
		BuildViewMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the roll in degrees, from [0..360)
//-----------------------------------------------------------------------------
void CCamera::SetRoll(float fDegrees)
{
	while (fDegrees >= 360)
	{
		fDegrees -= 360;
	}

	while (fDegrees < 0)
	{
		fDegrees += 360;
	}

	if (m_fRoll != fDegrees)
	{
		m_fRoll = fDegrees;
		BuildViewMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the yaw in degrees, from [0..360)
//-----------------------------------------------------------------------------
void CCamera::SetYaw(float fDegrees)
{
	while (fDegrees >= 360)
	{
		fDegrees -= 360;
	}

	while (fDegrees < 0)
	{
		fDegrees += 360;
	}

	if (m_fYaw != fDegrees)
	{
		m_fYaw = fDegrees;
		BuildViewMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the view point.
//-----------------------------------------------------------------------------
void CCamera::SetViewPoint(const Vector &ViewPoint)
{
	if ( m_ViewPoint != ViewPoint )
	{
		m_ViewPoint = ViewPoint;
		BuildViewMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the camera target, rebuilding the view matrix.
// Input  : ViewTarget - the point in world space that the camera should look at.
//-----------------------------------------------------------------------------
void CCamera::SetViewTarget(const Vector &ViewTarget)
{
	Vector ViewOrigin;
	Vector ViewForward;

	GetViewPoint( ViewOrigin );

	VectorSubtract(ViewTarget, ViewOrigin, ViewForward);
	VectorNormalize(ViewForward);

	//
	// Ideally we could replace the math below with standard VectorAngles stuff, but Hammer
	// camera matrices use a different convention from QAngle (sadly).
	//
	float fYaw = RAD2DEG(atan2(ViewForward[0], ViewForward[1]));
	SetYaw(fYaw);

	float fPitch = -RAD2DEG(asin(ViewForward[2]));
	SetPitch(fPitch);
}

//-----------------------------------------------------------------------------
// Purpose: Move the camera along a worldspace vector.
//-----------------------------------------------------------------------------
void CCamera::Move(Vector &vDelta)
{
	m_ViewPoint += vDelta;
	BuildViewMatrix();
}


//-----------------------------------------------------------------------------
// Purpose: Pitches the camera forward axis toward the camera's down axis a
//			given number of degrees.
//-----------------------------------------------------------------------------
void CCamera::Pitch(float fDegrees)
{
	if (fDegrees != 0)
	{
		float fPitch = GetPitch();
		fPitch += fDegrees;
		SetPitch(fPitch);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Rolls the camera's right axis toward the camera's up axis a given
//			number of degrees.
//-----------------------------------------------------------------------------
void CCamera::Roll(float fDegrees)
{
	if (fDegrees != 0)
	{
		float fRoll = GetRoll();
		fRoll += fDegrees;
		SetRoll(fRoll);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Yaws the camera's forward axis toward the camera's right axis a
//			given number of degrees.
//-----------------------------------------------------------------------------
void CCamera::Yaw(float fDegrees)
{
	if (fDegrees != 0)
	{
		float fYaw = GetYaw();
		fYaw += fDegrees;
		SetYaw(fYaw);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Loads the given matrix with an identity matrix.
// Input  : Matrix - 4 x 4 matrix to be loaded with the identity matrix.
//-----------------------------------------------------------------------------
void CCamera::CameraIdentityMatrix(VMatrix& Matrix)
{
	// This function produces a transform which transforms from
	// material system camera space to quake camera space

	// Camera right axis lies along the world X axis.
	Matrix[CAMERA_RIGHT][0] = 1;
	Matrix[CAMERA_RIGHT][1] = 0;
	Matrix[CAMERA_RIGHT][2] = 0;
	Matrix[CAMERA_RIGHT][3] = 0;

	// Camera up axis lies along the world Z axis.
	Matrix[CAMERA_UP][0] = 0;
	Matrix[CAMERA_UP][1] = 0;
	Matrix[CAMERA_UP][2] = 1;
	Matrix[CAMERA_UP][3] = 0;

	// Camera forward axis lies along the negative world Y axis.
	Matrix[CAMERA_FORWARD][0] = 0;
	Matrix[CAMERA_FORWARD][1] = -1;
	Matrix[CAMERA_FORWARD][2] = 0;
	Matrix[CAMERA_FORWARD][3] = 0;

	Matrix[CAMERA_ORIGIN][0] = 0;
	Matrix[CAMERA_ORIGIN][1] = 0;
	Matrix[CAMERA_ORIGIN][2] = 0;
	Matrix[CAMERA_ORIGIN][3] = 1;
}

//-----------------------------------------------------------------------------
// Purpose: Generates a view matrix based on our current yaw, pitch, and roll.
//			The view matrix does not consider FOV or clip plane distances.
//-----------------------------------------------------------------------------
void CCamera::BuildViewMatrix()
{
	// The camera transformation is produced by multiplying roll * yaw * pitch.
	// This will transform a point from world space into quake camera space, 
	// which is exactly what we want for our view matrix. However, quake
	// camera space isn't the same as material system camera space, so
	// we're going to have to apply a transformation that goes from quake
	// camera space to material system camera space.
	
	CameraIdentityMatrix( m_ViewMatrix );

	RotateAroundAxis(m_ViewMatrix, m_fPitch, 0 );
	RotateAroundAxis(m_ViewMatrix, m_fRoll, 1);
	RotateAroundAxis(m_ViewMatrix, m_fYaw, 2);

	// Translate the viewpoint to the world origin.
	VMatrix TempMatrix;
	TempMatrix.Identity();
	TempMatrix.SetTranslation( -m_ViewPoint );

	m_ViewMatrix = m_ViewMatrix * TempMatrix;

	m_ViewProjMatrix = m_ProjMatrix * m_ViewMatrix;
	m_ViewProjMatrix.InverseGeneral( m_InvViewProjMatrix );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : Matrix - 
//-----------------------------------------------------------------------------
void CCamera::GetViewMatrix(VMatrix& Matrix)
{
	Matrix = m_ViewMatrix;

}

void CCamera::GetProjMatrix(VMatrix& Matrix)
{
	Matrix = m_ProjMatrix;
}


//-----------------------------------------------------------------------------
// Purpose: Sets the view matrix of the current projection
// Output : Matrix - the matrix to store the current projection matrix
//-----------------------------------------------------------------------------
void CCamera::GetViewProjMatrix( VMatrix &Matrix )
{
	Matrix = m_ViewProjMatrix;
}


//-----------------------------------------------------------------------------
// Purpose: to set the zoom in the orthographic gl view
//   Input: fScale - the zoom scale
//-----------------------------------------------------------------------------
void CCamera::SetZoom( float fScale )
{
	if ( m_fZoom != fScale )
	{
	    m_fZoom = fScale;
		BuildProjMatrix();
	}
}


//-----------------------------------------------------------------------------
// Purpose: to accumulate the zoom in the orthographic gl view
//   Input: fScale - the zoom scale
//-----------------------------------------------------------------------------
void CCamera::Zoom( float fScale )
{
    m_fZoom += fScale;

    // don't zoom negative 
    if( m_fZoom < 0.00001f )
        m_fZoom = 0.00001f;
}


//-----------------------------------------------------------------------------
// Purpose: to get the zoom in the orthographic gl view
//  Output: return the zoom scale
//-----------------------------------------------------------------------------
float CCamera::GetZoom( void )
{
    return m_fZoom;
}

void CCamera::WorldToView( const Vector& vWorld, Vector2D &vView )
{
	Vector vView3D;

	Vector3DMultiplyPositionProjective( m_ViewProjMatrix, vWorld, vView3D );

	// NOTE: The negative sign on y is because wc wants to think about screen
	// coordinates in a different way than the material system
	vView.x = 0.5 * (vView3D.x + 1.0) * m_nViewWidth;
	vView.y = 0.5 * (-vView3D.y + 1.0) * m_nViewHeight;
}

void CCamera::ViewToWorld( const Vector2D &vView, Vector& vWorld)
{	
	Vector vView3D;

	vView3D.x = 2.0 * vView.x / m_nViewWidth - 1;
	vView3D.y = -2.0 * vView.y / m_nViewHeight + 1;
	vView3D.z = 0;

	Vector3DMultiplyPositionProjective( m_InvViewProjMatrix, vView3D, vWorld );
}

void CCamera::BuildRay( const Vector2D &vView, Vector& vStart, Vector& vEnd )
{
	// Find the point they clicked on in world coordinates. It lies on the near
	// clipping plane.
	Vector vClickPoint;
	ViewToWorld(vView, vClickPoint );

	// Build a ray from the viewpoint through the point on the near clipping plane.
	Vector vRay = vClickPoint - m_ViewPoint;
	VectorNormalize( vRay );
	
	vStart = m_ViewPoint;
	vEnd = vStart + vRay * 99999;
}