void executeStack(StateStack& stack, SDL_Window& window, bool* pTerminator)
{
std::vector<const SDL_Event> events;
SDL_Event e;
bool localRunning = true;
bool& running = pTerminator ? *pTerminator : localRunning;
Uint64 t0 = SDL_GetPerformanceCounter();
while (!stack.empty() && running == true)
{
while (SDL_PollEvent(&e) != 0)
{
if (e.type == SDL_QUIT)
{
running = false;
}
events.push_back(e);
}
Uint64 now = SDL_GetPerformanceCounter();
float dt = (float)(now - t0) / SDL_GetPerformanceFrequency();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
tickStack(stack, events, dt);
events.clear();
SDL_GL_SwapWindow(&window);
t0 = now;
}
}
void Core::run()
{
uint64_t frequency = SDL_GetPerformanceFrequency();
uint64_t fixedStep = frequency / static_cast<uint64_t>(kStepRate);
uint64_t maxTotalDelta = fixedStep * 6;
uint64_t stepTime = SDL_GetPerformanceCounter();
while(!done_)
{
uint64_t loopTime = SDL_GetPerformanceCounter();
if(loopTime > stepTime + maxTotalDelta)
{
stepTime = loopTime - maxTotalDelta;
}
while(loopTime >= stepTime + fixedStep)
{
handleEvents();
sessionManager_->handleBlobs();
step(fp_t(1.0) / kStepRate);
stepTime += fixedStep;
}
#ifndef HEADLESS
fp_t interp = static_cast<fp_t>(loopTime - stepTime) / static_cast<fp_t>(frequency);
renderer_->render(interp);
#else
// simulate ~83 without game logic
SDL_Delay(12);
#endif
}
}
/*
================
Sys_DoubleTime
================
*/
double Sys_DoubleTime( void )
{
static longtime_t g_PerformanceFrequency;
static longtime_t g_ClockStart;
longtime_t CurrentTime;
#ifdef XASH_SDL
if( !g_PerformanceFrequency )
{
g_PerformanceFrequency = SDL_GetPerformanceFrequency();
g_ClockStart = SDL_GetPerformanceCounter();
}
CurrentTime = SDL_GetPerformanceCounter();
return (double)( CurrentTime - g_ClockStart ) / (double)( g_PerformanceFrequency );
#elif _WIN32
if( !g_PerformanceFrequency )
{
g_PerformanceFrequency = GetPerformanceFrequency();
g_ClockStart = GetPerformanceCounter();
}
CurrentTime = GetPerformanceCounter();
return (double)( CurrentTime - g_ClockStart ) / (double)( g_PerformanceFrequency );
#else
struct timespec ts;
if( !g_PerformanceFrequency )
{
struct timespec res;
if( !clock_getres(CLOCK_MONOTONIC, &res) )
g_PerformanceFrequency = 1000000000LL/res.tv_nsec;
}
clock_gettime(CLOCK_MONOTONIC, &ts);
return (double) ts.tv_sec + (double) ts.tv_nsec/1000000000.0;
#endif
}
int main(int argc, char *argv[])
{
TankGame game;
float tick_duration = 1000.0f / SDL_GetPerformanceFrequency();
float frame_ticks = SDL_GetPerformanceFrequency() * 1.0f / 60.0f;
auto timer = SDL_GetPerformanceCounter();
if (game.initialize(false))
{
game.loadLevel01();
for (int i = 0; i < 500; ++i)
{
if (game.getPlayerTank())
{
game.getPlayerTank()->turnTurret(0.02);
if (i % 4 == 0) game.getPlayerTank()->fireBullet(5.0f);
}
game.updateLogic(1.0f/60.0);
game.render();
auto now = SDL_GetPerformanceCounter();
float delay = frame_ticks - (float)(now - timer);
if (delay > 0)
{
SDL_Delay(delay * tick_duration);
}
timer = SDL_GetPerformanceCounter();
}
}
}
void OpenGlCamera::UpdateCamera(const Uint8 *keyboard_state, int *x, int *y) {
double render_time = (SDL_GetPerformanceCounter() - last_call_time_) / (double)SDL_GetPerformanceFrequency();
last_call_time_ = SDL_GetPerformanceCounter();
// the mouse movement doesn't depend on the render_time (fps)
this->camera_data_->AddRot((-*y) * 0.001f * this->camera_data_->camera_sensitivity, (-*x) * 0.001f * this->camera_data_->camera_sensitivity, 0.0f);
/*if (keyboard_state[SDL_SCANCODE_Q])
this->camera_data->AddRot(0.0f, 0.0f, +render_time * this->camera_data_->speed * 0.1f);
if (keyboard_state[SDL_SCANCODE_E])
this->camera_data->AddRot(0.0f, 0.0f, -render_time * this->camera_data_->speed * 0.1f);*/
// Movement
if (keyboard_state[SDL_SCANCODE_Q])
this->camera_data_->AddPos(0.0f, 0.0f, -render_time * this->camera_data_->camera_speed);
if (keyboard_state[SDL_SCANCODE_E])
this->camera_data_->AddPos(0.0f, 0.0f, +render_time * this->camera_data_->camera_speed);
if (keyboard_state[SDL_SCANCODE_W] || keyboard_state[SDL_SCANCODE_UP])
this->camera_data_->AddPos(+render_time * this->camera_data_->camera_speed, 0.0f, 0.0f);
if (keyboard_state[SDL_SCANCODE_A] || keyboard_state[SDL_SCANCODE_LEFT])
this->camera_data_->AddPos(0.0f, +render_time * this->camera_data_->camera_speed, 0.0f);
if (keyboard_state[SDL_SCANCODE_S] || keyboard_state[SDL_SCANCODE_DOWN])
this->camera_data_->AddPos(-render_time * this->camera_data_->camera_speed, 0.0f, 0.0f);
if (keyboard_state[SDL_SCANCODE_D] || keyboard_state[SDL_SCANCODE_RIGHT])
this->camera_data_->AddPos(0.0f, -render_time * this->camera_data_->camera_speed, 0.0f);
}
void delay()
{
if (disabled)
return;
int64_t tickDelta = SDL_GetPerformanceCounter() - lastTickCount;
int64_t toDelay = tpf - tickDelta;
/* Compensate for the last delta
* to the ideal timestep */
toDelay -= adj.idealDiff;
if (toDelay < 0)
toDelay = 0;
delayTicks(toDelay);
uint64_t now = lastTickCount = SDL_GetPerformanceCounter();
int64_t diff = now - adj.last;
adj.last = now;
/* Recalculate our temporal position
* relative to the ideal timestep */
adj.idealDiff = diff - tpf + adj.idealDiff;
if (adj.resetFlag)
{
adj.idealDiff = 0;
adj.resetFlag = false;
}
}
uint64_t Sys_Microseconds( void )
{
static Uint64 base = 0;
if( !base )
base = SDL_GetPerformanceCounter();
return 1000000ULL * ( SDL_GetPerformanceCounter() - base ) / freq;
}
void GameTimer::Start( )
{
m_Started = true;
m_Paused = false;
m_StartTicks = SDL_GetPerformanceCounter( );
m_LastCheckedTicks = SDL_GetPerformanceCounter( );
m_TicksPerSec = SDL_GetPerformanceFrequency( );
}
void FrameCounter::TickFrame()
{
m_frameTimes[m_overwritePos] = SDL_GetPerformanceCounter() - m_startTime;
m_maxFrameTime = std::max( m_frameTimes[m_overwritePos], m_maxFrameTime );
m_nrOfFrames++;
m_nrOfFrames = std::min( m_nrOfFrames, FRAMECOUNTER_NR_OF_SAMPLES );
m_overwritePos = ( m_overwritePos + 1 ) % FRAMECOUNTER_NR_OF_SAMPLES;
m_startTime = SDL_GetPerformanceCounter();
}
/// <summary>
/// Calculates the time elapsed since this function was last called and sets the internal delta time to this value.
/// If the timer is paused or has not yet been started it sets the internal delta time value to 0.
/// </summary>
void GameTimer::Tick( )
{
if ( !m_Paused && m_Started )
{
m_DeltaTicks = SDL_GetPerformanceCounter( ) - m_LastCheckedTicks;
m_DeltaTime = m_DeltaTicks / static_cast<float>(m_TicksPerSec);
}
else
m_DeltaTime = 0.0;
m_LastCheckedTicks = SDL_GetPerformanceCounter( );
}
FPSLimiter(uint16_t desiredFPS)
: lastTickCount(SDL_GetPerformanceCounter()),
tickFreq(SDL_GetPerformanceFrequency()),
tickFreqMS(tickFreq / 1000),
tickFreqNS((double) tickFreq / NS_PER_S),
disabled(false)
{
setDesiredFPS(desiredFPS);
adj.last = SDL_GetPerformanceCounter();
adj.idealDiff = 0;
adj.resetFlag = false;
}
void ImGui_ImplSDL2_NewFrame(SDL_Window* window)
{
ImGuiIO& io = ImGui::GetIO();
IM_ASSERT(io.Fonts->IsBuilt() && "Font atlas not built! It is generally built by the renderer back-end. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame().");
// Setup display size (every frame to accommodate for window resizing)
int w, h;
int display_w, display_h;
SDL_GetWindowSize(window, &w, &h);
SDL_GL_GetDrawableSize(window, &display_w, &display_h);
io.DisplaySize = ImVec2((float)w, (float)h);
if (w > 0 && h > 0)
io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
// Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
static Uint64 frequency = SDL_GetPerformanceFrequency();
Uint64 current_time = SDL_GetPerformanceCounter();
io.DeltaTime = g_Time > 0 ? (float)((double)(current_time - g_Time) / frequency) : (float)(1.0f / 60.0f);
g_Time = current_time;
ImGui_ImplSDL2_UpdateMousePosAndButtons();
ImGui_ImplSDL2_UpdateMouseCursor();
// Update game controllers (if enabled and available)
ImGui_ImplSDL2_UpdateGamepads();
}
void app::perf::dump(bool log)
{
// Sample the timer.
Uint64 current = SDL_GetPerformanceCounter();
Uint64 persec = SDL_GetPerformanceFrequency();
// Calculate the timings.
double d1 = double(current - local_start) / double(persec);
double dn = double(current - total_start) / double(persec);
double m1 = 1000.0 * d1 / local_frames;
double mn = 1000.0 * dn / total_frames;
int fps = int(ceil(local_frames / d1));
local_start = current;
// Report to a string. Set the window title and log.
std::ostringstream str;
str << std::fixed << std::setprecision(1) << m1 << "ms "
<< "(" << mn << "ms) "
<< fps << "fps";
SDL_SetWindowTitle(window, str.str().c_str());
if (log) std::cout << str.str() << std::endl;
}
double
updateDeltaTime()
{
Uint64 curTime;
double deltaTime;
if (prevTime == 0) {
prevTime = SDL_GetPerformanceCounter();
}
curTime = SDL_GetPerformanceCounter();
deltaTime = (double) (curTime - prevTime) / (double) SDL_GetPerformanceFrequency();
prevTime = curTime;
return deltaTime;
}
void Clock::Initialize()
{
DEBUGPRINTF( "Initializing Clock\n" );
ShutDown();
#if BUILD_WINDOWS_NO_SDL
LARGE_INTEGER Frequency;
LARGE_INTEGER Counter;
QueryPerformanceFrequency( &Frequency );
QueryPerformanceCounter( &Counter );
m_Resolution = 1.0 / (double)Frequency.QuadPart;
m_PhysicalBaseTime = Counter.QuadPart;
#endif
#if BUILD_SDL
Uint64 Frequency = SDL_GetPerformanceFrequency();
Uint64 Counter = SDL_GetPerformanceCounter();
m_Resolution = 1.0 / static_cast<double>( Frequency );
m_PhysicalBaseTime = Counter;
#endif
m_PhysicalDeltaTime = 0;
m_MachineDeltaTime = 0.0f;
m_GameDeltaTime = 0.0f;
m_PhysicalCurrentTime = 0;
m_MachineCurrentTime = 0.0f;
m_GameCurrentTime = 0.0f;
m_TickCount = 0;
}
int main(int _argc, char *_argv[])
{
try
{
bool quit = false;
SDLState sdl;
DispatchStack &dispatch = DispatchStack::get();
Game game;
Update update;
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
update.ticksLast = SDL_GetPerformanceCounter();
update.tickFrequency = SDL_GetPerformanceFrequency(); // Should really refresh this.
while(!quit)
{
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(!dispatch.handleEvent(event)
&& (event.type == SDL_QUIT))
quit = true;
}
update.ticksNow = SDL_GetPerformanceCounter();
update.dt = float((update.ticksNow - update.ticksLast) / double(update.tickFrequency));
dispatch.update(update);
update.ticksLast = update.ticksNow;
dispatch.handleIdle();
SDL_Delay(0);
}
}
catch(std::exception tExc)
{
std::cerr << "An exception occurred: " << tExc.what() << std::endl;
return -1;
}
catch(...)
{
std::cerr << "An unknown exception occurred." << std::endl;
return -2;
}
}
//===========================================================================
void Timer::SetPaused (bool paused) {
// If unpausing, don't count all the previous time that's elapsed.
if (m_paused && !paused) {
m_sdlCounterLast = SDL_GetPerformanceCounter();
}
m_paused = paused;
}
void GameTimer::Pause( )
{
if ( !m_Paused && m_Started )
{
m_Paused = true;
m_PausedTicks = SDL_GetPerformanceCounter( ) - m_StartTicks;
}
}
static uint64_t get_performance_counter()
{
Assertion(Timer_inited, "This function can only be used when the timer system is initialized!");
auto counter = SDL_GetPerformanceCounter();
return counter - Timer_base_value;
}
void SimKit::FPSTimeline::log_frame_end() {
this->frame_end = SDL_GetPerformanceCounter();
this->frame_recorded = true;
this->past_frames[this->past_frames_ctr % SimKit::FPSTimeline::NUM_PAST_FRAMES] =
((float)(this->frame_end - this->frame_begin) / (float)SDL_GetPerformanceFrequency()) * MICROSECONDS_PER_SECOND;
this->past_frames_ctr++;
};
// ------------------------------------------------------------------------------------------------
// Timer Class
// ------------------------------------------------------------------------------------------------
cTimer::cTimer(const cTimer::timerState_t tState) {
state = tState;
dt = 0.0;
now = SDL_GetPerformanceCounter();
prev = now;
cpuFreq = SDL_GetPerformanceFrequency();
}
int ViewPanel::getContiniousValue(int interval) {
int tick = SDL_GetPerformanceCounter() / interval % 512;
if (tick > 255) {
return 512 - tick;
} else {
return tick;
}
}
static real32_t sdl_get_seconds_elapsed(uint64_t prev_counter, uint64_t counter_freq)
{
real32_t result;
uint64_t current_counter;
current_counter = SDL_GetPerformanceCounter();
result = (real32_t)((real64_t)(current_counter - prev_counter) / (real64_t)counter_freq);
return (result);
}
void GameTimer::UnPause( )
{
if ( m_Paused )
{
m_Paused = false;
m_StartTicks = SDL_GetPerformanceCounter( ) - m_PausedTicks;
m_PausedTicks = 0;
}
}
/**
* \brief Automatically profiles a scope, or you can call the Stop() function.
* \para name Identifier for the profiling entry.
* \para accumulation Wether or not to accumulate times over a frame
* \para mainThread (Optional) If this profiling is run on a separate thread set this to true.
*/
AutoProfiler::AutoProfiler (const rString& name, Profiler::PROFILER_CATEGORY category, bool accumulation, bool mainThread )
: m_Name ( name ), m_MainThread ( mainThread ), m_Accumulation ( accumulation ), m_Category(category)
{
if ( mainThread && !accumulation )
{
Profiler::ProfilerManager::GetInstance().StartEntry ( name );
}
m_StartTime = SDL_GetPerformanceCounter();
}
uint32_t TimeCounterGetMsec()
{
uint64_t perfCounter = SDL_GetPerformanceCounter();
uint64_t perfFreq = SDL_GetPerformanceFrequency();
uint32_t msec = ( uint32_t )( 1000000 * perfCounter / perfFreq );
return msec;
}
//
// Update Functions -------------------------------------------
//
cTimer *cTimer::tick(void) {
if (state != RUNNING)
return this;
now = SDL_GetPerformanceCounter();
dt = (now - prev) / (float) cpuFreq;
prev = now;
return this;
}
int main() {
double *fs = malloc(SIZE * sizeof (double));
int i;
Uint64 c, acc;
srand(SEED);
acc = 0;
for (i = 0; i < SIZE; i++) {
fs[i] = rand()/(double)RAND_MAX;
fs[i] *= 2.0;
fs[i] -= 1.0;
c = SDL_GetPerformanceCounter();
fs[i] = fclamp0(fs[i], D_MAX);
acc += SDL_GetPerformanceCounter() - c;
}
free(fs);
printf("%f secs\n", acc/(double) SDL_GetPerformanceFrequency());
return 0;
}
void endTiming()
{
acc += SDL_GetPerformanceCounter() - ticks;
if (++counter < iter)
return;
Debug() << "Avg. CPU time:" << ((double) acc / (iter * (perfFreq / 1000))) << "ms";
acc = counter = 0;
}
void AutoProfiler::Stop()
{
if ( m_Accumulation )
{
Profiler::ProfilerManager::GetInstance().IncrementAccumulationEntry( SDL_GetPerformanceCounter() - m_StartTime, m_Name, m_Category );
}
else
{
if ( m_MainThread )
{
Profiler::ProfilerManager::GetInstance().EndEntry ( SDL_GetPerformanceCounter() - m_StartTime, "", m_Category );
}
else
{
Profiler::ProfilerManager::GetInstance().EndEntry ( SDL_GetPerformanceCounter() - m_StartTime, m_Name, m_Category );
}
}
m_Stopped = true;
}
