c3dbase.cpp

S60 3D游戏引擎开发案例 S60 3D游戏引擎开发案例

   /*
============================================================================
    * Name : C3DBase.cpp
    * Part of : Example3D
    * Description : Definition of C3DBase
    * Copyright (c) 2007 Nokia Corporation
============================================================================
    */

// INCLUDES
#include "C3DBase.h"
#include <e32math.h>
#include <f32file.h>

// MEMBER FUNCTIONS

C3DBase* C3DBase::NewL( const TSize& aScreenSize )
	{
	C3DBase* self = new( ELeave )C3DBase( aScreenSize );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

C3DBase::~C3DBase()
	{
	delete[] iCos;
	delete[] iSin;
	}

C3DBase::C3DBase( const TSize& aScreenSize )
	: iScreenSize( aScreenSize )
	{
	}

void C3DBase::ConstructL()
	{
	//
	// generate sin & cos tables
	//
	iCos = new( ELeave )TInt16[ KSinTableSize ];
	iSin = new( ELeave )TInt16[ KSinTableSize ];

	TInt max = 1 << KShift;
	TInt i;
	for( i=0; i<KSinTableSize; i++ )
		{
		TReal r;
		Math::Cos( r, KPi * i / (KSinTableSize/2) );
		r *= max;
		Math::Int( iCos[ i ], r );
		Math::Sin( r, KPi * i / (KSinTableSize/2) );
		r *= max;
		Math::Int( iSin[ i ], r );
		}
	
	InitFrustum( iScreenSize );
	}

void C3DBase::InitFrustum( const TSize& aScreenSize )
	{
	iScreenSize = aScreenSize;
    TRect rect(aScreenSize);
	//
	// create view frustum
	//

	// calculate angles from screen size
	// -1 because of rounding errors
	// so we wouldn't draw outside visible screen

	TReal r;
	TInt lens = 512;
	TInt32 xangle;
	TInt32 yangle;

	Math::ATan( r, 0.5 * iScreenSize.iWidth / lens );
	r = r / KPi * KSinTableSize / 2 - 1;
	Math::Int( xangle, r );

	Math::ATan( r, 0.5 * iScreenSize.iHeight / lens );
	r = r / KPi * KSinTableSize / 2 - 1;
	Math::Int( yangle, r );

	iViewFrustum.iNumPlanes = 5;

	TInt a;
	// near clipping plane
	iViewFrustum.iPlane[ 0 ].iNormal = TVertex ( 0, 0, 1 << KShift );
	iViewFrustum.iPlane[ 0 ].iDistance = -500 << KShift;

	// left clipping plane
	a = (TInt)( xangle ) & ( KSinTableSize-1 );
	iViewFrustum.iPlane[ 1 ].iNormal = TVertex ( iCos[ a ], 0, iSin[ a ] );
	iViewFrustum.iPlane[ 1 ].iDistance = 0;

	// bottom clipping plane
	a = ( ( KSinTableSize/2 )-yangle ) & ( KSinTableSize-1 ); 
	iViewFrustum.iPlane[ 2 ].iNormal = TVertex ( 0, iCos[ a ], iSin[ a ] );
	iViewFrustum.iPlane[ 2 ].iDistance = 0;

	// right clipping plane
	a = (TInt)( ( KSinTableSize/2 )-xangle ) & ( KSinTableSize-1 ); 
	iViewFrustum.iPlane[ 3 ].iNormal = TVertex ( iCos[ a ], 0, iSin[ a ] );
	iViewFrustum.iPlane[ 3 ].iDistance = 0;

	// top clipping plane
	a = ( yangle ) & ( KSinTableSize-1 ); 
	iViewFrustum.iPlane[ 4 ].iNormal = TVertex ( 0, iCos[ a ], iSin[ a ] );
	iViewFrustum.iPlane[ 4 ].iDistance = 0;
	}

TInt16* C3DBase::CosTable()
	{
	return iCos;
	}

TInt16* C3DBase::SinTable()
	{
	return iSin;
	}

TFrustum& C3DBase::ViewFrustum()
	{
	return iViewFrustum;
	}

TVertex C3DBase::RotateX( const TVertex& aVertex, TInt aAngle )
	{
	TInt c = iCos[ aAngle & ( KSinTableSize-1 ) ];
	TInt s = iSin[ aAngle & ( KSinTableSize-1 ) ];
	
	TVertex v;

	v.iX = aVertex.iX;
	v.iY = ( aVertex.iY * c - aVertex.iZ * s ) >> KShift;
	v.iZ = ( aVertex.iY * s + aVertex.iZ * c ) >> KShift;

	return v;
	}

TVertex C3DBase::RotateY( const TVertex& aVertex, TInt aAngle )
	{
	TInt c = iCos[ aAngle & ( KSinTableSize-1 ) ];
	TInt s = iSin[ aAngle & ( KSinTableSize-1 ) ];
	
	TVertex v;

	v.iX = ( aVertex.iX * c - aVertex.iZ * s ) >> KShift;
	v.iY = aVertex.iY;
	v.iZ = ( aVertex.iX * s + aVertex.iZ * c ) >> KShift;

	return v;
	}

TVertex C3DBase::RotateZ( const TVertex& aVertex, TInt aAngle )
	{
	TInt c = iCos[ aAngle & ( KSinTableSize-1 ) ];
	TInt s = iSin[ aAngle & ( KSinTableSize-1 ) ];
	
	TVertex v;

	v.iX = ( aVertex.iX * c - aVertex.iY * s ) >> KShift;
	v.iY = ( aVertex.iX * s + aVertex.iY * c ) >> KShift;
	v.iZ = aVertex.iZ;

	return v;
	}

void C3DBase::QSort( TInt* aZ, TInt* aN, TInt aLow, TInt aHigh )
	{
	// the table aZ from range aLow..aHigh is sorted here
	// the table aN is an index table for aZ table entries
	
	// sorting method is a standard "quick sort"
	
	if( aHigh <= aLow ) return;

	TInt vz = aZ[ aLow ];
	TInt vn = aN[ aLow ];
	TInt lo = aLow;
	TInt hi = aHigh;
	
	TInt rPos = lo+1;
	TInt z = aZ[ rPos ];
	TInt n = aN[ rPos++ ];
	TInt t;
	
	for( TInt i=aLow+1; i<=aHigh; i++ )
		{
		if( z<vz )
			{
			aZ[ lo ] = z;
			z = aZ[ rPos ];

			aN[ lo++ ] = n;
			n = aN[ rPos++ ];
			}
		else
			{
			t = aZ[ hi ];
			aZ[ hi ] = z;
			z = t;

			t = aN[ hi ];
			aN[ hi-- ] = n;
			n = t;
			}
		}
	
	aZ[ lo ] = vz;
	aN[ lo ] = vn;

	// this function will recursively call itself to arrange
	// everything that wasn't arranged on this run.
	QSort( aZ, aN, aLow, lo-1 );
	QSort( aZ, aN, lo+1, aHigh );
	}

TInt C3DBase::PolygonCount()
	{
	return iPolygonCount;
	}

void C3DBase::ResetPolygonCount()
	{
	iPolygonCount = 0;
	}
	
void C3DBase::AddPolygonCount( TInt aCount )
	{
	iPolygonCount += aCount;
	}