c3drenderer.cpp

Symbian平台下的一个3D赛车游戏源码

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

// INCLUDES
#include "C3DRenderer.h"
#include "C3DBase.h"
#include "M3dObject.h"
#include <e32svr.h>

// MEMBER FUNCTIONS

C3DRenderer* C3DRenderer::NewL( C3DBase* a3DBase, TInt aMaxObjects )
	{
	C3DRenderer* self = new( ELeave )C3DRenderer( a3DBase, aMaxObjects );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}
	
C3DRenderer::~C3DRenderer()
	{
	delete[] iObject;
	delete[] iObjectPosition;
	delete[] iObjectMatrix;
	delete[] iObjectRotMatrix;
	delete[] iObjectPriority;

	delete[] iObjectZ;
	delete[] iObjectN;
	}
	
void C3DRenderer::ConstructL()
	{

	// make room for object parameters for all objects:
	iObject = new( ELeave )M3dObject*[ iMaxObjects ];
	iObjectPosition = new( ELeave )TVertex[ iMaxObjects ];
	iObjectMatrix = new( ELeave )TMatrix[ iMaxObjects ];
	iObjectRotMatrix = new( ELeave )TMatrix[ iMaxObjects ];
	iObjectPriority = new( ELeave )TInt[ iMaxObjects ];

	// and put default values where needed:
	iObjectZ = new( ELeave )TInt[ iMaxObjects ];
	iObjectN = new( ELeave )TInt[ iMaxObjects ];
	TInt i;
	for( i=0; i<iMaxObjects; i++ )
		{
		iObject[ i ] = NULL;
		iObjectPriority[ i ] = 0;
		}
	}
	


C3DRenderer::C3DRenderer( C3DBase* a3DBase, TInt aMaxObjects )
	: i3DBase( a3DBase )
	, iMaxObjects( aMaxObjects )
	, iCos( a3DBase->CosTable() )
	, iSin( a3DBase->SinTable() )
	{
	}




TInt C3DRenderer::AddObject( M3dObject* aObject )
	{
	// scan object list for empty position and put new object there.

	TBool found = EFalse;
	TInt i = 0;
	while( ( i<iMaxObjects ) && ( !found ) )
		{
		if( iObject[ i ] == NULL )
			{
			found = ETrue;
			}
		else
			{
			i++;
			}
		}

	if( found )
		{
		iObject[ i ] = aObject;
		iObjectPosition[ i ] = TVertex( 0,0,0 );
		SetObjectAngle( i, TVertex( 0,0,0 ) );
		}

	return i;
	}

void C3DRenderer::RemoveObject( TInt aIndex )
	{
	iObject[ aIndex ] = NULL;
	}

void C3DRenderer::SetObjectPosition( TInt aIndex, const TVertex& aPosition )
	{
	iObjectPosition[ aIndex ] = aPosition;
	}

void C3DRenderer::SetObjectAngle( TInt aIndex, const TVertex& aAngle )
	{
	// when object has new angle, the rotate matrix must be updated:

	TInt c1 = iCos[ aAngle.iZ & 4095 ];
	TInt s1 = iSin[ aAngle.iZ & 4095 ];

	TInt c2 = iCos[ aAngle.iX & 4095 ];
	TInt s2 = iSin[ aAngle.iX & 4095 ];

	TInt c3 = iCos[ aAngle.iY & 4095 ];
	TInt s3 = iSin[ aAngle.iY & 4095 ];

	TInt v1 = 1 << KShift;


	// rotation order around axises: Z, X, Y
	// order can be changed here ( order is backwards to definition )

	TMatrix objRot( c3, 0,	-s3, 0,			// rotation matrix around Y-axis
					 0,	v1,   0, 0,
					s3,	 0,  c3, 0 );

	objRot *= TMatrix( v1,  0,   0, 0,		// rotation matrix around X-axis
						0, c2, -s2, 0,
						0, s2,  c2, 0 );
		
	objRot *= TMatrix( c1, -s1,  0,  0,		// rotation matrix around Z-axis
					   s1,  c1,  0,  0,
				 		0,   0, v1,  0 );

	iObjectMatrix[ aIndex ] = objRot;
	}



void C3DRenderer::SetObjectPriority( TInt aIndex, TInt aPriority )
	{
	iObjectPriority[ aIndex ] = aPriority;
	}

void C3DRenderer::SetCameraPosition( const TVertex& aPosition )
	{
	iCameraPosition = aPosition;
	}

void C3DRenderer::SetCameraAngle( const TVertex& aAngle )
	{
	iCameraAngle = aAngle;
	}




void C3DRenderer::Draw( const TBitmap& aScreen )
	{
	i3DBase->ResetPolygonCount();

	TInt i;

	TInt v1 = 1 << KShift;
	
	TInt c1 = iCos[ iCameraAngle.iY & 4095 ];
	TInt s1 = iSin[ iCameraAngle.iY & 4095 ];

	TInt c2 = iCos[ iCameraAngle.iX & 4095 ];
	TInt s2 = iSin[ iCameraAngle.iX & 4095 ];

	TInt c3 = iCos[ iCameraAngle.iZ & 4095 ];
	TInt s3 = iSin[ iCameraAngle.iZ & 4095 ];

	// Calculate camera rotation matrix:
	
	TMatrix camRot( c3, -s3,  0,  0,		// Z-axis
					s3,  c3,  0,  0,
					 0,   0, v1,  0 );
	
	camRot *= TMatrix( v1, 0,   0,  0,		// X-axis
						0, c2, -s2, 0,
						0, s2,  c2, 0 );
	
	
	camRot *= TMatrix( c1, 0, -s1, 0,		// Y-axis
						0,v1,   0, 0,
					   s1, 0,  c1, 0 );

	 
	// and add camera position
	
	camRot *= TMatrix ( v1, 0, 0, -iCameraPosition.iX,
						0, v1, 0, -iCameraPosition.iY,
						0, 0, v1, -iCameraPosition.iZ );

	
	TFrustum frustum( i3DBase->ViewFrustum() );

	// rotate all objects to their place in space

	TInt numObjects = 0;
	for( i=0; i<iMaxObjects; i++ )
		{
		if( iObject[ i ] != NULL )		// objectlist can contain empty indexes
			{
			iObjectMatrix[ i ][ 3 ] = iObjectPosition[ i ].iX;
			iObjectMatrix[ i ][ 7 ] = iObjectPosition[ i ].iY;
			iObjectMatrix[ i ][ 11] = iObjectPosition[ i ].iZ;
			
			TMatrix& obj = iObjectRotMatrix[ numObjects ];

			obj = camRot;
			obj *= iObjectMatrix[ i ];

			TVertex objPos( obj[ 3 ], obj[ 7 ], obj[ 11 ] );

			// check if object is inside view frustum

			TBool visible = ETrue;

			for( TInt n=0; n<frustum.iNumPlanes; n++ )
				{
				TVertex& mv1 = frustum.iPlane[ n ].iNormal;
				
				// calculate dot product to get point distance to plane:
				TInt l = mv1.iX * objPos.iX + mv1.iY * objPos.iY + mv1.iZ * objPos.iZ;
				l += frustum.iPlane[ n ].iDistance;
				l >>= KShift;
				l += iObject[ i ]->iBoundingRadius;

				if( l < 0 ) 
					{
					visible = EFalse;
					break;
					}
				}

			if( visible )
				{
				// calculate object distance from camera
				// used for object sorting

				TInt v = objPos.iX >> KShift;
				TInt d = v*v;
				v = objPos.iY >> KShift;
				d += v*v;
				v = objPos.iZ >> KShift;
				d += v*v;
				d += iObjectPriority[ i ];
				
				iObjectZ[ numObjects ] = d;
				iObjectN[ numObjects ] = ( i << 16 ) + numObjects;
				
				numObjects++;
				}			
			}
		}


	// sort
	i3DBase->QSort( iObjectZ, iObjectN, 0, numObjects-1 );

	// draw sorted back to front
	for( i=numObjects-1; i>=0; i-- )
		{
		TInt n1 = iObjectN[ i ] & 0xffff;
		TInt n2 = iObjectN[ i ] >> 16;
		iObject[ n2 ]->Draw( aScreen, &iObjectRotMatrix[ n1 ] );
		}

	}