mhcamera.cpp

墨香最新私服

// MHCamera.cpp: implementation of the CMHCamera class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MHCamera.h"
#include ".\Engine\EngineCamera.h"
#include "Object.h"
#include "MHCameraDefine.h"
#include "MoveManager.h"
#include "ObjectManager.h"

#include "GameResourceManager.h"

#include "mhMap.h"
#include "./Input/UserInput.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

float DEFAULT_ANGLEX_FOLLOW_VIEW = 15.f;
float DEFAULT_ANGLEY_FOLLOW_VIEW = 180.f;
float DEFAULT_DISTANCE_FOLLOW_VIEW = 700.f;

float CHARHEIGHT	= 140.f;
float SITHEIGHT		= 90.f;
float DIEHEIGHT		= 80.f;



SHAKEVECTOR MHDesc_Earthquake[] =
{
	{	0.f,	10.f,	0.f,	50	},
	{	0.f,	-10.f,	0.f,	50	},
	{	0.f,	20.f,	0.f,	50	},
	{	0.f,	-20.f,	0.f,	50	},
	{	0.f,	15.f,	0.f,	50	},
	{	0.f,	-15.f,	0.f,	50	},
	{	0.f,	10.f,	0.f,	50	},
	{	0.f,	-10.f,	0.f,	50	},
	{	0.f,	5.f,	0.f,	50	},
	{	0.f,	-5.f,	0.f,	50	},
	{	0.f,	2.f,	0.f,	50	},
	{	0.f,	-2.f,	0.f,	50	},
	{	0.f,	1.f,	0.f,	50	},
	{	0.f,	-1.f,	0.f,	50	},
};

SHAKEVECTOR MHDesc_Vibration[] =
{
	{	0.f,	5.f,	0.f,	50	},
	{	0.f,	-5.f,	0.f,	50	},
	{	0.f,	5.f,	0.f,	50	},
	{	0.f,	-5.f,	0.f,	50	},
	{	0.f,	2.f,	0.f,	50	},
	{	0.f,	-2.f,	0.f,	50	},
	{	0.f,	1.f,	0.f,	50	},
	{	0.f,	-1.f,	0.f,	50	},
};

GLOBALTON(CMHCamera)
CMHCamera::CMHCamera()
{
	for(int n=0;n<MAX_CAMERA_DESC;++n)
	{
		m_CameraDesc[n].m_AngleX.SetAngleDeg(0);
		m_CameraDesc[n].m_AngleY.SetAngleDeg(0);
		m_CameraDesc[n].m_pPivotObject = NULL;
		m_CameraDesc[n].m_fDistance = 0;
		m_CameraDesc[n].m_bCameraAngleMovingX = 0;
		m_CameraDesc[n].m_bCameraAngleMovingY = 0;
		m_CameraDesc[n].m_bCameraDistanceMoving = 0;
		//KES
		m_CameraDesc[n].m_bHeightChanging = FALSE;
	}
	m_CurCamera = 0;
	
	m_bIsVibrating = FALSE;
	m_bIsShaking = FALSE;


	m_ppCameraShakeDesc = new MHCAMERASHAKE*[eCSD_Max];
	m_ppCameraShakeDesc[eCSD_Earthquake] = new MHCAMERASHAKE(MHDesc_Earthquake,sizeof(MHDesc_Earthquake));
	m_ppCameraShakeDesc[eCSD_Vibration] = new MHCAMERASHAKE(MHDesc_Vibration,sizeof(MHDesc_Vibration));

	m_fDistanceRate		= 100.0f;		//(%)
	m_fMaxSightDistance	= 10000.0f;		//(cm)
	m_fFov				= gPHI/4.0f;		//rad


	m_CurPosition = eCP_CHARSEL;
	m_GotoPosition = -1;
	m_MoveSpeed = 300;
	m_bMoved = FALSE;
	m_pCameraFilter = NULL;

	m_LastMoveNoticeTime = 0;
}

CMHCamera::~CMHCamera()
{
	for(int n=1;n<eCSD_Max;++n)
	{
		delete m_ppCameraShakeDesc[n];
	}
	delete [] m_ppCameraShakeDesc;
}

void CMHCamera::Init(CObject* pObject,float angleX,float angleY,float fDistance)
{	
	VECTOR3 pos;
	if(pObject)
		pObject->GetPosition(&pos);
	else
		pos.x = pos.y = pos.z = 0;
	
	InitCamera(0,angleX,angleY,fDistance,pObject);
	SetCurCamera(0);

	SetCameraMode(eCM_Free);
}
void CMHCamera::InitCamera(int CameraNum,float angleX,float angleY,float fDistance,CObject* pObject)
{
	m_CameraDesc[CameraNum].m_AngleX.SetAngleDeg(angleX);
	m_CameraDesc[CameraNum].m_AngleY.SetAngleDeg(angleY);
	m_CameraDesc[CameraNum].m_fDistance = fDistance;
	m_CameraDesc[CameraNum].m_CharHeight = CHARHEIGHT;
	m_CameraDesc[CameraNum].m_TargetCharHeight = CHARHEIGHT;
	
	m_CameraDesc[CameraNum].m_bCameraAngleMovingX = FALSE;
	m_CameraDesc[CameraNum].m_bCameraAngleMovingY = FALSE;
	m_CameraDesc[CameraNum].m_bCameraDistanceMoving = FALSE;

	SetCameraPivotObject(CameraNum,pObject);

	if(m_CurCamera == CameraNum)
	{
		CalcCameraPosAngle();
		SetToEngineCamera();
	}

	float fov = MAP->GetMapDesc()->Fov;
	float radian = fov*gPHI/360;
	m_DownVector.x = 0;	
	m_DownVector.y = -CAMERA_NEAR * (tanf(radian) + 1);
	m_DownVector.z = 0;
}
void CMHCamera::InitCamera(int CameraNum,float angleX,float angleY,float fDistance,VECTOR3* pPivotPos)
{
	m_CameraDesc[CameraNum].m_pPivotObject = NULL;
	m_CameraDesc[CameraNum].m_AngleX.SetAngleDeg(angleX);
	m_CameraDesc[CameraNum].m_AngleY.SetAngleDeg(angleY);
	m_CameraDesc[CameraNum].m_fDistance = fDistance;
	m_CameraDesc[CameraNum].m_CharHeight = CHARHEIGHT;
	m_CameraDesc[CameraNum].m_TargetCharHeight = CHARHEIGHT;

	m_CameraDesc[CameraNum].m_PivotPos = *pPivotPos;

	m_CameraDesc[CameraNum].m_bPivotObject = FALSE;

	if(m_CurCamera == CameraNum)
	{
		CalcCameraPosAngle();
		SetToEngineCamera();
	}
}


void CMHCamera::SetToEngineCamera()
{
	VECTOR3 AnglePYR;
	AnglePYR.x = -m_CameraDesc[m_CurCamera].m_AngleX.ToRad();
	AnglePYR.y = -m_CameraDesc[m_CurCamera].m_AngleY.ToRad();
	AnglePYR.z = 0;

	VECTOR3 CameraAngle = AnglePYR + m_VibrateAngle;
	VECTOR3 CameraPos = m_CameraDesc[m_CurCamera].m_CameraPos;	
	if(m_bIsVibrating)
		CameraPos = CameraPos + m_VibratePos;
	if(m_bIsShaking)
		CameraPos = CameraPos + m_ShakingPos;

	m_EngineCamera.SetCameraPos(&CameraPos);
	m_EngineCamera.SetCameraAngle(&CameraAngle);
}

void CMHCamera::Process()
{
	ProcessCameraMoving();				// 墨皋扼 捞悼贸府
	ProcessCameraMode();				// 墨皋扼 葛靛俊 蝶弗 贸府
	RestrictCameraAngleDistance();		// 矫痢 力茄 贸府
	CalcCameraPosAngle();				// 墨皋扼 困摹 角力 拌魂
	CalcVibration();					// 柳悼 扁瓷 贸府(嘎阑锭 剐府绰芭)
	CalcShaking();						// 冻覆 扁瓷 贸府(瘤柳捞唱 顶匡覆殿)
	SetToEngineCamera();				// 角力 浚柳俊 悸泼

	// 捞悼捞搁 焊埃矫累
	if(m_GotoPosition != -1)
		Interpolation();
/* test
	else
	{
		if(m_CurPosition == eCP_CHARSEL)
		{
			m_CurPosition = eCP_CHARSEL;
			CAMERA->MoveStart(eCP_CHARMAKE);
		}
		else
		{
			m_CurPosition = eCP_CHARMAKE;
			CAMERA->MoveStart(eCP_CHARSEL);
		}
	}
//*/
}
void CMHCamera::Interpolation()
{
	float anX, anY;
	VECTOR3 Pos;
	float mtime = (gCurTime - m_MoveStartTime)* 0.001f;
	if(mtime > 1.f)		mtime = 1.f;
	float di = sin(gPHI*mtime*0.5f);

	anX = m_MovePos[m_CurPosition].m_AngleX + m_MovePos[2].m_AngleX*di;
	anY = m_MovePos[m_CurPosition].m_AngleY + m_MovePos[2].m_AngleY*di;
	
// 措眉 捞赤籍狼 沥眉绰 构矫促衬.. ぱぱ 捞芭 捞惑秦..
/*	anX.SetAngleDeg(m_MovePos[m_CurPosition].m_AngleX + m_MovePos[2].m_AngleX*di);
	anY.SetAngleDeg(m_MovePos[m_CurPosition].m_AngleY + m_MovePos[2].m_AngleY*di);	
	m_EngineCamera.SetCameraAngle(anX.ToRad(), anY.ToRad());*/


/*	VECTOR3 Angle;
	Angle.x = m_MovePos[m_CurPosition].m_AngleX + m_MovePos[2].m_AngleX*di;
	Angle.y = m_MovePos[m_CurPosition].m_AngleY + m_MovePos[2].m_AngleY*di;
	Angle.z = 0;
	m_EngineCamera.SetCameraAngle(&Angle);*/


// 捞扒 粱歹 犬牢捞 鞘夸
//	if(m_CurPosition == eCP_CHARMAKE)		di = sin(gPHI*mtime*0.5f);
//	else									di = cos(gPHI*mtime*0.5f);

	Pos.x = m_MovePos[m_CurPosition].m_Pivot.x + m_MovePos[2].m_Pivot.x*di;
	Pos.y = m_MovePos[m_CurPosition].m_Pivot.y + m_MovePos[2].m_Pivot.y*di;
	Pos.z = m_MovePos[m_CurPosition].m_Pivot.z + m_MovePos[2].m_Pivot.z*di;
//	m_EngineCamera.SetCameraPos(&Pos);

	// 捞吧肺 措眉.. ぱぱa
	InitCamera(m_CurCamera, anX, anY, 2000, &Pos);

	if(mtime == 1.f)
	{
		m_CurPosition = m_GotoPosition;
		m_GotoPosition = -1;
		m_bMoved = TRUE;
	}
}

void CMHCamera::ResetInterPolation()
{
	m_bMoved = FALSE;
	m_CurPosition = eCP_CHARSEL;
	m_GotoPosition = -1;
}

void CMHCamera::SetMovePos(int Index, MHCAMERAPOS* pCameraPos)
{
	memcpy(&m_MovePos[Index], pCameraPos, sizeof(MHCAMERAPOS));
}

void CMHCamera::MoveStart(int GotoIndex)
{
	m_GotoPosition = GotoIndex;
	m_MoveStartTime = gCurTime;

	float dx = m_MovePos[m_CurPosition].m_Pivot.x - m_MovePos[m_GotoPosition].m_Pivot.x;
	float dy = m_MovePos[m_CurPosition].m_Pivot.y - m_MovePos[m_GotoPosition].m_Pivot.y;
	float dz = m_MovePos[m_CurPosition].m_Pivot.z - m_MovePos[m_GotoPosition].m_Pivot.z;	
	float Dist = sqrtf(dx*dx + dy*dy + dz*dz);

	m_MoveTime = Dist / m_MoveSpeed;

	m_MovePos[2].m_AngleX = m_MovePos[m_GotoPosition].m_AngleX - m_MovePos[m_CurPosition].m_AngleX;
	m_MovePos[2].m_AngleY = m_MovePos[m_GotoPosition].m_AngleY - m_MovePos[m_CurPosition].m_AngleY;
	m_MovePos[2].m_Dist = m_MovePos[m_GotoPosition].m_Dist - m_MovePos[m_CurPosition].m_Dist;
	m_MovePos[2].m_Pivot.x = m_MovePos[m_GotoPosition].m_Pivot.x - m_MovePos[m_CurPosition].m_Pivot.x;
	m_MovePos[2].m_Pivot.y = m_MovePos[m_GotoPosition].m_Pivot.y - m_MovePos[m_CurPosition].m_Pivot.y;
	m_MovePos[2].m_Pivot.z = m_MovePos[m_GotoPosition].m_Pivot.z - m_MovePos[m_CurPosition].m_Pivot.z;
}


void CMHCamera::SetCameraFilter(CEngineObject* pEngineObj,float minAngle,float maxAngle)
{
	m_pCameraFilter = pEngineObj;
	m_MinAngle = minAngle;
	m_MaxAngle = maxAngle;
}

void CMHCamera::CalcCameraPosAngle()
{
	MHCAMERADESC* pCurCamera = &m_CameraDesc[m_CurCamera];

	static float x_rad = -1;
	static float y_rad = -1;
	static float lastdist = -1;
	static VECTOR3 HeroPos;
	float curx = pCurCamera->m_AngleX.ToRad();
	float cury = -pCurCamera->m_AngleY.ToRad();
	static float fHeight = 0;
	
	VECTOR3 pos;
	if(pCurCamera->m_bPivotObject)
		pCurCamera->m_pPivotObject->GetPosition(&pos);
	else
		pos = pCurCamera->m_PivotPos;


	if( x_rad == curx &&
		y_rad == cury &&
		HeroPos.x == pos.x &&
		HeroPos.y == pos.y &&
		HeroPos.z == pos.z &&
		lastdist == pCurCamera->m_fDistance &&
		!pCurCamera->m_bHeightChanging &&
		fHeight == m_fAddHeight && m_CurCameraMode != eCM_EyeView)
	{
		return;
	}
	

	x_rad = curx;
	y_rad = cury;
	HeroPos = pos;
	lastdist = pCurCamera->m_fDistance;

	fHeight = m_fAddHeight;

	if(m_pCameraFilter)
	{
		float tempx = x_rad > gPHI ? x_rad - 2*gPHI : x_rad;
		float alpha;
		if(tempx > m_MaxAngle)
			alpha = 0;
		else if(tempx < m_MinAngle)
			alpha = 1;
		else
			alpha = (m_MaxAngle - tempx) / (m_MaxAngle - m_MinAngle);
		m_pCameraFilter->SetAlpha(alpha);
	}
	
	MATRIX4 mx,my,mtotal;
	SetRotationXMatrix(&mx,x_rad);
	SetRotationYMatrix(&my,y_rad);
	MatrixMultiply2(&mtotal,&mx,&my);

	VECTOR3 dir;
	dir.x = 0;
	dir.y = 0;
	dir.z = 1;
	TransformVector3_VPTR2(&pCurCamera->m_CameraDir,&dir,&mtotal,1);
	TransformVector3_VPTR2(&pCurCamera->m_CameraDownVector,&m_DownVector,&mtotal,1);

	if( m_CurCameraMode == eCM_EyeView )
	{
//		pCurCamera->m_CameraPos = HeroPos;
//		pCurCamera->m_CameraPos.y += pCurCamera->m_CharHeight + m_fAddHeight;

		CalcFreeCamera();
	}
	else
	{
		pCurCamera->m_CameraPos = HeroPos - pCurCamera->m_CameraDir * pCurCamera->m_fDistance;
		pCurCamera->m_CameraPos.y += pCurCamera->m_CharHeight;
	}

	pCurCamera->m_CameraDownPositon = pCurCamera->m_CameraPos + pCurCamera->m_CameraDownVector;

	///////////////////////////////////////////////////////////////////////////
	// Check Collison by Tile
	/*
	if(MAP->CollisonCheck(&HeroPos,&pCurCamera->m_CameraPos,&temp) == TRUE)
	{
		float dx,dz;
		dx = pCurCamera->m_CameraPos.x - HeroPos.x;
		dz = pCurCamera->m_CameraPos.z - HeroPos.z;
		float distOri = sqrtf(dx*dx + dz*dz);
		dx = temp.x - HeroPos.x;
		dz = temp.z - HeroPos.z;
		float distCha = sqrtf(dx*dx + dz*dz);
		float fRate = distCha/distOri;

		float fHeight = pCurCamera->m_CameraPos.y - HeroPos.y;
		pCurCamera->m_CameraPos.x = temp.x;
		pCurCamera->m_CameraPos.y = fHeight * fRate;
		pCurCamera->m_CameraPos.z = temp.z;
	}
	*/

	// 父距俊 纳腐磐俊辑 墨皋扼肺 啊绰 饭捞甫 父甸绢 顶苞 面倒茄促搁
	// 弊 面倒 谅钎甫 m_CameraPos肺 悸泼茄促.
	float OriDist, ColDist;
	VECTOR3* pColPos;
	VECTOR3 HeroHead = HeroPos;

	HeroHead.y += pCurCamera->m_CharHeight;
	pColPos = m_EngineCamera.IsCollisonBetweenCamAndHero(&pCurCamera->m_CameraDownPositon,&HeroHead, &OriDist, &ColDist );
	if(pColPos && m_CurCameraMode != eCM_LOGIN)
	{
		if( ColDist < 260 )
			ColDist = 260;	//呈公 淋捞 登绰巴 规瘤:

		VECTOR3 HeroToCamDir = pCurCamera->m_CameraPos - HeroHead;
		HeroToCamDir = HeroToCamDir * ColDist / OriDist;
		pCurCamera->m_CameraPos = HeroHead + HeroToCamDir;
	}

}


void CMHCamera::CalcFreeCamera()
{
	MHCAMERADESC* pCurCamera = &m_CameraDesc[m_CurCamera];

	// 菊
	if( g_UserInput.GetKeyboard()->GetKeyPressed( KEY_W ) )
	{
		pCurCamera->m_CameraPos = pCurCamera->m_CameraPos + pCurCamera->m_CameraDir*40.f;
	}
	// 第
	else if( g_UserInput.GetKeyboard()->GetKeyPressed( KEY_S ) )
	{
		pCurCamera->m_CameraPos = pCurCamera->m_CameraPos - pCurCamera->m_CameraDir*40.f;
	}
	// 惑
	if( g_UserInput.GetKeyboard()->GetKeyPressed( KEY_Q ) )
	{
		pCurCamera->m_CameraPos.y += 15.f;
	}
	// 窍
	else if( g_UserInput.GetKeyboard()->GetKeyPressed( KEY_E ) )
	{
		pCurCamera->m_CameraPos.y -= 15.f;
	}
	// 谅
	if( g_UserInput.GetKeyboard()->GetKeyPressed( KEY_A ) )
	{
		VECTOR3 vOut, tv1, tv2;
		tv1 = pCurCamera->m_CameraDir;
		tv2 = pCurCamera->m_CameraDir;
		tv1.y += 100.f;
		Normalize(&tv1, &tv1);		
		CrossProduct(&vOut, &tv1, &tv2);
		pCurCamera->m_CameraPos = pCurCamera->m_CameraPos - vOut*40.f;
	}
	// 快
	else if( g_UserInput.GetKeyboard()->GetKeyPressed( KEY_D ) )
	{
		VECTOR3 vOut, tv1, tv2;
		tv1 = pCurCamera->m_CameraDir;
		tv2 = pCurCamera->m_CameraDir;
		tv1.y += 100.f;
		Normalize(&tv1, &tv1);
		CrossProduct(&vOut, &tv1, &tv2);
		pCurCamera->m_CameraPos = pCurCamera->m_CameraPos + vOut*40.f;
	}

	// 顶 墩瘤 臼档废..
	VECTOR3 pos;
	pCurCamera->m_pPivotObject->GetPosition( &pos );
	if(pCurCamera->m_CameraPos.y < pos.y+140.f)
		pCurCamera->m_CameraPos.y = pos.y+140.f;