#include "defines.h"
#include "camera.h"
#include "globals.h"

#ifndef CAMERATESTER
#include "camdata.h"
int m_PlayCamTime;
int m_PlayCamTrack;

void PreparePlayCam()
{
	m_PlayCamTime= 0;
	m_PlayCamTrack= 0;
}

void PlayCam( int iRealTimePassed, SCameraDefinition& Out )
{
	m_PlayCamTime+= iRealTimePassed;
	while( true )
	{
		SCameraKey* Keys= (SCameraKey*)c_BinaryCam;
		SActCamData camData;
		camData.m_iMaxStepCount= c_iCamLength[ m_PlayCamTrack ];
		if( m_PlayCamTrack > 0 )
		{
			camData.m_pCamData= Keys + c_iCamLength[ m_PlayCamTrack - 1 ];
			camData.m_iMaxStepCount-= c_iCamLength[ m_PlayCamTrack - 1 ];
		}
		else
		{
			camData.m_pCamData= Keys;
		}
		
		int Result= CalcCamGlobal( &camData, m_PlayCamTime, Out );
		if( Result == -1 )
		{
			return;
		}

		if( m_PlayCamTrack < c_iCamCount - 1 )
		{
			m_PlayCamTime= Result;
			m_PlayCamTrack++;
		}
		else
		{
			return;
		}
	}
}

#endif

#ifdef CAMERATESTER
void SCameraKey::ToString( std::string& strData )
{
	std::stringstream ss;
	ss << m_dwTime << "\t";
	ss << m_dwDemoTimeStart << "\t";
	ss << m_dwDemoTimeSpeed << "\t";
	ss << m_fPos[ 0 ] << "\t";
	ss << m_fPos[ 1 ] << "\t";
	ss << m_fPos[ 2 ] << "\t";
	ss << m_fRot[ 0 ] << "\t";
	ss << m_fRot[ 1 ] << "\t";
	ss << m_fRot[ 2 ] << "\t";
	ss << m_fDOF << "\t";
	ss << m_fFOV << "\t";
	ss << m_fTangentOffset[ 0 ] << "\t";
	ss << m_fTangentOffset[ 1 ] << "\t";
	strData= ss.str();
}

void SCameraKey::FromString( std::string& strData )
{
	Reset();
	std::stringstream ss;
	ss << strData;
	ss >> m_dwTime;
	ss >> m_dwDemoTimeStart;
	ss >> m_dwDemoTimeSpeed;
	ss >> m_fPos[ 0 ];
	ss >> m_fPos[ 1 ];
	ss >> m_fPos[ 2 ];
	ss >> m_fRot[ 0 ];
	ss >> m_fRot[ 1 ];
	ss >> m_fRot[ 2 ];
	ss >> m_fDOF;
	ss >> m_fFOV;
	ss >> m_fTangentOffset[ 0 ];
	ss >> m_fTangentOffset[ 1 ];
}

void SCameraKey::Reset()
{
	m_dwTime= g_iCamTickFactor;
	m_dwDemoTimeStart= 0;
	m_dwDemoTimeSpeed= 256;
	m_fPos[ 0 ]= 0;
	m_fPos[ 1 ]= 0;
	m_fPos[ 2 ]= 0;
	m_fRot[ 0 ]= 0;
	m_fRot[ 1 ]= 0;
	m_fRot[ 2 ]= 0;
	m_fDOF= 3.0f;
	m_fFOV= 1.0f;
	m_fTangentOffset[ 0 ]= 2;
	m_fTangentOffset[ 1 ]= -1;
}

void SCameraKey::FromCameraDefinition( SCameraDefinition& camDef )
{
	m_dwDemoTimeStart= camDef.m_iDemoTime;
	m_fPos[ 0 ]= camDef.m_vec3Pos.x;
	m_fPos[ 1 ]= camDef.m_vec3Pos.y;
	m_fPos[ 2 ]= camDef.m_vec3Pos.z;
	m_fRot[ 0 ]= camDef.m_vec3Rot.x;
	m_fRot[ 1 ]= camDef.m_vec3Rot.y;
	m_fRot[ 2 ]= camDef.m_vec3Rot.z;
	m_fDOF= camDef.m_fDOF;
	m_fFOV= camDef.m_fFOV;
}

void SCameraKey::ToCameraDefinition( SCameraDefinition& camDef )
{
	camDef.m_iDemoTime= m_dwDemoTimeStart;
	camDef.m_vec3Pos.x= m_fPos[ 0 ];
	camDef.m_vec3Pos.y= m_fPos[ 1 ];
	camDef.m_vec3Pos.z= m_fPos[ 2 ];
	camDef.m_vec3Rot.x= m_fRot[ 0 ];
	camDef.m_vec3Rot.y= m_fRot[ 1 ];
	camDef.m_vec3Rot.z= m_fRot[ 2 ];
	camDef.m_fDOF= m_fDOF;
	camDef.m_fFOV= m_fFOV;
}

#include <vector>
std::vector<std::vector<SCameraKey>> g_CamKeyEditData;
std::vector< int > g_CamTrackStarts;
typedef std::vector<SCameraKey> SCameraTrack;

int GetCamTrackCount()
{
	return (int)g_CamKeyEditData.size();
}
std::vector<SCameraKey>& GetCamTrack( int iIndex )
{
	return g_CamKeyEditData[ iIndex ];
}

void drawDebugText( char* pcString, int iX, int iY );

void ReadCameraTrack( char* pcFileName, int iTrack )
{
	while( GetCamTrackCount() <= iTrack )
	{
		std::vector<SCameraKey> Empty;
		g_CamKeyEditData.push_back( Empty );
	}

	std::vector<SCameraKey>& CamTrack= GetCamTrack( iTrack );

	FrameWork::TextFileReader tfrData;
	if( !tfrData.read( pcFileName ) )
	{
		return;
	}

	for( int i= 0; i < (int)tfrData.getFileLines().size(); ++i )
	{
		std::string strAct= tfrData.getFileLines()[ i ];
		if( strAct != "" )
		{
			SCameraKey camKey;
			camKey.FromString( strAct );
			CamTrack.push_back( camKey );
		}
	}

	CalcCamTrackStarts();
	return;
}

void WriteCameraTrack( char* pcFileName, int iTrack )
{
	if( GetCamTrackCount() <= iTrack )
	{
		return;
	}

	std::vector<SCameraKey>& CamTrack= GetCamTrack( iTrack );

	std::ofstream ofsFile( pcFileName );
	for( size_t i= 0; i < CamTrack.size(); ++i )
	{
		std::string strKey;
		CamTrack[ i ].ToString( strKey );
		ofsFile << strKey << "\n";
	}
	return;
}

void ReadCamera();

void WriteCameraHeader()
{
	/*static bool bWritten= false;
	if( bWritten )
	{
	return;
	}
	bWritten= true;*/

	std::ofstream ofsFile( "camdata.h" );

	if( !ofsFile.is_open() )
	{
		return;
	}


	ofsFile << "const int c_iCamCount= " << g_CamKeyEditData.size() << ";\n";
	ofsFile << "\n";

	ofsFile << "const int c_iCamLength[c_iCamCount]= " << "\n";
	ofsFile << "{\n";

	int iFullCount= 0;
	for( int i= 0; i < (int)g_CamKeyEditData.size(); ++i )
	{
		iFullCount+= (int)g_CamKeyEditData[ i ].size();
		char pcSpecial[ 1024 ];
		sprintf_s(	pcSpecial, 
			1024,
			"\t%d,\n",
			iFullCount );
		ofsFile << pcSpecial;
	}
	ofsFile << "};\n";
	ofsFile << "\n";

	ofsFile << "const DWORD c_BinaryCam[]= " << "\n";
	ofsFile << "{\n";

	for( int i= 0; i < (int)g_CamKeyEditData.size(); ++i )
	{
		int dwords= g_CamKeyEditData[ i ].size() * sizeof( SCameraKey ) / 4;
		if( dwords > 0 )
		{
			DWORD* pdwData= (DWORD*)&(g_CamKeyEditData[ i ][ 0 ]);
			for( int j= 0; j < dwords; ++j )
			{
				char pcSpecial[ 1024 ];
				sprintf_s(	pcSpecial, 
					1024,
					"\t%d,\n",
					pdwData[ j ] );
				ofsFile << pcSpecial;
			}
		}
	}

	ofsFile << "};\n";
	ofsFile << "\n";
}

void ReadCameraAll()
{
	char pcName[]= "cam/00_cam.txt";

	for( int i= 0; i < c_iCamCount; ++i )
	{
		pcName[ 4 ] = i / 10 + '0';
		pcName[ 5 ] = i % 10 + '0';

		ReadCameraTrack( pcName, i );
	}
	while( g_CamKeyEditData.size() > 0 && g_CamKeyEditData.back().size() == 0 )
	{
		g_CamKeyEditData.pop_back();
	}
}

void WriteCameraAll()
{
	char pcName[]= "cam/00_cam.txt";

	for( int i= 0; i < c_iCamCount; ++i )
	{
		pcName[ 4 ] = i / 10 + '0';
		pcName[ 5 ] = i % 10 + '0';

		WriteCameraTrack( pcName, i );
	}

	WriteCameraHeader();
}

enum CameraMode
{
	CM_INTERPOLATED,
	CM_PAUSE,
	CM_FREE,
};
enum MenuData
{
	MD_CHANGELENGTH,
	MD_CHANGESPEED,
	MD_CHANGESTART,
	MD_CHANGETANGENTA,
	MD_CHANGETANGENTB,
	MD_CHANGESTEP,
	MD_CHANGETRACK,
	MD_LOCKTRACK,
	MD_ADDTRACK,
	MD_DELETETRACK,
	MD_CLEARTRACK,
	MD_MOVETRACK,
	MD_MAKETIMECONTINUOS,
	MD_SAVE,
	MD_RELOAD
};

CameraMode m_CamMode= CM_FREE;
SCameraDefinition m_EditCam;
int m_iCurrentStep;
int m_iCurrentTrack;
int	m_iEditMenu;
float m_fCamTimeSpeed;
bool m_bLockCurrentTrack;

int m_iRealTime;

std::vector<SCameraKey>& GetEditTrack()
{
	while( GetCamTrackCount() <= m_iCurrentTrack )
	{
		g_CamKeyEditData.push_back( SCameraTrack() );
		CalcCamTrackStarts();
	}
	return GetCamTrack( m_iCurrentTrack );
}

int FillDataFromEdit(SActCamData& data)
{
	int iTrack= 0;
	int iTimeOffset= 0;
	for( ;iTrack < (int)g_CamTrackStarts.size() - 1; ++iTrack )
	{
		if( g_CamTrackStarts[ iTrack ] > m_iRealTime )
		{
			break;
		}
	}
	if( iTrack > 0 )
	{
		iTimeOffset= g_CamTrackStarts[ iTrack - 1 ];
	}
	SCameraTrack& track= g_CamKeyEditData[ iTrack ];
	data.m_iMaxStepCount= track.size();
	if( data.m_iMaxStepCount > 0 )
	{
		data.m_pCamData= &(track[ 0 ]);
	}
	else
	{
		data.m_pCamData= NULL;
	}
	return m_iRealTime - iTimeOffset;
}

void InterpolateCamGlobal( int iRealTimePassed, SCameraDefinition& CamData )
{
	TickFreeCam( iRealTimePassed );
	{
		iRealTimePassed= (int)((float)iRealTimePassed * m_fCamTimeSpeed);
	}

	m_iRealTime+= iRealTimePassed;
	int RealLow= 0;
	int RealHigh= 0;
	if( g_CamTrackStarts.size() > 0 )
	{
		RealHigh= g_CamTrackStarts.back();
	}
	if( m_bLockCurrentTrack )
	{
		if( m_iCurrentTrack > 0 )
		{
			RealLow= g_CamTrackStarts[ m_iCurrentTrack - 1 ];
		}
		RealHigh= g_CamTrackStarts[ m_iCurrentTrack ];
	}
	m_iRealTime= min( m_iRealTime, RealHigh - 1 );
	m_iRealTime= max( m_iRealTime, RealLow );

	SActCamData data;
	int iTime= FillDataFromEdit( data );
	if( m_CamMode == CM_FREE )
	{
		CamData= m_EditCam;
		CamData.m_iDemoTime+= iRealTimePassed;
	}
	else
	{
		CalcCamGlobal( &data, iTime, CamData );
		SetStepFromTime();
	}
	m_EditCam.m_iDemoTime= CamData.m_iDemoTime;
}

/*void CameraControl::FillDummyCam( SActCamData& CamData )
{
	CamData.m_fCurPos[ 0 ]= 0.0f;
	CamData.m_fCurPos[ 1 ]= 0.0f;
	CamData.m_fCurPos[ 2 ]= 0.0f;

	CamData.m_fCurRot[ 0 ]= 0.0f;
	CamData.m_fCurRot[ 1 ]= 0.0f;
	CamData.m_fCurRot[ 2 ]= 0.0f;

	CamData.m_iDemoTime= 0;

	CamData.m_iRealTimeFull= m_iRealTimeFull;
	CamData.m_iRealTimePart= 0;
	CamData.m_iSceneHint= 0;
}

void CameraControl::FillDummyCam( SActCamData& CamData, SCameraKey& CurStep )
{
	CamData.m_fCurPos[ 0 ]= CurStep.m_fPos[ 0 ];
	CamData.m_fCurPos[ 1 ]= CurStep.m_fPos[ 1 ];
	CamData.m_fCurPos[ 2 ]= CurStep.m_fPos[ 2 ];

	CamData.m_fCurRot[ 0 ]= CurStep.m_fRot[ 0 ];
	CamData.m_fCurRot[ 1 ]= CurStep.m_fRot[ 1 ];
	CamData.m_fCurRot[ 2 ]= CurStep.m_fRot[ 2 ];

	CamData.m_iDemoTime= CurStep.m_iDemoTimeStart;
	//CamData.m_iDemoTime+= CurStep.m_iRealTimeLength * CurStep.m_iDemoTimeSpeed / 256;

	CamData.m_iRealTimeFull= m_iRealTimeFull;
	CamData.m_iRealTimePart= 0;
}*/


void DrawCameraDebugOutput()
{
	char pcBuffer[ 1024 ];
	pcBuffer[ 0 ]= 0;
	bool bHelp= EditorHelp::m_KeyDown[ VK_F1 ];
	if( bHelp )
	{
		int l= 0;
		EditorHelp::PrintDebug( l++,0,	"F1 - Hilfeanzeige aktivieren" );
		EditorHelp::PrintDebug( l++,0,	"WASD - Kamera bewegen                    Mouse + mittlere oder rechte Taste - Kamera rotieren" );
		EditorHelp::PrintDebug( l++,0,	"FV - Kamera auf/ abbewegen               Home - Kamera zuruecksetzen" );
		EditorHelp::PrintDebug( l++,0,	"QE - Kamera um Sichtachse rotieren       Z - Reset" );
		EditorHelp::PrintDebug( l++,0,	"YH - Fov aendern                         TG - DOF Fokusebene" );
#ifdef CAMERAEDIT
		l++;
		EditorHelp::PrintDebug( l++,0,	"Page Up/Down - KameraSchritt wechseln" );
		EditorHelp::PrintDebug( l++,0,	"Space - KameraSchritt hinzufuegen" );
		EditorHelp::PrintDebug( l++,0,	"Tab - Kameraposition des aktuellen Schrittes setzen" );
		EditorHelp::PrintDebug( l++,0,	"Shift+Space - aktuellen KameraSchritt verschieben" );
		EditorHelp::PrintDebug( l++,0,	"Entfernen - aktuellen KameraSchritt loeschen" );
		EditorHelp::PrintDebug( l++,0,	"F9 - Kameraedit/ Kameraplay wechseln" );
		EditorHelp::PrintDebug( l++,0,	"F7 - Kamerabewegen abspielen/pausieren" );
		EditorHelp::PrintDebug( l++,0,	"F6/F8 - vor/ zurueckspulen" );
		EditorHelp::PrintDebug( l++,0,	"F5 - auf Anfang setzen" );
#endif
		return;
	}

	if( EditorHelp::m_KeyPressed[ VK_F2 ] )
	{
		EditorHelp::m_bShowDebugData= !EditorHelp::m_bShowDebugData;
	}

#ifdef CAMERAEDIT
	sprintf_s( pcBuffer,
		"Cam: %7.3f,%7.3f,%7.3f",
		m_EditCam.m_vec3Pos.x,
		m_EditCam.m_vec3Pos.y,
		m_EditCam.m_vec3Pos.z );

	EditorHelp::PrintDebug( 1,80, pcBuffer );

	sprintf_s( pcBuffer,
		"Rot: %7.3f,%7.3f,%7.3f",
		m_EditCam.m_vec3Rot.x,
		m_EditCam.m_vec3Rot.y,
		m_EditCam.m_vec3Rot.z );
	EditorHelp::PrintDebug( 2,80, pcBuffer );
	
	sprintf_s( pcBuffer,
		"DOF: %7.3f FOV: %7.3f",
		m_EditCam.m_fDOF,
		m_EditCam.m_fFOV );
	EditorHelp::PrintDebug( 3,80, pcBuffer );

	DrawEditOutput();
#endif
}

bool IsFreeCam()
{
	return m_CamMode == CM_FREE;
}

void DrawEditOutput()
{
	char pcBuffer[ 1024 ];
	if( m_CamMode == CM_FREE )
	{
		EditorHelp::PrintDebug( 46 , 105, "Cam-Edit" );
		sprintf_s(	pcBuffer,
					"DemoTime: %8.4f",
					(float)m_EditCam.m_iDemoTime / (float)g_iCamTickFactor );
		EditorHelp::PrintDebug( 45, 95, pcBuffer );
	}
	else
	{
		sprintf_s( pcBuffer,
			"%5.1fx %2s",
			m_fCamTimeSpeed,
			( m_CamMode == CM_PAUSE ) ? "||" : "|>" );
		EditorHelp::PrintDebug( 46, 104, pcBuffer );

		int iDemoTime= m_EditCam.m_iDemoTime;

		/*if( m_iCurrentTrack < (int)m_CameraData.size() )
		{
			SCameraTrack& curTrack= m_CameraData[ m_iCurrentTrack ];

			if( m_iCurrentStep < (int)curTrack.size() )
			{
				SCameraKey& curStep= curTrack[ m_iCurrentStep ];
				iDemoTime= curStep.m_iDemoTimeStart;
				iDemoTime+= m_iRealTimePart * curStep.m_iDemoTimeSpeed / 256;
			}
		}*/

		sprintf_s(	pcBuffer,
					"DemoTime: %8.4f",
					(float)iDemoTime / (float)g_iCamTickFactor );
		EditorHelp::PrintDebug( 45, 95, pcBuffer );
		sprintf_s(	pcBuffer,
					"Time: %8.4f",
					(float)m_iRealTime / (float)g_iCamTickFactor );
		EditorHelp::PrintDebug( 44, 99, pcBuffer );
	}

	int iStepCount= 0;
	{
		iStepCount= GetEditTrack().size();

		if( m_iCurrentStep < (int)GetEditTrack().size() )
		{
			SCameraKey& curStep= GetEditTrack()[ m_iCurrentStep ];

			float fSpeed1= 0.0f;
			float fSpeed2= 0.0f;

			/*if( m_iCurrentStep > 1 && m_iCurrentStep < iStepCount - 1 )
			{
				SActCamData Res;
				Res.m_pCamData= &(GetEditTrack()[ 0 ]);
				Res.m_iMaxStepCount= GetEditTrack().size();

				InterpolateCamLocal(
					Res,
					m_iCurrentStep - 1,
					curTrack[ m_iCurrentStep - 1 ].m_iRealTimeLength - g_iCamTickFactor / 128,
					curTrack, 
					m_iCurrentStep - 1,
					Res );

				D3DXVECTOR3 vDist=
					*( (D3DXVECTOR3*)&(curStep.m_fPos )) - *( (D3DXVECTOR3*)&(Res.m_fCurPos));

				fSpeed1= D3DXVec3Length( &vDist ) * 128.0f;
			}
			if( m_iCurrentStep > 0 && m_iCurrentStep < iStepCount - 2 )
			{
				SActCamData Res;
				InterpolateCamLocal(
					SAMPLEFREQUENCY / 128,
					curTrack, 
					m_iCurrentStep,
					Res );


				D3DXVECTOR3 vDist=
					*( (D3DXVECTOR3*)&(curStep.m_fPos )) - *( (D3DXVECTOR3*)&(Res.m_fCurPos));

				fSpeed2= D3DXVec3Length( &vDist ) * 128.0f;
			}*/


			sprintf_s( pcBuffer,
				"Tangente Vor: %7.4f  (Speed: %6.5f)",
				curStep.m_fTangentOffset[ 0 ] - 2.0f,
				fSpeed1 );
			EditorHelp::PrintDebug( 46 - MD_CHANGETANGENTA, 2, pcBuffer );

			sprintf_s( pcBuffer,
				"Tangente Nach: %7.4f  (Speed: %6.5f)",
				curStep.m_fTangentOffset[ 1 ] + 1.0f,
				fSpeed2 );
			EditorHelp::PrintDebug( 46 - MD_CHANGETANGENTB, 2, pcBuffer );

			int iTimeEnd= 
				curStep.m_dwDemoTimeStart + curStep.m_dwTime * curStep.m_dwDemoTimeSpeed / 256;
			sprintf_s( pcBuffer,
				"Time: %8.4f-%8.4f  (ENTER -> auto)",
				(float)curStep.m_dwDemoTimeStart / (float)g_iCamTickFactor,
				(float)iTimeEnd / (float)g_iCamTickFactor );
			EditorHelp::PrintDebug( 46 - MD_CHANGESTART, 2, pcBuffer );
			sprintf_s( pcBuffer,
				"TimeSpeed: %8.4f  (ENTER -> auto)",
				(float)curStep.m_dwDemoTimeSpeed / 256.0f );
			EditorHelp::PrintDebug( 46 - MD_CHANGESPEED, 2, pcBuffer );
			sprintf_s( pcBuffer,
				"Laenge: %8.4f  (ENTER -> auto)",
				(float)curStep.m_dwTime / (float)g_iCamTickFactor );
			EditorHelp::PrintDebug( 46 - MD_CHANGELENGTH, 2, pcBuffer );
		}
	}
	sprintf_s( pcBuffer,
		"Step:  %02d/%02d",
		m_iCurrentStep + 1,
		iStepCount );
	EditorHelp::PrintDebug( 46 - MD_CHANGESTEP,2, pcBuffer );
	sprintf_s( pcBuffer,
		"Track: %03d/%03d",
		m_iCurrentTrack + 1,
		GetCamTrackCount() );
	EditorHelp::PrintDebug( 46 - MD_CHANGETRACK,2, pcBuffer );

	if( m_bLockCurrentTrack )
	{
		EditorHelp::PrintDebug( 46 - MD_LOCKTRACK, 2, "x" );
	}

	const int iNormal= 7;
	const int iExtended= 15;
	static char* pcMenu[]=
	{
		")",
		")",
		")",
		")",
		")",
		")",
		")",
		"( )Lock Track",
		"Add Track",
		"Delete Track",
		"Clear Track",
		"Move Track",
		"Zeiten ab dem Step fixen",
		"Save Data",
		"Reload Data",
	};

	for( int i= 0; i < iExtended; ++i )
	{
		if( i >= iNormal && m_iEditMenu < iNormal )
		{
			EditorHelp::PrintDebug( 46 - iNormal, 0, "^^" );
			break;
		}
		if( m_iEditMenu == i )
		{
			EditorHelp::PrintDebug( 46 - i, 0, ">" );
		}
		EditorHelp::PrintDebug( 46 - i, 1, pcMenu[ i ] );
	}

	if( EditorHelp::m_KeyPressed[ VK_UP ] )
	{
		m_iEditMenu++;
	}
	if( EditorHelp::m_KeyPressed[ VK_DOWN ] )
	{
		m_iEditMenu--;
	}
	m_iEditMenu= ( m_iEditMenu + iExtended ) % iExtended;
}

void TickFreeCam( int iTime )
{
#ifdef CAMERAEDIT
	if( EditorHelp::m_KeyPressed[ VK_SPACE ] )
	{
		SetStep();
	}
	if( EditorHelp::m_KeyPressed[ VK_TAB ] )
	{
		SetStepCamera();
	}
	if( EditorHelp::m_KeyPressed[ VK_DELETE ] )
	{
		RemoveStep();
	}
	
	if( EditorHelp::m_KeyPressed[ VK_F9 ] )
	{
		if( CM_FREE == m_CamMode )
		{
			m_CamMode= CM_PAUSE;

			m_iRealTime= CalculateRealTime();
			m_EditCam.m_iDemoTime= CalculateDemoTime();
		}
		else
		{
			m_CamMode= CM_FREE;
			SCameraTrack& curTrack= GetEditTrack();

			if( m_iCurrentStep < (int)curTrack.size() )
			{
				SCameraKey& curStep= curTrack[ m_iCurrentStep ];
				curStep.ToCameraDefinition( m_EditCam );
			}
		}
	}

	if( EditorHelp::m_KeyPressed[ VK_F7 ] )
	{
		if( CM_FREE == m_CamMode )
		{
			m_CamMode= CM_INTERPOLATED;

			m_iRealTime= CalculateRealTime();
			m_EditCam.m_iDemoTime= CalculateDemoTime();
		}
		else if( CM_INTERPOLATED == m_CamMode )
		{
			m_CamMode= CM_PAUSE;
		}
		else
		{
			m_CamMode= CM_INTERPOLATED;
		}
	}
	if( EditorHelp::m_KeyPressed[ VK_F5 ] )
	{
		if( CM_FREE != m_CamMode )
		{
			m_iCurrentStep= 0;
			if( !m_bLockCurrentTrack )
			{
				m_iCurrentTrack= 0;
			}
			m_iRealTime= CalculateRealTime();
			m_EditCam.m_iDemoTime= CalculateDemoTime();
		}
	}
	if( CM_INTERPOLATED == m_CamMode )
	{
		m_fCamTimeSpeed= 1.0f;
	}
	else
	{
		m_fCamTimeSpeed= 0.0f;
	}
	{
		float fCamSpeed= EditorHelp::GetKeyDownVal(	0.0f,
													VK_F8,
													VK_F6,
													4.0f,
													0.5f,
													12.0f );

		if( fCamSpeed != 0.0f )
		{
			m_fCamTimeSpeed= fCamSpeed;
		}
	}

	ChangeStepKeys( VK_PRIOR, VK_NEXT );

	switch( m_iEditMenu )
	{
	case MD_CHANGELENGTH:
		ChangeLength();
		break;
	case MD_CHANGESPEED:
		ChangeSpeed();
		break;
	case MD_CHANGESTART:
		ChangeStart();
		break;
	case MD_CHANGETANGENTA:
		ChangeTangent( 0 );
		break;
	case MD_CHANGETANGENTB:
		ChangeTangent( 1 );
		break;
	case MD_CHANGESTEP:
		ChangeStep();
		break;
	/*case MD_CHANGEHINT:
		ChangeHint();
		break;*/
	case MD_CHANGETRACK:
		ChangeTrack();
		break;
	case MD_LOCKTRACK:
		LockTrack();
		break;
	case MD_ADDTRACK:
		AddTrack();
		break;
	case MD_DELETETRACK:
		DeleteTrack();
		break;
	case MD_CLEARTRACK:
		ClearTrack();
		break;
	case MD_MOVETRACK:
		MoveTrack();
		break;
	case MD_MAKETIMECONTINUOS:
		MakeTimeContinous();
		break;
	case MD_SAVE:
		Save();
		break;
	case MD_RELOAD:
		Reload();
		break;
	}
#endif
#ifdef CAMERAEDIT
	if( EditorHelp::m_KeyDown[ VK_HOME ] )
	{
		HomeCam();
	}

	static POINT OldCurPos;
	POINT CurPos;
	GetCursorPos( &CurPos );

	if( EditorHelp::m_KeyDown[ VK_MBUTTON ] || EditorHelp::m_KeyDown[ VK_RBUTTON ] )
	{
		m_EditCam.m_vec3Rot.x+= 0.003f * ( OldCurPos.x - CurPos.x );
		m_EditCam.m_vec3Rot.y-= 0.003f * ( OldCurPos.y - CurPos.y );
		m_EditCam.m_vec3Rot.y= max( m_EditCam.m_vec3Rot.y, -1.56f );
		m_EditCam.m_vec3Rot.y= min( m_EditCam.m_vec3Rot.y, 1.56f );
	}
	OldCurPos= CurPos;

	float fSpeed= (float)iTime / 4096.0f;
	fSpeed= fabs( fSpeed );
	float fSpeedSlow= fSpeed / 4.0f;
	float fSpeedFast= fSpeed * 4.0f;

	float fTurnZ= EditorHelp::GetKeyDownVal(	0.0f,
												'Q',
												'E',
												fSpeed / 4.0f,
												fSpeedSlow / 4.0f,
												fSpeedFast / 4.0f );
	m_EditCam.m_vec3Rot.z+= fTurnZ;
	if( EditorHelp::m_KeyPressed[ 'Z' ] )
	{
		m_EditCam.m_vec3Rot.z= 0.0f;
	}

	float fForward= EditorHelp::GetKeyDownVal(	0.0f,
												'W',
												'S',
												fSpeed,
												fSpeedSlow,
												fSpeedFast );
	float fLeftRight= EditorHelp::GetKeyDownVal(	0.0f,
													'D',
													'A',
													fSpeed,
													fSpeedSlow,
													fSpeedFast );
	float fUpDown= EditorHelp::GetKeyDownVal(	0.0f,
												'F',
												'V',
												fSpeed,
												fSpeedSlow,
												fSpeedFast );

	D3DXMATRIX CamMat;
	D3DXMatrixRotationYawPitchRoll( &CamMat,
									-m_EditCam.m_vec3Rot.x,
									m_EditCam.m_vec3Rot.y,
									m_EditCam.m_vec3Rot.z );


	/*g_CamFront= D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
	g_CamUp= D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
	g_CamRight= D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
	D3DXVec3TransformCoord( &g_CamFront, &g_CamFront, CamMat );
	D3DXVec3TransformCoord( &g_CamUp, &g_CamUp, CamMat );
	D3DXVec3TransformCoord( &g_CamRight, &g_CamRight, CamMat );*/

	D3DXVECTOR3 CamMove(fLeftRight, fUpDown, fForward );
	D3DXVec3TransformCoord( &CamMove, &CamMove, &CamMat );

	m_EditCam.m_vec3Pos+= CamMove;

	float fFOV= EditorHelp::GetKeyDownVal(	0.0f,
		'Y',
		'H',
		1.0f / 64.0f,
		1.0f / 256.0f,
		1.0f / 16.0f );
	float fDOF= EditorHelp::GetKeyDownVal(	0.0f,
		'T',
		'G',
		1.0f / 32.0f,
		1.0f / 128.0f,
		1.0f / 8.0f );

	m_EditCam.m_fFOV+= fFOV;
	m_EditCam.m_fFOV= max( m_EditCam.m_fFOV, 1.0f/ 16.0f );
	m_EditCam.m_fFOV= min( m_EditCam.m_fFOV, 16.0f );

	m_EditCam.m_fDOF+= fDOF;
	m_EditCam.m_fDOF= max( m_EditCam.m_fDOF, -1.0f/ 16.0f );
	m_EditCam.m_fDOF= min( m_EditCam.m_fDOF, 1024.0f );
#endif
}

void SetStepCamera()
{
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		SCameraKey& curStep= curTrack[ m_iCurrentStep ];
		int iOldTime= curStep.m_dwDemoTimeStart;
		curStep.FromCameraDefinition( m_EditCam );
		curStep.m_dwDemoTimeStart= iOldTime;

		if( m_iCurrentStep < (int)curTrack.size() - 1 )
		{
			m_iCurrentStep++;
			SCameraKey& nextStep= curTrack[ m_iCurrentStep ];
			m_EditCam.m_iDemoTime= nextStep.m_dwDemoTimeStart;
		}
	}
}

void SetStep()
{
	bool bAdd= false;
	SCameraTrack& curTrack= GetEditTrack();
	if( !EditorHelp::m_KeyDown[ VK_SHIFT ] && !EditorHelp::m_KeyDown[ VK_CONTROL ] )
	{
		bAdd= true;
		if( m_iCurrentStep < (int)curTrack.size() )
		{
			SCameraKey newKey;
			newKey.Reset();
			curTrack.insert( curTrack.begin() + m_iCurrentStep + 1, newKey );
			m_iCurrentStep++;
		}
		else
		{
			SCameraKey newKey;
			newKey.Reset();
			curTrack.push_back( newKey );
			m_iCurrentStep= (int)curTrack.size() - 1;
		}
	}
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		SCameraKey& curStep= curTrack[ m_iCurrentStep ];
		curStep.FromCameraDefinition( m_EditCam );
	
		if( bAdd )
		{
			if( m_iCurrentStep > 0 )
			{
				SCameraKey& prevStep= curTrack[ m_iCurrentStep - 1];
				curStep.m_dwDemoTimeSpeed= prevStep.m_dwDemoTimeSpeed;
				curStep.m_dwTime= prevStep.m_dwTime;
			}

			int iPrevStart= curStep.m_dwDemoTimeStart;
			int iPrevSpeed= curStep.m_dwDemoTimeSpeed;
			int iPrevLength= curStep.m_dwTime;
			m_EditCam.m_iDemoTime= iPrevLength * iPrevSpeed / 256 + iPrevStart;
		}
	}
	CalcCamTrackStarts();
}

void RemoveStep()
{
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		curTrack.erase( curTrack.begin() + m_iCurrentStep );
		if( m_iCurrentStep == curTrack.size() && curTrack.size() > 0 )
		{
			m_iCurrentStep--;
		}
		EditToStep();
	}
}

void MakeTimeContinous()
{
	if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
	{
		SCameraTrack& curTrack= GetEditTrack();

		for( size_t i= m_iCurrentStep + 1; i < curTrack.size(); ++i )
		{
			SCameraKey& curStep= curTrack[ i ];
			if( i > 1 )
			{
				int iPrevStart= curTrack[ i - 1 ].m_dwDemoTimeStart;
				int iPrevSpeed= curTrack[ i - 1 ].m_dwDemoTimeSpeed;
				int iPrevLength= curTrack[ i - 1 ].m_dwTime;
				curStep.m_dwDemoTimeStart= iPrevLength * iPrevSpeed / 256 + iPrevStart;
			}
			else
			{
				curStep.m_dwDemoTimeStart= 0;
			}
		}
	}

	CalcCamTrackStarts();
}

void DeleteTrack()
{
	if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
	{
		if( m_iCurrentTrack < GetCamTrackCount() && 0 < GetCamTrackCount() )
		{
			//SaveBackup();
			g_CamKeyEditData.erase( g_CamKeyEditData.begin() + m_iCurrentTrack );
			VerifyStep();
		}
	}
}

void MoveTrack()
{
	if( EditorHelp::m_KeyPressed[ VK_RIGHT ] )
	{
		if( m_iCurrentTrack < (int)GetCamTrackCount() - 1)
		{
			SCameraTrack curTrack= g_CamKeyEditData[ m_iCurrentTrack ];
			g_CamKeyEditData[ m_iCurrentTrack ]= g_CamKeyEditData[ m_iCurrentTrack + 1 ];
			g_CamKeyEditData[ m_iCurrentTrack + 1 ]= curTrack;
			m_iCurrentTrack++;
			VerifyStep();
			CalcCamTrackStarts();
		}
	}
	if( EditorHelp::m_KeyPressed[ VK_LEFT ] )
	{
		if( m_iCurrentTrack > 0 && m_iCurrentTrack < (int)GetCamTrackCount() )
		{
			SCameraTrack curTrack= g_CamKeyEditData[ m_iCurrentTrack ];
			g_CamKeyEditData[ m_iCurrentTrack ]= g_CamKeyEditData[ m_iCurrentTrack - 1 ];
			g_CamKeyEditData[ m_iCurrentTrack - 1 ]= curTrack;
			m_iCurrentTrack--;
			VerifyStep();
			CalcCamTrackStarts();
		}
	}
}

void ClearTrack()
{
	if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
	{
		if( m_iCurrentTrack < (int)g_CamKeyEditData.size() && !g_CamKeyEditData.empty() )
		{
			//SaveBackup();
			g_CamKeyEditData[ m_iCurrentTrack ]= SCameraTrack();
			VerifyStep();
		}
	}
}

void AddTrack()
{
	if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
	{
		if( m_iCurrentTrack < GetCamTrackCount() )
		{
			g_CamKeyEditData.insert( g_CamKeyEditData.begin() + m_iCurrentTrack + 1, SCameraTrack() );
			m_iCurrentTrack++;
		}
		else
		{
			g_CamKeyEditData.push_back( SCameraTrack() );
			m_iCurrentTrack= GetCamTrackCount() - 1;
		}

		CalcCamTrackStarts();
		VerifyStep();
	}
}

void LockTrack()
{
	if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
	{
		m_bLockCurrentTrack= !m_bLockCurrentTrack;
	}
}

void ChangeTrack()
{
	bool bChanged= false;
	if( EditorHelp::m_KeyPressed[ VK_RIGHT ] )
	{
		if( m_iCurrentTrack < GetCamTrackCount() - 1 )
		{
			m_iCurrentTrack++;
		}
		else
		{
			m_iCurrentTrack= 0;
		}
		bChanged= true;
	}
	if( EditorHelp::m_KeyPressed[ VK_LEFT ] )
	{
		if( m_iCurrentTrack > 0 )
		{
			m_iCurrentTrack--;
		}
		else
		{
			m_iCurrentTrack= GetCamTrackCount() - 1;
		}
		bChanged= true;
	}

	if( bChanged )
	{
		m_iRealTime= CalculateRealTime();
		VerifyStep();
	}
}

void ChangeStepKeys( int iPrior, int iNext )
{
	SCameraTrack& curTrack= GetEditTrack();
	bool bChanged= false;
	if( EditorHelp::m_KeyPressed[ iPrior ] && m_iCurrentStep < (int)curTrack.size() - 1 )
	{
		m_iCurrentStep++;
		bChanged= true;
	}
	if( EditorHelp::m_KeyPressed[ iNext ] && m_iCurrentStep > 0 )
	{
		m_iCurrentStep--;
		bChanged= true;
	}

	if( bChanged && !EditorHelp::m_KeyDown[ VK_SHIFT ] && !EditorHelp::m_KeyDown[ VK_CONTROL ] )
	{
		EditToStep();
	}

	if( bChanged )
	{
		m_iRealTime= CalculateRealTime();
	}
}

void ChangeStep()
{
	ChangeStepKeys( VK_RIGHT, VK_LEFT );
}


void EditToStep()
{
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		SCameraKey& curStep= curTrack[ m_iCurrentStep ];
		curStep.ToCameraDefinition( m_EditCam );
	}
}

void VerifyStep()
{
	SCameraTrack& curTrack= GetEditTrack();

	if( m_iCurrentStep >= (int)curTrack.size() )
	{
		m_iCurrentStep= (int)curTrack.size() - 1;
	}
	if( m_iCurrentStep < 0 )
	{
		m_iCurrentStep= 0;
	}
	EditToStep();
}

void ChangeTangent( int iCount )
{
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		SCameraKey& curStep= curTrack[ m_iCurrentStep ];

		curStep.m_fTangentOffset[ iCount ]=
			EditorHelp::GetKeyPressedVal(	curStep.m_fTangentOffset[ iCount ],
			VK_RIGHT,
			VK_LEFT,
			1.0f / 32.0f,
			1.0f / 256.0f,
			1.0f / 4.0f );
	}
}

void ChangeStart()
{
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		SCameraKey& curStep= curTrack[ m_iCurrentStep ];

		curStep.m_dwDemoTimeStart=
			(int)EditorHelp::GetKeyPressedVal(	(float)curStep.m_dwDemoTimeStart,
			VK_RIGHT,
			VK_LEFT,
			(float)( g_iCamTickFactor / 16),
			(float)( g_iCamTickFactor / 128),
			(float)( g_iCamTickFactor / 2 ) );

		if( EditorHelp::m_KeyPressed[ VK_RETURN ] && m_iCurrentStep > 0 )
		{
			if( m_iCurrentStep > 1 )
			{
				int iPrevStart= curTrack[ m_iCurrentStep - 1 ].m_dwDemoTimeStart;
				int iPrevSpeed= curTrack[ m_iCurrentStep - 1 ].m_dwDemoTimeSpeed;
				int iPrevLength= curTrack[ m_iCurrentStep - 1 ].m_dwTime;
				curStep.m_dwDemoTimeStart= iPrevLength * iPrevSpeed / 256 + iPrevStart;
			}
			else
			{
				curStep.m_dwDemoTimeStart= 0;
			}
		}

		m_EditCam.m_iDemoTime= curStep.m_dwDemoTimeStart;
	}
}

void ChangeSpeed()
{
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		SCameraKey& curStep= curTrack[ m_iCurrentStep ];

		curStep.m_dwDemoTimeSpeed=
			(int)EditorHelp::GetKeyPressedVal(	(float)curStep.m_dwDemoTimeSpeed,
			VK_RIGHT,
			VK_LEFT,
			(float)( 32 ),
			(float)( 4 ),
			(float)( 128 ) );

		if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
		{
			for( size_t i= m_iCurrentStep + 1; i < curTrack.size(); ++i )
			{
				curTrack[ i ].m_dwDemoTimeSpeed= curStep.m_dwDemoTimeSpeed;
			}
		}
	}
}
void ChangeLength()
{
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		SCameraKey& curStep= curTrack[ m_iCurrentStep ];

		curStep.m_dwTime=
			(int)EditorHelp::GetKeyPressedVal(	(float)curStep.m_dwTime,
			VK_RIGHT,
			VK_LEFT,
			(float)( g_iCamTickFactor / 16),
			(float)( g_iCamTickFactor / 128),
			(float)( g_iCamTickFactor / 2) );

		curStep.m_dwTime= max( 0, curStep.m_dwTime );

		if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
		{
			for( size_t i= m_iCurrentStep + 1; i < curTrack.size(); ++i )
			{
				curTrack[ i ].m_dwTime= curStep.m_dwTime;
			}
		}
	}
	CalcCamTrackStarts();
}

void SaveAllData()
{
	WriteCameraAll();
}

void ReloadAllData()
{
	ReadCameraAll();
}

void Save()
{
	if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
	{
		SaveAllData();
	}
}

void Reload()
{
	if( EditorHelp::m_KeyPressed[ VK_RETURN ] )
	{
		ReloadAllData();
	}
}

void HomeCam()
{
	m_EditCam.m_vec3Pos= D3DXVECTOR3( 0, 60,75 );
	m_EditCam.m_vec3Rot= D3DXVECTOR3( 3.14f, 0.65f, 0.0f );
	m_EditCam.m_fDOF= 3.0f;
	m_EditCam.m_fFOV= 1.0f;
	m_EditCam.m_iDemoTime= 0;
}

int GetCurrentTrackStartTime()
{
	return g_CamTrackStarts[ m_iCurrentTrack ];
}

void ResetRealTime()
{
	if( m_bLockCurrentTrack )
	{
		m_iRealTime= GetCurrentTrackStartTime();
	}
	else
	{
		m_iRealTime= 0;
	}
}

void CalcCamTrackStarts()
{
	g_CamTrackStarts.resize( 0 );
	int Time= 0;
	for( int i= 0; i < GetCamTrackCount(); ++i )
	{
		SCameraTrack& curTrack= g_CamKeyEditData[ i ];
		for( int j= 1; j < (int)curTrack.size() - 2; ++j )
		{
			Time+= curTrack[ j ].m_dwTime;
		}
		g_CamTrackStarts.push_back( Time );
	}
}

void SetStepFromTime()
{
	int iTrack= 0;
	int iTimeOffset= 0;
	for( ;iTrack < (int)g_CamTrackStarts.size() - 1; ++iTrack )
	{
		if( g_CamTrackStarts[ iTrack ] > m_iRealTime )
		{
			break;
		}
	}
	if( iTrack > 0 )
	{
		iTimeOffset= g_CamTrackStarts[ iTrack - 1 ];
	}
	m_iCurrentTrack= iTrack;
	int iTime= m_iRealTime - iTimeOffset;
	SCameraTrack& curTrack= GetEditTrack();
	m_iCurrentStep= 1;
	while( iTime >= 0 && m_iCurrentStep + 1 < (int)curTrack.size() )
	{
		iTime-= curTrack[ m_iCurrentStep ].m_dwTime;
		m_iCurrentStep++;
	}
	m_iCurrentStep--;
}

int GetRealTime()
{
	return m_iRealTime;
}

int CalculateRealTime()
{
	int iRealTimeFull= 0;
	for( int i= 0; i < GetCamTrackCount(); ++i )
	{
		std::vector<SCameraKey>& curTrack= g_CamKeyEditData[ i ];
		for( size_t j= 3; j < curTrack.size(); ++j )
		{
			SCameraKey& curStep= curTrack[ j - 2];
			if( (int)i > m_iCurrentTrack )
			{
				return iRealTimeFull;
			}
			if( (int)i == m_iCurrentTrack && (int)j - 2 >= m_iCurrentStep )
			{
				return iRealTimeFull;
			}
			iRealTimeFull+= curStep.m_dwTime;
		}
	}
	return iRealTimeFull;
}

int CalculateDemoTime()
{
	int Time= 0;
	SCameraTrack& curTrack= GetEditTrack();
	if( m_iCurrentStep < (int)curTrack.size() )
	{
		Time= curTrack[ m_iCurrentStep ].m_dwDemoTimeStart;
	}

	return Time;
}

#endif

void InterpolateCamLocal( SActCamData* pData, int iIndex, int dwLocalTime, SCameraDefinition& Out )
{
	SCameraKey* pStepPrev= pData->m_pCamData + iIndex - 1;
	SCameraKey* pStepA= pData->m_pCamData + iIndex;
	SCameraKey* pStepB= pData->m_pCamData + iIndex + 1;
	SCameraKey* pStepNext= pData->m_pCamData + iIndex + 2;

	float fWeight= 0.5f;
	if( pStepA->m_dwTime > 0 )
	{
		fWeight= (float)dwLocalTime / (float)pStepA->m_dwTime;
	}
	
	Out.m_fDOF= pStepA->m_fDOF * (1.0f - fWeight) + pStepB->m_fDOF * fWeight;
	Out.m_fFOV= pStepA->m_fFOV * (1.0f - fWeight) + pStepB->m_fFOV * fWeight;
	Out.m_iDemoTime= pStepA->m_dwDemoTimeStart + int( (float)dwLocalTime * (float)pStepA->m_dwDemoTimeSpeed / 256.0f );
	
	D3DXVECTOR2 vecStep1( pStepA->m_fTangentOffset[ 1 ], 0.0f );
	D3DXVECTOR2 vecStep2( 0.0f, 0.0f );
	D3DXVECTOR2 vecStep3( 1.0f, 0.0f );
	D3DXVECTOR2 vecStep4( pStepB->m_fTangentOffset[ 0 ], 0.0f );

	D3DXVECTOR2 vecStepCalc;
	D3DXVec2CatmullRom(	&vecStepCalc,
						&vecStep1,
						&vecStep2,
						&vecStep3,
						&vecStep4,
						fWeight );
	fWeight= vecStepCalc.x;

	D3DXVec3CatmullRom(	&Out.m_vec3Pos,
		(D3DXVECTOR3*)&(pStepPrev->m_fPos),
		(D3DXVECTOR3*)&(pStepA->m_fPos),
		(D3DXVECTOR3*)&(pStepB->m_fPos),
		(D3DXVECTOR3*)&(pStepNext->m_fPos),
		fWeight );
	D3DXVec3CatmullRom(	&Out.m_vec3Rot,
		(D3DXVECTOR3*)&(pStepPrev->m_fRot),
		(D3DXVECTOR3*)&(pStepA->m_fRot),
		(D3DXVECTOR3*)&(pStepB->m_fRot),
		(D3DXVECTOR3*)&(pStepNext->m_fRot),
		fWeight );

}

int CalcCamGlobal( SActCamData* pData, int dwTime, SCameraDefinition& Out )
{
	if( pData->m_pCamData == NULL )
	{
		return -1;
	}
	int dwCalc= dwTime;

	for( int i= 1; i < pData->m_iMaxStepCount - 2; ++i )
	{
		SCameraKey* pStep= pData->m_pCamData + i;
		int dwCurrentTicks= pStep->m_dwTime;

		if( dwCalc < dwCurrentTicks )
		{
			InterpolateCamLocal( 
				pData, 
				i,
				dwCalc, 
				Out );
			return -1;
		}
		dwCalc-= dwCurrentTicks;
	}

	{
		SCameraKey* pStep= pData->m_pCamData + pData->m_iMaxStepCount - 2;
		Out.m_vec3Pos= *((D3DXVECTOR3*)&(pStep->m_fPos));
		Out.m_vec3Rot= *((D3DXVECTOR3*)&(pStep->m_fRot));
		Out.m_fDOF= pStep->m_fDOF;
		Out.m_fFOV= pStep->m_fFOV;
	}

	return dwCalc;
}