1532 lines
32 KiB
C++
1532 lines
32 KiB
C++
#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;
|
|
}
|