camera.cpp

Torus3D.rar,BREW平台的3D游戏引擎的一个实例.喜欢的朋友可以下载

// ==========================================================================================================
//
// BREW v2.0+ OPENGLES MICROENGINE
//
// ----------------------------------------
//
// Written by Vander Nunes
//
// ==========================================================================================================

#include "camera.h"


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
CCamera::CCamera(CEngine* pEngine)
{
	m_pEngine = pEngine;
	m_pFrustum = new CFrustum();
	m_pInverseFrustum = new CFrustum();
	Init();
	Setup(1.0f, 500.0f, 1.0f);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
CCamera::~CCamera()
{
	DeletePtr(m_pFrustum);
	DeletePtr(m_pInverseFrustum);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
void CCamera::Init()
{
	VectorSet(m_Position, 0,0,0);
	VectorSet(m_Rotation, 0,0,0);
	VectorSet(m_Direction, 0,0,ITOX(-1));
	UpdateDirection();
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
void CCamera::Setup(float fNear, float fFar, float fFOV)
{
	m_fNear = fNear;
	m_fFar = fFar;
	m_fFOV = fFOV;

	m_ProjMatrix = MatrixProjection(m_fNear, m_fFar, fFOV, m_pEngine->ScreenWidth(), m_pEngine->ScreenHeight());
	m_pFrustum->InitFromProjectionMatrix(m_ProjMatrix);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
void CCamera::TranslateTo(int Px, int Py, int Pz)
{
	VectorSet(m_Position, Px,Py,Pz);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
void CCamera::AddTranslation(int Px, int Py, int Pz)
{
	vec3_t v = { Px, Py, Pz };
	VectorAdd(m_Position, v, m_Position);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
void CCamera::RotateTo(int Rx, int Ry, int Rz)
{
	VectorSet(m_Rotation, Rx,Ry,Rz);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
void CCamera::AddRotation(int Rx, int Ry, int Rz)
{
	vec3_t v = { Rx, Ry, Rz };
	VectorAdd(m_Rotation, v, m_Rotation);

	while (m_Rotation[0] >= ITOX(360)) m_Rotation[0] -= ITOX(360);
	while (m_Rotation[0] < 0) m_Rotation[0] += ITOX(360);

	while (m_Rotation[1] >= ITOX(360)) m_Rotation[1] -= ITOX(360);
	while (m_Rotation[1] < 0) m_Rotation[1] += ITOX(360);

	while (m_Rotation[2] >= ITOX(360)) m_Rotation[2] -= ITOX(360);
	while (m_Rotation[2] < 0) m_Rotation[2] += ITOX(360);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
void CCamera::UpdateDirection(void)
{
	// Update model rotation matrix
	#define DIR_SIZE ITOX(1)

	matrix_t m;
	m = RXMatrix(m_Rotation[0]);
	m = MatrixMultiply(m, RYMatrix(m_Rotation[1]));

	vec3_t v = { 0, 0, DIR_SIZE };
	MatrixMultiplyVector(m, v, m_Direction);

	//
	// update inverse frustum planes
	//

	m = RXMatrix(m_Rotation[0]);
	m = MatrixMultiply(m, RYMatrix(-m_Rotation[1]));
	m = MatrixMultiply(m, RZMatrix(m_Rotation[2]));

	for (byte x=0; x<5; x++)
	{
		vec3_t v;
		MatrixMultiplyVector(m, m_pFrustum->m_Planes[x].vNormal, m_pInverseFrustum->m_Planes[x].vNormal);
		VectorCopy(m_pInverseFrustum->m_Planes[x].vNormal, v);
		m_pInverseFrustum->m_Planes[x].iDist = FPXFP(v[0],-m_Position[0]) + FPXFP(v[1],-m_Position[1]) + FPXFP(v[2],-m_Position[2]);
	}
	//DBGPRINTF("%d %d %d %d  |  %d %d %d %d", m_pFrustum->m_Planes[4].vNormal[0], m_pFrustum->m_Planes[4].vNormal[1], m_pFrustum->m_Planes[4].vNormal[2], m_pFrustum->m_Planes[4].iDist, m_pInverseFrustum->m_Planes[4].vNormal[0], m_pInverseFrustum->m_Planes[4].vNormal[1], m_pInverseFrustum->m_Planes[4].vNormal[2], m_pInverseFrustum->m_Planes[4].iDist);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
boolean CCamera::IsBoxVisible(vec3_t vBBMin, vec3_t vBBMax)
{
	FRUSTUM_RELATION Res = m_pInverseFrustum->BoxRelation(vBBMin, vBBMax);
	return (Res == FRUSTUM_INSIDE || Res == FRUSTUM_INTERSECTING);
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
matrix_t CCamera::ProjectionMatrix()
{
	return m_ProjMatrix;
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
int* CCamera::Position()
{
	return m_Position;
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
int* CCamera::Rotation()
{
	return m_Rotation;
}


// ----------------------------------------------------------------------------------------------------------
//
//
//
// ----------------------------------------------------------------------------------------------------------
int* CCamera::Direction()
{
	return m_Direction;
}