1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
#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 typcial 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);
}
|