ccameracontrol.cpp

一个3D的保龄球的源代码

		//Qiu Li, solve the problem of crash when TotalTime equals to 1, 2004/12/28
		if( endRate == 0 )
			endRate++;
		//Qiu Li end
		interRate=m_iTimer;
		break;

	case CCSCT_DISTANCE:
		if( m_bReplay )
			startRate = m_pScene->GetReplayBallStartY();
		else
			startRate=m_pCurStage->iStartRate; 
		if(m_pCurStage->iEndRate==-1)
			endRate=CC_LANE_LENGH;
		else
			endRate=m_pCurStage->iEndRate;

		interRate=m_pScene->m_ball.GetPosition().y;
		if(endRate>startRate)
		{
			if(interRate<startRate)interRate=startRate;
			if(interRate>endRate)interRate=endRate;
		}
		else
		{
			if(interRate>startRate)interRate=startRate;
			if(interRate<endRate)interRate=endRate;
		}
		break;

	case CCSCT_STATIC:
	case CCSCT_MENTAL:
		startRate=0;
		endRate=1;
		interRate=0;
		break;

	default:
		return;
	}


	int i;
	int t[3];
	int r[3];
	// get absolute coordinates from reference object of pos
	GetAbsCoords(m_pCurStage->iPosRefer,ref);


	// get current pos value
	if(m_pCurStage->iPosContStyle==CCPDS_XYZ)
	{
		for(i=0;i<3;i++)
			curPos[i]=ref[i]+Interpolate(m_pCurStage->iStartPos[i],m_pCurStage->iEndPos[i],
			startRate,endRate,interRate);
	}
	else if(m_pCurStage->iPosContStyle==CCPDS_AAD)
	{
		for(i=0;i<3;i++)
			t[i]=Interpolate(m_pCurStage->iStartPos[i],m_pCurStage->iEndPos[i],
			startRate,endRate,interRate);

		AADtoXYZ(t,r);

		for(i=0;i<3;i++)
			curPos[i]=ref[i]+r[i];
	}


	// get absolute coordinates from reference object of lookat
	//Qiu Li modify, if iLookatRefer is camera, use current calculated eye value, 2004/12/28
	if( m_pCurStage->iLookatRefer == CCRO_CAMERA )
	{
		ref2[0]=curPos[0];
		ref2[1]=curPos[1];
		ref2[2]=curPos[2];
	}
	else
	//Qiu Li end
		GetAbsCoords(m_pCurStage->iLookatRefer,ref2);

	// get current lookat value
	if(m_pCurStage->iLookatContStyle==CCPDS_XYZ)
	{
		for(i=0;i<3;i++)
		{
			int sv,ev;
			sv=ref2[i]+m_pCurStage->iStartLookat[i]-ref[i]-m_pCurStage->iStartPos[i];
			ev=ref2[i]+m_pCurStage->iEndLookat[i]-ref[i]-m_pCurStage->iEndPos[i];
			curLookat[i]=Interpolate(sv,ev,startRate,endRate,interRate);

		}
	}
	else if(m_pCurStage->iLookatContStyle==CCPDS_AAD)
	{
		for(i=0;i<3;i++)
			t[i]=Interpolate(m_pCurStage->iStartLookat[i],m_pCurStage->iEndLookat[i],
			startRate,endRate,interRate);

		AADtoXYZ(t,r);

		for(i=0;i<3;i++)
			curLookat[i]=ref2[i]+r[i]-curPos[i];
	}


	// get current up value
	curUp[0]=Interpolate(m_pCurStage->iStartUp[0],m_pCurStage->iEndUp[0],
		startRate,endRate,interRate);
	curUp[1]=Interpolate(m_pCurStage->iStartUp[1],m_pCurStage->iEndUp[1],
		startRate,endRate,interRate);


	// update camera eye & lookat
	if(m_pCurStage->iControlType!=CCSCT_STATIC && m_pCurStage->iControlType!=CCSCT_MENTAL)
	{
		m_eye.x=curPos[0];
		m_eye.y=curPos[1];
		m_eye.z=curPos[2];

		m_lookat.x=curLookat[0];
		m_lookat.y=curLookat[1];
		m_lookat.z=curLookat[2];
	}
	else
	{
		m_eye.x=m_pCurStage->iStartPos[0]+ref[0];
		m_eye.y=m_pCurStage->iStartPos[1]+ref[1];
		m_eye.z=m_pCurStage->iStartPos[2]+ref[2];

		m_lookat.x=ref2[0]+m_pCurStage->iStartLookat[0]-ref[0]-m_pCurStage->iStartPos[0];
		m_lookat.y=ref2[1]+m_pCurStage->iStartLookat[1]-ref[1]-m_pCurStage->iStartPos[1];
		m_lookat.z=ref2[2]+m_pCurStage->iStartLookat[2]-ref[2]-m_pCurStage->iStartPos[2];
	}

	m_up.x=Cosinus(curUp[1])/16*Sinus(curUp[0])/1024/16;
	m_up.y=-Cosinus(curUp[1])/16*Cosinus(curUp[0])/1024/16;
	m_up.z=Sinus(curUp[1])/16;

	SetViewMatrix();
	UpdateView();

//	DBGPRINTF("CAMERA:%d %d %d\n",m_eye.x, m_eye.y,	m_eye.z); 

//	DBGPRINTF("CAMERA:%d %d %d, %d %d %d, %d %d %d\n",m_eye.x, m_eye.y,
//		m_eye.z, m_lookat.x, m_lookat.y, 
//		m_lookat.z, m_up.x, m_up.y,
//		m_up.z);
	
//	DBGPRINTF("Interpolate:sv%d ev%d sr%d er%d ir%d",m_pCurStage->iStartLookat[i],m_pCurStage->iEndLookat[i],
//			startRate,endRate,interRate);

//	DBGPRINTF("BALL:%d %d %d", m_pScene->m_ball.GetPosition().x, m_pScene->m_ball.GetPosition().y, m_pScene->m_ball.GetPosition().z);


////////////////////////////////////////////////////////////
	// time goes by
//	if(m_pCurStage->iControlType!=CCSCT_TIME && m_pCurStage->iControlType!=CCSCT_DISTANCE)return;

	if(m_pCurStage->iControlType==CCSCT_TIME)
	{
		if(!( m_bReplay && m_iCurStageIndex == CCSS_THROW ))
		{
			m_iTimer++;
			if(m_iTimer>=m_pCurStage->iTotalTime)
				NextStage();
		}
	}
	else if(m_pCurStage->iControlType==CCSCT_DISTANCE)
	{
		if(interRate>=endRate)
			NextStage();
	}
	else
		return;
}




// linear interpolation
int CCameraControl::Interpolate(int StartValue, int EndValue, int StartRate, int EndRate, int InterRate)
{
	// return startvalue+(endvalue-starvalue)/(endrate-startrate)*(interrate-startrate);
	int r1=StartValue+(EndValue-StartValue)*(InterRate-StartRate)/(EndRate-StartRate);
//	int r2=EndValue+(StartValue-EndValue)*(InterRate-EndRate)/(StartRate-EndRate);
//	return (r1+r2)/2;
	return r1;

}


// angle,angle,distance format to x,y,z format
// aad: pointer to int array
// xyz: pointer to return result 
void CCameraControl::AADtoXYZ(int* aad, int* xyz)
{
	xyz[2]=aad[2]*Sinus(aad[1])/1024/16;
	xyz[0]=aad[2]*Cosinus(aad[1])/1024/16*Sinus(aad[0])/1024/16;
	xyz[1]=-aad[2]*Cosinus(aad[1])/1024/16*Cosinus(aad[0])/1024/16;

}


void CCameraControl::XYZtoAAD(int* xyz, int* aad)
{
	int t;
	aad[0]=Atan2i(-xyz[1], xyz[0]);
	t=sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
	if(xyz[2]<0)
		aad[1]=-Atan2i(t,-xyz[2]);
	else
		aad[1]=Atan2i(t,xyz[2]);

//	DBGPRINTF("tan(%d,%d)=%d",t,xyz[2],aad[1]);
	
	aad[2]=sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);

}



// get absolute 3d coordinates of reference object
// refer: id of the reference object
// coords: pointer to return the result
void CCameraControl::GetAbsCoords(int refer, int *coords)
{
	int i;
	switch(refer)
	{
	case CCRO_BALL:
		coords[0]=m_pScene->m_ball.GetPosition().x; 
		coords[1]=m_pScene->m_ball.GetPosition().y;
		coords[2]=m_pScene->m_ball.GetPosition().z;
		break;

	case CCRO_PLAYER:
		if( m_iCombIndex == IDC_CAMERE_FOUL2 )
		{
			coords[0]=m_pScene->m_player->GetBBCenter().x;
			coords[1]=m_pScene->m_player->GetBBCenter().y;
			coords[2]=m_pScene->m_player->GetBBCenter().z;
			//DBGPRINTF("PLAYER:%d, %d, %d",coords[0],coords[1],coords[2]);

		}
		else{
			coords[0]=m_pScene->m_player->GetPosition().x;
			coords[1]=m_pScene->m_player->GetPosition().y;
			coords[2]=m_pScene->m_player->GetPosition().z;
		}
//		DBGPRINTF("=======================================");
//		DBGPRINTF("PLAYER:%d, %d, %d",coords[0],coords[1],coords[2]);
//		DBGPRINTF("=======================================");
		break;

	case CCRO_SCENE:
		for(i=0;i<3;i++)
			coords[i]=0; 
		break;

	case CCRO_CAMERA:
		coords[0]=m_eye.x;
		coords[1]=m_eye.y;
		coords[2]=m_eye.z;
		break;

	default:
		for(i=0;i<3;i++)
			coords[i]=0;
	}
}

/*
* =============================================================
* Name		: void CCameraControl::SetStage(int stageId)
* Parameter	: id: camera id
* Implementation: 
*		It is the main function for other module set camera
*	mode, CallCamera() will be called to set camera combination id.
*
* =============================================================
*/
void CCameraControl::SetStage(int stageId,int replaytimer)
{
	//Qiu Li, stageId should between 1 to CC_STAGE_COUNT-1, 2004/12/22
//	if(stageId<1 || stageId>CC_STAGE_COUNT)return;
	if(stageId<1 || stageId>=CC_STAGE_COUNT)
		return;
	//Qiu Li end
	m_iCurStageIndex=stageId;

	if( m_bReplay && replaytimer && m_iCurStageIndex == CCSS_THROW )
		m_iTimer = replaytimer;

	switch(stageId)
	{
	case CCSS_CHEER:
		{
		int CC_CHEER=43;
		int j=getRandomNumber(3-1);
		CallCamera(j+CC_CHEER);
		return;
		}
	//Qiu Li, add two camera views for throw when foul, 2004/12/21
/*	case CCSS_FOUL:
		CallCamera(IDC_FOUL);
		return;
*/
	case CCSS_FOUL_L:
	case CCSS_FOUL_R:
		{
			int i;
			i=getRandomNumber(CC_TRW_STEP1_COUNT-1);//0 - count-1
			CallCamera(i+IDC_THROW_FWD);

			iFoulStep = 1;
			return;
		}
		return;
	//Qiu Li end
	
	case CCSS_FOUL2:
		CallCamera(IDC_CAMERE_FOUL2);
		return;

	case CCSS_AIM:
		CallCamera(IDC_AIM);
		return;

	case CCSS_WIN:
		CallCamera(IDC_WIN);
		return;

	case CCSS_LOSE:
		CallCamera(IDC_LOSE);
		return;

	case CCSS_ROCK_LOSE:
		CallCamera(IDC_ROCK_LOSE);
		return;

	case CCSS_INTRODUCTION:
		//CallCamera(IDC_CENTERROTATE);
		{
			int i;
			i=getRandomNumber(CAMERAVIEW_FWD_BWD-1);
			CallCamera(IDC_CENTERROTATE_FWD+i);
			iCameraViewStep = 1;
			return;
		}

	//Qiu Li, add camera shake when strike, 2004/12/22
	case CCSS_STRIKE:
		CallCamera(IDC_STRIKE);
		return;
	//Qiu Li

	case CCSS_CAMERE_FORWARD:
		CallCamera(IDC_CAMERE_FORWARD);
		return;
	
	case CCSS_CLUB1_LEFTSIDE:
	case CCSS_CLUB1_RIGHTSIDEBACK:
	case CCSS_CLUB1_LEFTSIDEFRONT:
	case CCSS_CLUB1_BACKSIDE:
	case CCSS_CLUB1_FRONTSIDE:
	case CCSS_CLUB2_RIGHTSIDE:
	case CCSS_CLUB2_LEFTSIDEBACK:
	case CCSS_CLUB2_RIGHTSIDEFRONT:
	case CCSS_CLUB2_BACKSIDE:
	case CCSS_CLUB2_FRONTSIDE:
	case CCSS_CLUB3_RIGHTSIDE:
	case CCSS_CLUB3_LEFTSIDEBACK:
	case CCSS_CLUB3_LEFTSIDEFRONT:
	case CCSS_CLUB3_BACKSIDE:
	case CCSS_CLUB3_FRONTSIDE:
		{
			int i = stageId - CCSS_CLUB1_LEFTSIDE;
			CallCamera(IDC_CLUB1_LEFTSIDE + i);
			return;
		}

	case CCSS_CAMERA_VS:
		CallCamera(IDC_CAMERA_VS);
		break;

	case CCSS_COLLIDE_CENTER:
		CallCamera(IDC_COLLIDE_CENTER);
		break;

	case CCSS_COLLIDE_RIGHT:
		CallCamera(IDC_COLLIDE_RIGHT);
		break;

	case CCSS_COLLIDE_BACK:
		CallCamera(IDC_COLLIDE_BACK);
		break;

	case CCSS_TV:
		CallCamera(IDC_CAMERA_TV);
		break;

	case CCSS_TITLE:
		CallCamera(IDC_CAMERA_INTRO);
		break;


	default:
		if(m_bReplay)
		{
			CallCamera(m_iCurCombIndex*4+m_iCurStageIndex);
			bNeedRollbackInReplay = false;
			if( m_iCurStageIndex != CCSS_THROW )
				CheckCameraStage();
		}
		else if( stageId == CCSS_THROW )
		{
			int i;
			i=getRandomNumber(CC_TRW_STEP1_COUNT-1);//0 - count-1
			//CallCamera(i+CCSS_TRW_FWD);
			CallCamera(i+IDC_THROW_FWD);

			iThrowStep = 1;
			return;
		}
//		CallCamera(8+m_iCurStageIndex);
		else
		{
			CallCamera(m_iCurStageIndex);
		}
		break;
	}

}



void CCameraControl::SetReplay(bool flag)
{
	m_bReplay=flag;
}

/*
* =============================================================
* Name		: void CCameraControl::SetCameraFocus(Vector4s focus)
* Parameter	: focus: camera lookat
* Implementation: 
*		set camera to focus on a point, which is probably a tenpin
*
* =============================================================
*/
//Qiu Li, set camera focus on a tenpin, 2004/12/22
void CCameraControl::SetCameraFocus(Vector4s focus)
{
	Vector4s pos;
	pos.x = focus.x;
	pos.y = focus.y;
	pos.z = focus.z;

	m_iCurStageIndex=IDC_CHAS_FOCUS;
	CallCamera(IDC_CHAS_FOCUS);
	
	//move from current position
	m_pCurStage->iStartPos[0] = m_eye.x;
	m_pCurStage->iStartPos[1] = m_eye.y;
	m_pCurStage->iStartPos[2] = m_eye.z;

	//set end posision
	m_pCurStage->iEndPos[0] = m_eye.x;
	m_pCurStage->iEndPos[1] = m_eye.y;
	m_pCurStage->iEndPos[2] = m_eye.z;

	//set lookat
	m_pCurStage->iEndLookat[0] = pos.x;
	m_pCurStage->iEndLookat[1] = pos.y;
	m_pCurStage->iEndLookat[2] = 20;//pos.z;
}
//Qiu Li end

/*
* =============================================================
* Name		: void CCameraControl::MovetoCoin(Vector4s coin)
* Parameter	: coin: coin position
* Implementation: 
*		Set camera to move from current position to 1.5 metre
*	before coin, and look at coin.
*
* =============================================================
*/
//Qiu Li, move camera to focus to coin, 2005/1/11
void CCameraControl::MovetoCoin(Vector4s coin)
{
	vCoinPos.x = coin.x;
	vCoinPos.y = coin.y;
	vCoinPos.z = coin.z;

	m_iCurStageIndex=IDC_FORWARDTO_COIN;
	CallCamera(IDC_FORWARDTO_COIN);

	//from current position and lookat
	CCameraStage* m_pStage=&m_pCameraCombinations[IDC_AIM][0];

	int ref[3];
	GetAbsCoords(CCRO_PLAYER,ref);

	m_pCurStage->iStartPos[0] = m_pStage->iStartPos[0]+ref[0];//m_eye.x;
	m_pCurStage->iStartPos[1] = m_pStage->iStartPos[1]+ref[1];//m_eye.y;
	m_pCurStage->iStartPos[2] = m_pStage->iStartPos[2]+ref[2];//m_eye.z;

	m_pCurStage->iStartLookat[0] = m_pStage->iStartLookat[0];//m_lookat.x;
	m_pCurStage->iStartLookat[1] = m_pStage->iStartLookat[1];//m_lookat.y;
	m_pCurStage->iStartLookat[2] = m_pStage->iStartLookat[2];//m_lookat.z;

	//set end posision
	m_pCurStage->iEndPos[0] = vCoinPos.x;
	m_pCurStage->iEndPos[1] = vCoinPos.y-150;
	m_pCurStage->iEndPos[2] = vCoinPos.z+38;

	//set lookat
	m_pCurStage->iEndLookat[0] = vCoinPos.x;
	m_pCurStage->iEndLookat[1] = vCoinPos.y;
	m_pCurStage->iEndLookat[2] = vCoinPos.z+12;
}

/*
* =============================================================
* Name		: void CCameraControl::MoveBackFromCoin(void)
* Parameter	: none
* Implementation: 
*		Set camera to move back from coin to previous wait position.
*
* =============================================================
*/
void CCameraControl::MoveBackFromCoin(void)	//need to be called after MovetoCoin()
{
	m_iCurStageIndex=IDC_FORWARDTO_COIN;
	CallCamera(IDC_FORWARDTO_COIN);

	//from current position and lookat
	m_pCurStage->iStartPos[0] = vCoinPos.x;
	m_pCurStage->iStartPos[1] = vCoinPos.y-150;
	m_pCurStage->iStartPos[2] = vCoinPos.z+38;

	m_pCurStage->iStartLookat[0] = vCoinPos.x;
	m_pCurStage->iStartLookat[1] = vCoinPos.y;