as_object.cpp

类似小蜜蜂的游戏,但是已经3D化了,斑竹给我开通吧,我已经上传了5个了.

#include "Invasion.h"


FLOAT3 fTextCoordTemp[3] = {{0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}};


AS_OBJECT::AS_OBJECT(void)
{ // begin AS_OBJECT::AS_OBJECT()
	memset(this, 0, sizeof(AS_OBJECT));
} // end AS_OBJECT::AS_OBJECT()

AS_OBJECT::~AS_OBJECT(void)
{ // begin AS_OBJECT::~AS_OBJECT()
} // end AS_OBJECT::~AS_OBJECT()

void AS_OBJECT::SetFrameT(short iID)
{ // begin AS_OBJECT::SetFrameT()
	int i;

	for(i = 0; i < Header.iChildren; i++)
		pChild[i]->SetFrameT(iID);
	if(iID < 0 || iID >= Header.iFrames)
		pFrameT = NULL;
	else
		pFrameT = &pFrame[iID];
} // end AS_OBJECT::SetFrameT()

void AS_OBJECT::SetAnimationT(short iID)
{ // begin AS_OBJECT::SetAnimationT()
	int i;

	for(i = 0; i < Header.iChildren; i++)
		pChild[i]->SetAnimationT(iID);
	if(iID < 0 || iID >= Header.iAnimations)
		pAnimationT = NULL;
	else
		pAnimationT = &pAnimation[iID];
} // end AS_OBJECT::SetAnimationT()

void AS_OBJECT::SetAnimationStepT(short iID)
{ // begin AS_OBJECT::SetAnimationStepT()
	int i;

	for(i = 0; i < Header.iChildren; i++)
		pChild[i]->SetAnimationStepT(iID);
	if(iID < 0 || iID >= pAnimationT->iSteps)
		pAnimationT->pStepT = NULL;
	else
		pAnimationT->pStepT = &pAnimationT->pStep[iID];
} // end AS_OBJECT::SetAnimationStepT()

void AS_OBJECT::SetInterpolateTime(DWORD dwTime)
{ // begin AS_OBJECT::SetInterpolateTime()
	int i;

	for(i = 0; i < Header.iChildren; i++)
		pChild[i]->SetInterpolateTime(dwTime);
	if(!pAnimationT || !pAnimationT->pStepT)
		return;
	pAnimationT->pStepT->dwInterpolateTime = dwTime;
} // end AS_OBJECT::SetInterpolateTime()

void AS_OBJECT::CalculateInterpolations(void)
{ // begin AS_OBJECT::CalculateInterpolations()
	AS_OBJECT_ANIMATION_STEP *pAniStepTemp, *pNextAniStepTemp;
	int i, i2, i3, i4;

	// Precalculate the constant interpolation data:
	for(i3 = 0; i3 < Header.iAnimations; i3++)
	{
		for(i4 = 0; i4 < pAnimation[i3].iSteps; i4++)
		{
			pAniStepTemp = &pAnimation[i3].pStep[i4];
			if(i4 >= pAnimation[i3].iSteps-1)
				pNextAniStepTemp = &pAnimation[i3].pStep[0];
			else
				pNextAniStepTemp = &pAnimation[i3].pStep[i4+1];
			if(!pAniStepTemp->pFrame)
				continue;
			for(i = 0; i < pAniStepTemp->pFrame->iTextureCoords; i++)
				for(i2 = 0; i2 < 2; i2++)
					pAniStepTemp->fTextureCoordIncreasePos[i][i2] = (pNextAniStepTemp->pFrame->fTextureCoord[i][i2]-pAniStepTemp->pFrame->fTextureCoord[i][i2])/pAniStepTemp->dwInterpolateTime;
			for(i2 = 0; i2 < 3; i2++)
			{
				for(i = 0; i < pAniStepTemp->pFrame->iDiffuseColors; i++)
					pAniStepTemp->fDiffuseColorIncreasePos[i][i2] = (pNextAniStepTemp->pFrame->fDiffuseColor[i][i2]-pAniStepTemp->pFrame->fDiffuseColor[i][i2])/pAniStepTemp->dwInterpolateTime;
				for(i = 0; i < pAniStepTemp->pFrame->iNormals; i++)
					pAniStepTemp->fNormalIncreasePos[i][i2] = (pNextAniStepTemp->pFrame->fNormal[i][i2]-pAniStepTemp->pFrame->fNormal[i][i2])/pAniStepTemp->dwInterpolateTime;
				for(i = 0; i < pAniStepTemp->pFrame->iVertices; i++)
					pAniStepTemp->fVertexIncreasePos[i][i2] = (pNextAniStepTemp->pFrame->fVertex[i][i2]-pAniStepTemp->pFrame->fVertex[i][i2])/pAniStepTemp->dwInterpolateTime;
			}
			// Now calculate the matrix:
			for(i2 = 0; i2 < 4; i2++)
				for(i = 0; i < 4; i++)
					pAniStepTemp->MatrixIncrease[i][i2] = (pNextAniStepTemp->pFrame->Matrix[i][i2]-pAniStepTemp->pFrame->Matrix[i][i2])/pAniStepTemp->dwInterpolateTime;
		}
	}
} // end AS_OBJECT::CalculateInterpolations()

void AS_OBJECT::CalculateCurrentFrame(void)
{ // begin AS_OBJECT::CalculateCurrentFrame()
	short i, i2;
	AS_OBJECT_ANIMATION_STEP *pCurrentAniStep;
	AS_OBJECT_ANIMATION_STEP *pNextAniStep;
	AS_OBJECT_FRAME *pFrameTemp;
	
	// Calculates the current frame:
	pCurrentAniStep = pAnimationT->pStepT;
	dwCurrentTime = GetTickCount();
	dwTimeDifference = dwCurrentTime-dwLastTime;
	if(pCurrentAniStep->dwInterpolateTime < dwTimeDifference)
		dwTimeDifference = pCurrentAniStep->dwInterpolateTime;
	if(pCurrentAniStep->dwInterpolateTime == dwTimeDifference)
	{ // Go to the next frame:
		dwTimeDifference = 0;
		dwCurrentTime = dwLastTime = GetTickCount();
		if(pCurrentAniStep->iID >= pAnimationT->iSteps-1)
			pCurrentAniStep = &pAnimationT->pStep[0];
		else
			pCurrentAniStep = &pAnimationT->pStep[pCurrentAniStep->iID+1];
		pAnimationT->pStepT = pCurrentAniStep;
	}
	pFrameTemp = pCurrentAniStep->pFrame;
	CurrentFrame.iFace = pFrameTemp->iFace;
	memcpy(CurrentFrame.fMin, pFrameTemp->fMin, sizeof(FLOAT3));
	memcpy(CurrentFrame.fMax, pFrameTemp->fMax, sizeof(FLOAT3));
	memcpy(CurrentFrame.fMiddle, pFrameTemp->fMiddle, sizeof(FLOAT3));
	if(pCurrentAniStep->iID >= pAnimationT->iSteps-1)
		pNextAniStep = &pAnimationT->pStep[0];
	else
		pNextAniStep = &pAnimationT->pStep[pCurrentAniStep->iID+1];
	if(!pCurrentAniStep || !pNextAniStep)
		return;
	if(CurrentFrame.fDiffuseColor)
		for(i2 = 0; i2 < 3; i2++)
			for(i = 0; i < pFrameTemp->iDiffuseColors; i++)
				CurrentFrame.fDiffuseColor[i][i2] = pFrameTemp->fDiffuseColor[i][i2]+(pCurrentAniStep->fDiffuseColorIncreasePos[i][i2]*dwTimeDifference);
	if(CurrentFrame.fNormal)
		for(i2 = 0; i2 < 3; i2++)
			for(i = 0; i < pFrameTemp->iNormals; i++)
				CurrentFrame.fNormal[i][i2] = pFrameTemp->fNormal[i][i2]+(pCurrentAniStep->fNormalIncreasePos[i][i2]*dwTimeDifference);
	if(CurrentFrame.fVertex)
		for(i2 = 0; i2 < 3; i2++)
			for(i = 0; i < pFrameTemp->iVertices; i++)
				CurrentFrame.fVertex[i][i2] = pFrameTemp->fVertex[i][i2]+(pCurrentAniStep->fVertexIncreasePos[i][i2]*dwTimeDifference);
	for(i = 0; i < pFrameTemp->iTextureCoords; i++)
		for(i2 = 0; i2 < 2; i2++)
			CurrentFrame.fTextureCoord[i][i2] = pFrameTemp->fTextureCoord[i][i2]+(pCurrentAniStep->fTextureCoordIncreasePos[i][i2]*dwTimeDifference);
	// Now calculate the current matrix:
	for(i = 0; i < 4; i++)
		for(i2 = 0; i2 < 4; i2++)
			CurrentFrame.Matrix[i][i2] = pFrameTemp->Matrix[i][i2]+(pCurrentAniStep->MatrixIncrease[i][i2]*dwTimeDifference);
} // end AS_OBJECT::CalculateCurrentFrame()

void AS_OBJECT::Draw(BOOL bChildrenToo, BOOL bTextured, BOOL bDrawBounding)
{ // begin AS_OBJECT::Draw()
	SHORT3 *pFaceTemp;
	short i;

	if(!pAnimationT)
		return;
	if(!pAnimationT->pStepT)
		pAnimationT->pStepT = &pAnimationT->pStep[0];
	if(bChildrenToo)
		if(Header.bChildrenActive && pChild)
		{
			for(i = 0; i < Header.iChildren; i++)
			{
				if(!pChild[i])
					continue;
				pChild[i]->Draw(bChildrenToo, bTextured, bDrawBounding);
			}
		}
	if(!Header.bActive)
		return;
	if(!pAnimationT->iSteps == 1)
		pFrameT = pAnimationT->pStep[0].pFrame;
	else
	{
		CalculateCurrentFrame();
		pFrameT = &CurrentFrame;
	}
	glPushMatrix();
	glMultMatrixf(CurrentFrame.Matrix[0]);
	if(bDrawBounding)
		DrawBounding();
	glColorPointer(3, GL_FLOAT, 0, CurrentFrame.fDiffuseColor);
	glVertexPointer(3, GL_FLOAT, 0, CurrentFrame.fVertex);
	glNormalPointer(GL_FLOAT, 0, CurrentFrame.fNormal);
	if(!bTextured)
	{
		pFaceTemp = &CurrentFrame.iFace[0];
		glBegin(GL_TRIANGLES);
			for(i = 0; i < CurrentFrame.iFaces; i++, pFaceTemp++)
			{
				glArrayElement((*pFaceTemp)[0]);
				glArrayElement((*pFaceTemp)[1]);
				glArrayElement((*pFaceTemp)[2]);
			}
		glEnd();
	}
	else
	{
		pFaceTemp = &CurrentFrame.iFace[0];
		glBegin(GL_TRIANGLES);
			for(i = 0; i < CurrentFrame.iFaces; i++, pFaceTemp++)
			{
				glTexCoord2fv(fTextCoordTemp[0]);
				glArrayElement((*pFaceTemp)[0]);
				glTexCoord2fv(fTextCoordTemp[1]);
				glArrayElement((*pFaceTemp)[1]);
				glTexCoord2fv(fTextCoordTemp[2]);
				glArrayElement((*pFaceTemp)[2]);
			}
		glEnd();
	}
	glPopMatrix();
} // end AS_OBJECT::Draw()

void AS_OBJECT::DrawBounding(void)
{ // begin AS_OBJECT::DrawBounding()
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	glDisable(GL_CULL_FACE);
	glColor3f(1.0f, 1.0f, 1.0f);
	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	glLineWidth(1.f);
	glBegin(GL_QUADS);
		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMin[Z]);
		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMax[Y],
				   CurrentFrame.fMin[Z]);
		glVertex3f(CurrentFrame.fMax[X],
				   CurrentFrame.fMax[Y],
				   CurrentFrame.fMin[Z]);
		glVertex3f(CurrentFrame.fMax[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMin[Z]);

		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMax[Z]);
		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMax[Y],
				   CurrentFrame.fMax[Z]);
		glVertex3f(CurrentFrame.fMax[X],
				   CurrentFrame.fMax[Y],
				   CurrentFrame.fMax[Z]);
		glVertex3f(CurrentFrame.fMax[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMax[Z]);

		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMin[Z]);
		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMax[Z]);
		glVertex3f(CurrentFrame.fMax[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMax[Z]);
		glVertex3f(CurrentFrame.fMax[X],
				   CurrentFrame.fMin[Y],
				   CurrentFrame.fMin[Z]);

		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMax[Y],
				   CurrentFrame.fMin[Z]);
		glVertex3f(CurrentFrame.fMin[X],
				   CurrentFrame.fMax[Y],
				   CurrentFrame.fMax[Z]);
		glVertex3f(CurrentFrame.fMax[X],
				   CurrentFrame.fMax[Y],