diff options
Diffstat (limited to 'main/main_timer_sync.cpp')
| -rw-r--r-- | main/main_timer_sync.cpp | 76 |
1 files changed, 38 insertions, 38 deletions
diff --git a/main/main_timer_sync.cpp b/main/main_timer_sync.cpp index 5252ea005b..93448d0904 100644 --- a/main/main_timer_sync.cpp +++ b/main/main_timer_sync.cpp @@ -5,8 +5,8 @@ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ -/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ @@ -30,17 +30,17 @@ #include "main_timer_sync.h" -void MainFrameTime::clamp_idle(float min_idle_step, float max_idle_step) { - if (idle_step < min_idle_step) { - idle_step = min_idle_step; - } else if (idle_step > max_idle_step) { - idle_step = max_idle_step; +void MainFrameTime::clamp_process_step(float min_process_step, float max_process_step) { + if (process_step < min_process_step) { + process_step = min_process_step; + } else if (process_step > max_process_step) { + process_step = max_process_step; } } ///////////////////////////////// -// returns the fraction of p_frame_slice required for the timer to overshoot +// returns the fraction of p_physics_step required for the timer to overshoot // before advance_core considers changing the physics_steps return from // the typical values as defined by typical_physics_steps float MainTimerSync::get_physics_jitter_fix() { @@ -72,15 +72,15 @@ int MainTimerSync::get_average_physics_steps(float &p_min, float &p_max) { return CONTROL_STEPS; } -// advance physics clock by p_idle_step, return appropriate number of steps to simulate -MainFrameTime MainTimerSync::advance_core(float p_frame_slice, int p_iterations_per_second, float p_idle_step) { +// advance physics clock by p_process_step, return appropriate number of steps to simulate +MainFrameTime MainTimerSync::advance_core(float p_physics_step, int p_physics_fps, float p_process_step) { MainFrameTime ret; - ret.idle_step = p_idle_step; + ret.process_step = p_process_step; // simple determination of number of physics iteration - time_accum += ret.idle_step; - ret.physics_steps = floor(time_accum * p_iterations_per_second); + time_accum += ret.process_step; + ret.physics_steps = floor(time_accum * p_physics_fps); int min_typical_steps = typical_physics_steps[0]; int max_typical_steps = min_typical_steps + 1; @@ -107,7 +107,7 @@ MainFrameTime MainTimerSync::advance_core(float p_frame_slice, int p_iterations_ // try to keep it consistent with previous iterations if (ret.physics_steps < min_typical_steps) { - const int max_possible_steps = floor((time_accum)*p_iterations_per_second + get_physics_jitter_fix()); + const int max_possible_steps = floor((time_accum)*p_physics_fps + get_physics_jitter_fix()); if (max_possible_steps < min_typical_steps) { ret.physics_steps = max_possible_steps; update_typical = true; @@ -115,7 +115,7 @@ MainFrameTime MainTimerSync::advance_core(float p_frame_slice, int p_iterations_ ret.physics_steps = min_typical_steps; } } else if (ret.physics_steps > max_typical_steps) { - const int min_possible_steps = floor((time_accum)*p_iterations_per_second - get_physics_jitter_fix()); + const int min_possible_steps = floor((time_accum)*p_physics_fps - get_physics_jitter_fix()); if (min_possible_steps > max_typical_steps) { ret.physics_steps = min_possible_steps; update_typical = true; @@ -124,7 +124,7 @@ MainFrameTime MainTimerSync::advance_core(float p_frame_slice, int p_iterations_ } } - time_accum -= ret.physics_steps * p_frame_slice; + time_accum -= ret.physics_steps * p_physics_step; // keep track of accumulated step counts for (int i = CONTROL_STEPS - 2; i >= 0; --i) { @@ -146,52 +146,52 @@ MainFrameTime MainTimerSync::advance_core(float p_frame_slice, int p_iterations_ } // calls advance_core, keeps track of deficit it adds to animaption_step, make sure the deficit sum stays close to zero -MainFrameTime MainTimerSync::advance_checked(float p_frame_slice, int p_iterations_per_second, float p_idle_step) { +MainFrameTime MainTimerSync::advance_checked(float p_physics_step, int p_physics_fps, float p_process_step) { if (fixed_fps != -1) { - p_idle_step = 1.0 / fixed_fps; + p_process_step = 1.0 / fixed_fps; } // compensate for last deficit - p_idle_step += time_deficit; + p_process_step += time_deficit; - MainFrameTime ret = advance_core(p_frame_slice, p_iterations_per_second, p_idle_step); + MainFrameTime ret = advance_core(p_physics_step, p_physics_fps, p_process_step); - // we will do some clamping on ret.idle_step and need to sync those changes to time_accum, + // we will do some clamping on ret.process_step and need to sync those changes to time_accum, // that's easiest if we just remember their fixed difference now - const double idle_minus_accum = ret.idle_step - time_accum; + const double process_minus_accum = ret.process_step - time_accum; - // first, least important clamping: keep ret.idle_step consistent with typical_physics_steps. - // this smoothes out the idle steps and culls small but quick variations. + // first, least important clamping: keep ret.process_step consistent with typical_physics_steps. + // this smoothes out the process steps and culls small but quick variations. { float min_average_physics_steps, max_average_physics_steps; int consistent_steps = get_average_physics_steps(min_average_physics_steps, max_average_physics_steps); if (consistent_steps > 3) { - ret.clamp_idle(min_average_physics_steps * p_frame_slice, max_average_physics_steps * p_frame_slice); + ret.clamp_process_step(min_average_physics_steps * p_physics_step, max_average_physics_steps * p_physics_step); } } // second clamping: keep abs(time_deficit) < jitter_fix * frame_slise - float max_clock_deviation = get_physics_jitter_fix() * p_frame_slice; - ret.clamp_idle(p_idle_step - max_clock_deviation, p_idle_step + max_clock_deviation); + float max_clock_deviation = get_physics_jitter_fix() * p_physics_step; + ret.clamp_process_step(p_process_step - max_clock_deviation, p_process_step + max_clock_deviation); - // last clamping: make sure time_accum is between 0 and p_frame_slice for consistency between physics and idle - ret.clamp_idle(idle_minus_accum, idle_minus_accum + p_frame_slice); + // last clamping: make sure time_accum is between 0 and p_physics_step for consistency between physics and process + ret.clamp_process_step(process_minus_accum, process_minus_accum + p_physics_step); // restore time_accum - time_accum = ret.idle_step - idle_minus_accum; + time_accum = ret.process_step - process_minus_accum; // track deficit - time_deficit = p_idle_step - ret.idle_step; + time_deficit = p_process_step - ret.process_step; - // p_frame_slice is 1.0 / iterations_per_sec + // p_physics_step is 1.0 / iterations_per_sec // i.e. the time in seconds taken by a physics tick - ret.interpolation_fraction = time_accum / p_frame_slice; + ret.interpolation_fraction = time_accum / p_physics_step; return ret; } // determine wall clock step since last iteration -float MainTimerSync::get_cpu_idle_step() { +float MainTimerSync::get_cpu_process_step() { uint64_t cpu_ticks_elapsed = current_cpu_ticks_usec - last_cpu_ticks_usec; last_cpu_ticks_usec = current_cpu_ticks_usec; @@ -219,9 +219,9 @@ void MainTimerSync::set_fixed_fps(int p_fixed_fps) { fixed_fps = p_fixed_fps; } -// advance one frame, return timesteps to take -MainFrameTime MainTimerSync::advance(float p_frame_slice, int p_iterations_per_second) { - float cpu_idle_step = get_cpu_idle_step(); +// advance one physics frame, return timesteps to take +MainFrameTime MainTimerSync::advance(float p_physics_step, int p_physics_fps) { + float cpu_process_step = get_cpu_process_step(); - return advance_checked(p_frame_slice, p_iterations_per_second, cpu_idle_step); + return advance_checked(p_physics_step, p_physics_fps, cpu_process_step); } |