Re3/src/core/Timer.cpp

243 lines
5.3 KiB
C++
Raw Normal View History

2019-06-30 06:53:39 -04:00
#include <windows.h>
2019-05-15 10:52:37 -04:00
#include "common.h"
#include "patcher.h"
2019-05-29 14:02:58 -04:00
#include "DMAudio.h"
2019-05-29 18:47:33 -04:00
#include "Record.h"
2019-05-15 10:52:37 -04:00
#include "Timer.h"
2020-04-17 01:54:14 -04:00
uint32 CTimer::m_snTimeInMilliseconds;
uint32 CTimer::m_snTimeInMillisecondsPauseMode = 1;
uint32 CTimer::m_snTimeInMillisecondsNonClipped;
uint32 CTimer::m_snPreviousTimeInMilliseconds;
uint32 CTimer::m_FrameCounter;
float CTimer::ms_fTimeScale;
float CTimer::ms_fTimeStep;
float CTimer::ms_fTimeStepNonClipped;
bool CTimer::m_UserPause;
bool CTimer::m_CodePause;
uint32 oldPcTimer;
uint32 suspendPcTimer;
uint32 _nCyclesPerMS = 1;
LARGE_INTEGER _oldPerfCounter;
LARGE_INTEGER perfSuspendCounter;
uint32 suspendDepth;
2019-05-29 14:02:58 -04:00
2020-04-10 11:06:49 -04:00
#ifdef FIX_BUGS
double frameTime;
#endif
2019-05-29 14:02:58 -04:00
void CTimer::Initialise(void)
{
debug("Initialising CTimer...\n");
ms_fTimeScale = 1.0f;
ms_fTimeStep = 1.0f;
suspendDepth = 0;
m_UserPause = false;
m_CodePause = false;
m_snTimeInMillisecondsNonClipped = 0;
m_snPreviousTimeInMilliseconds = 0;
m_snTimeInMilliseconds = 1;
LARGE_INTEGER perfFreq;
if ( QueryPerformanceFrequency(&perfFreq) )
{
OutputDebugString("Performance counter available\n");
2019-06-16 18:16:38 -04:00
_nCyclesPerMS = uint32(perfFreq.QuadPart / 1000);
2019-05-29 14:02:58 -04:00
QueryPerformanceCounter(&_oldPerfCounter);
}
else
{
OutputDebugString("Performance counter not available, using millesecond timer\n");
_nCyclesPerMS = 0;
oldPcTimer = RsTimer();
}
m_snTimeInMilliseconds = m_snPreviousTimeInMilliseconds;
m_FrameCounter = 0;
DMAudio.ResetTimers(m_snPreviousTimeInMilliseconds);
debug("CTimer ready\n");
}
void CTimer::Shutdown(void)
{
;
}
void CTimer::Update(void)
{
m_snPreviousTimeInMilliseconds = m_snTimeInMilliseconds;
2019-06-16 18:16:38 -04:00
if ( (double)_nCyclesPerMS != 0.0 )
2019-05-29 14:02:58 -04:00
{
LARGE_INTEGER pc;
QueryPerformanceCounter(&pc);
2020-01-11 12:36:46 -05:00
int32 updInCycles = (pc.LowPart - _oldPerfCounter.LowPart); // & 0x7FFFFFFF; pointless
2019-05-29 14:02:58 -04:00
_oldPerfCounter = pc;
2020-01-11 12:36:46 -05:00
float updInCyclesScaled = updInCycles * ms_fTimeScale;
2019-05-29 14:02:58 -04:00
2020-04-10 11:06:49 -04:00
// We need that real frame time to fix transparent menu bug.
#ifndef FIX_BUGS
double
#endif
frameTime = updInCyclesScaled / (double)_nCyclesPerMS;
2019-05-29 14:02:58 -04:00
2020-04-10 11:06:49 -04:00
m_snTimeInMillisecondsPauseMode = m_snTimeInMillisecondsPauseMode + frameTime;
2019-05-29 14:02:58 -04:00
if ( GetIsPaused() )
ms_fTimeStep = 0.0f;
else
{
2020-04-10 11:06:49 -04:00
m_snTimeInMilliseconds = m_snTimeInMilliseconds + frameTime;
m_snTimeInMillisecondsNonClipped = m_snTimeInMillisecondsNonClipped + frameTime;
ms_fTimeStep = frameTime / 1000.0f * 50.0f;
2019-05-29 14:02:58 -04:00
}
}
else
{
2019-06-16 18:16:38 -04:00
uint32 timer = RsTimer();
2019-05-29 14:02:58 -04:00
2019-06-16 18:16:38 -04:00
uint32 updInMs = timer - oldPcTimer;
2019-05-29 14:02:58 -04:00
2020-04-10 11:06:49 -04:00
// We need that real frame time to fix transparent menu bug.
#ifndef FIX_BUGS
double
#endif
frameTime = (double)updInMs * ms_fTimeScale;
2019-05-29 14:02:58 -04:00
oldPcTimer = timer;
2020-04-10 11:06:49 -04:00
m_snTimeInMillisecondsPauseMode = m_snTimeInMillisecondsPauseMode + frameTime;
2019-05-29 14:02:58 -04:00
if ( GetIsPaused() )
ms_fTimeStep = 0.0f;
else
{
2020-04-10 11:06:49 -04:00
m_snTimeInMilliseconds = m_snTimeInMilliseconds + frameTime;
m_snTimeInMillisecondsNonClipped = m_snTimeInMillisecondsNonClipped + frameTime;
ms_fTimeStep = frameTime / 1000.0f * 50.0f;
2019-05-29 14:02:58 -04:00
}
}
if ( ms_fTimeStep < 0.01f && !GetIsPaused() )
ms_fTimeStep = 0.01f;
ms_fTimeStepNonClipped = ms_fTimeStep;
2020-04-10 04:03:38 -04:00
if ( !CRecordDataForGame::IsPlayingBack() )
2019-05-29 14:02:58 -04:00
{
ms_fTimeStep = min(3.0f, ms_fTimeStep);
if ( (m_snTimeInMilliseconds - m_snPreviousTimeInMilliseconds) > 60 )
m_snTimeInMilliseconds = m_snPreviousTimeInMilliseconds + 60;
}
2020-04-10 19:03:42 -04:00
if ( CRecordDataForChase::IsRecording() )
2019-05-29 14:02:58 -04:00
{
ms_fTimeStep = 1.0f;
m_snTimeInMilliseconds = m_snPreviousTimeInMilliseconds + 16;
}
m_FrameCounter++;
}
void CTimer::Suspend(void)
{
if ( ++suspendDepth > 1 )
return;
2019-06-16 18:16:38 -04:00
if ( (double)_nCyclesPerMS != 0.0 )
2019-05-29 14:02:58 -04:00
QueryPerformanceCounter(&perfSuspendCounter);
else
suspendPcTimer = RsTimer();
}
void CTimer::Resume(void)
{
if ( --suspendDepth != 0 )
return;
2019-06-16 18:16:38 -04:00
if ( (double)_nCyclesPerMS != 0.0 )
2019-05-29 14:02:58 -04:00
{
LARGE_INTEGER pc;
QueryPerformanceCounter(&pc);
_oldPerfCounter.LowPart += pc.LowPart - perfSuspendCounter.LowPart;
}
else
oldPcTimer += RsTimer() - suspendPcTimer;
}
2019-06-16 18:16:38 -04:00
uint32 CTimer::GetCyclesPerMillisecond(void)
2019-05-29 14:02:58 -04:00
{
if (_nCyclesPerMS != 0)
return _nCyclesPerMS;
else
return 1;
}
2019-06-16 18:16:38 -04:00
uint32 CTimer::GetCurrentTimeInCycles(void)
2019-05-29 14:02:58 -04:00
{
if ( _nCyclesPerMS != 0 )
{
LARGE_INTEGER pc;
QueryPerformanceCounter(&pc);
2020-01-11 12:36:46 -05:00
return (pc.LowPart - _oldPerfCounter.LowPart); // & 0x7FFFFFFF; pointless
2019-05-29 14:02:58 -04:00
}
else
return RsTimer() - oldPcTimer;
}
2019-06-16 18:16:38 -04:00
bool CTimer::GetIsSlowMotionActive(void)
2019-05-29 14:02:58 -04:00
{
return ms_fTimeScale < 1.0f;
}
void CTimer::Stop(void)
{
m_snPreviousTimeInMilliseconds = m_snTimeInMilliseconds;
}
void CTimer::StartUserPause(void)
{
m_UserPause = true;
}
void CTimer::EndUserPause(void)
{
m_UserPause = false;
}
2020-03-31 06:30:13 -04:00
uint32 CTimer::GetCyclesPerFrame()
{
return 20;
}
2020-01-11 12:36:46 -05:00
#if 1
2019-05-29 14:02:58 -04:00
STARTPATCHES
InjectHook(0x4ACE60, CTimer::Initialise, PATCH_JUMP);
InjectHook(0x4ACF60, CTimer::Shutdown, PATCH_JUMP);
InjectHook(0x4ACF70, CTimer::Update, PATCH_JUMP);
InjectHook(0x4AD310, CTimer::Suspend, PATCH_JUMP);
InjectHook(0x4AD370, CTimer::Resume, PATCH_JUMP);
InjectHook(0x4AD3F0, CTimer::GetCyclesPerMillisecond, PATCH_JUMP);
InjectHook(0x4AD410, CTimer::GetCurrentTimeInCycles, PATCH_JUMP);
InjectHook(0x4AD450, CTimer::GetIsSlowMotionActive, PATCH_JUMP);
InjectHook(0x4AD480, CTimer::Stop, PATCH_JUMP);
InjectHook(0x4AD490, CTimer::StartUserPause, PATCH_JUMP);
InjectHook(0x4AD4A0, CTimer::EndUserPause, PATCH_JUMP);
ENDPATCHES
#endif