summaryrefslogtreecommitdiff
path: root/main/timer_sync.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'main/timer_sync.cpp')
-rw-r--r--main/timer_sync.cpp223
1 files changed, 0 insertions, 223 deletions
diff --git a/main/timer_sync.cpp b/main/timer_sync.cpp
deleted file mode 100644
index 5ee834880f..0000000000
--- a/main/timer_sync.cpp
+++ /dev/null
@@ -1,223 +0,0 @@
-/*************************************************************************/
-/* timer_sync.cpp */
-/*************************************************************************/
-/* This file is part of: */
-/* GODOT ENGINE */
-/* https://godotengine.org */
-/*************************************************************************/
-/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
-/* Copyright (c) 2014-2019 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 */
-/* "Software"), to deal in the Software without restriction, including */
-/* without limitation the rights to use, copy, modify, merge, publish, */
-/* distribute, sublicense, and/or sell copies of the Software, and to */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions: */
-/* */
-/* The above copyright notice and this permission notice shall be */
-/* included in all copies or substantial portions of the Software. */
-/* */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
-/*************************************************************************/
-
-#include "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;
- }
-}
-
-/////////////////////////////////
-
-// returns the fraction of p_frame_slice 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() {
- return Engine::get_singleton()->get_physics_jitter_fix();
-}
-
-// gets our best bet for the average number of physics steps per render frame
-// return value: number of frames back this data is consistent
-int MainTimerSync::get_average_physics_steps(float &p_min, float &p_max) {
- p_min = typical_physics_steps[0];
- p_max = p_min + 1;
-
- for (int i = 1; i < CONTROL_STEPS; ++i) {
- const float typical_lower = typical_physics_steps[i];
- const float current_min = typical_lower / (i + 1);
- if (current_min > p_max)
- return i; // bail out of further restrictions would void the interval
- else if (current_min > p_min)
- p_min = current_min;
- const float current_max = (typical_lower + 1) / (i + 1);
- if (current_max < p_min)
- return i;
- else if (current_max < p_max)
- p_max = current_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) {
- MainFrameTime ret;
-
- ret.idle_step = p_idle_step;
-
- // simple determination of number of physics iteration
- time_accum += ret.idle_step;
- ret.physics_steps = floor(time_accum * p_iterations_per_second);
-
- int min_typical_steps = typical_physics_steps[0];
- int max_typical_steps = min_typical_steps + 1;
-
- // given the past recorded steps and typical steps to match, calculate bounds for this
- // step to be typical
- bool update_typical = false;
-
- for (int i = 0; i < CONTROL_STEPS - 1; ++i) {
- int steps_left_to_match_typical = typical_physics_steps[i + 1] - accumulated_physics_steps[i];
- if (steps_left_to_match_typical > max_typical_steps ||
- steps_left_to_match_typical + 1 < min_typical_steps) {
- update_typical = true;
- break;
- }
-
- if (steps_left_to_match_typical > min_typical_steps)
- min_typical_steps = steps_left_to_match_typical;
- if (steps_left_to_match_typical + 1 < max_typical_steps)
- max_typical_steps = steps_left_to_match_typical + 1;
- }
-
- // 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());
- if (max_possible_steps < min_typical_steps) {
- ret.physics_steps = max_possible_steps;
- update_typical = true;
- } else {
- 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());
- if (min_possible_steps > max_typical_steps) {
- ret.physics_steps = min_possible_steps;
- update_typical = true;
- } else {
- ret.physics_steps = max_typical_steps;
- }
- }
-
- time_accum -= ret.physics_steps * p_frame_slice;
-
- // keep track of accumulated step counts
- for (int i = CONTROL_STEPS - 2; i >= 0; --i) {
- accumulated_physics_steps[i + 1] = accumulated_physics_steps[i] + ret.physics_steps;
- }
- accumulated_physics_steps[0] = ret.physics_steps;
-
- if (update_typical) {
- for (int i = CONTROL_STEPS - 1; i >= 0; --i) {
- if (typical_physics_steps[i] > accumulated_physics_steps[i]) {
- typical_physics_steps[i] = accumulated_physics_steps[i];
- } else if (typical_physics_steps[i] < accumulated_physics_steps[i] - 1) {
- typical_physics_steps[i] = accumulated_physics_steps[i] - 1;
- }
- }
- }
-
- return ret;
-}
-
-// 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) {
- if (fixed_fps != -1)
- p_idle_step = 1.0 / fixed_fps;
-
- // compensate for last deficit
- p_idle_step += time_deficit;
-
- MainFrameTime ret = advance_core(p_frame_slice, p_iterations_per_second, p_idle_step);
-
- // we will do some clamping on ret.idle_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;
-
- // 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.
- {
- 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);
- }
- }
-
- // 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);
-
- // 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);
-
- // restore time_accum
- time_accum = ret.idle_step - idle_minus_accum;
-
- // track deficit
- time_deficit = p_idle_step - ret.idle_step;
-
- return ret;
-}
-
-// determine wall clock step since last iteration
-float MainTimerSync::get_cpu_idle_step() {
- uint64_t cpu_ticks_elapsed = current_cpu_ticks_usec - last_cpu_ticks_usec;
- last_cpu_ticks_usec = current_cpu_ticks_usec;
-
- return cpu_ticks_elapsed / 1000000.0;
-}
-
-MainTimerSync::MainTimerSync() :
- last_cpu_ticks_usec(0),
- current_cpu_ticks_usec(0),
- time_accum(0),
- time_deficit(0),
- fixed_fps(0) {
- for (int i = CONTROL_STEPS - 1; i >= 0; --i) {
- typical_physics_steps[i] = i;
- accumulated_physics_steps[i] = i;
- }
-}
-
-// start the clock
-void MainTimerSync::init(uint64_t p_cpu_ticks_usec) {
- current_cpu_ticks_usec = last_cpu_ticks_usec = p_cpu_ticks_usec;
-}
-
-// set measured wall clock time
-void MainTimerSync::set_cpu_ticks_usec(uint64_t p_cpu_ticks_usec) {
- current_cpu_ticks_usec = p_cpu_ticks_usec;
-}
-
-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();
-
- return advance_checked(p_frame_slice, p_iterations_per_second, cpu_idle_step);
-}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-04 13:37:31 +0000