maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Rename MainLoop methods to match Node methods

Browse source
This commit is contained in:
Marcel Admiraal 2020-12-22 09:50:29 +00:00
parent 6532596d97
commit d9e9eb8d04
27 changed files with 179 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
core/config/engine.h
View file

@ -50,7 +50,7 @@ private:
uint64_t frames_drawn = 0;
uint32_t _frame_delay = 0;
uint64_t _frame_ticks = 0;
float _frame_step = 0;
float _process_step = 0;
int ips = 60;
float physics_jitter_fix = 0.5;
@ -62,7 +62,7 @@ private:
bool abort_on_gpu_errors = false;
bool use_validation_layers = false;
uint64_t _idle_frames = 0;
uint64_t _process_frames = 0;
bool _in_physics = false;
List<Singleton> singletons;
@ -89,10 +89,10 @@ public:
uint64_t get_frames_drawn();
uint64_t get_physics_frames() const { return _physics_frames; }
uint64_t get_idle_frames() const { return _idle_frames; }
uint64_t get_process_frames() const { return _process_frames; }
bool is_in_physics_frame() const { return _in_physics; }
uint64_t get_idle_frame_ticks() const { return _frame_ticks; }
float get_idle_frame_step() const { return _frame_step; }
uint64_t get_frame_ticks() const { return _frame_ticks; }
float get_process_step() const { return _process_step; }
float get_physics_interpolation_fraction() const { return _physics_interpolation_fraction; }
void set_time_scale(float p_scale);

6
core/core_bind.cpp
View file

@ -2278,8 +2278,8 @@ uint64_t _Engine::get_physics_frames() const {
return Engine::get_singleton()->get_physics_frames();
}
uint64_t _Engine::get_idle_frames() const {
return Engine::get_singleton()->get_idle_frames();
uint64_t _Engine::get_process_frames() const {
return Engine::get_singleton()->get_process_frames();
}
void _Engine::set_time_scale(float p_scale) {
@ -2358,7 +2358,7 @@ void _Engine::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_frames_drawn"), &_Engine::get_frames_drawn);
ClassDB::bind_method(D_METHOD("get_frames_per_second"), &_Engine::get_frames_per_second);
ClassDB::bind_method(D_METHOD("get_physics_frames"), &_Engine::get_physics_frames);
ClassDB::bind_method(D_METHOD("get_idle_frames"), &_Engine::get_idle_frames);
ClassDB::bind_method(D_METHOD("get_process_frames"), &_Engine::get_process_frames);
ClassDB::bind_method(D_METHOD("get_main_loop"), &_Engine::get_main_loop);

2
core/core_bind.h
View file

@ -635,7 +635,7 @@ public:
float get_frames_per_second() const;
uint64_t get_physics_frames() const;
uint64_t get_idle_frames() const;
uint64_t get_process_frames() const;
int get_frames_drawn();

6
core/debugger/engine_debugger.cpp
View file

@ -117,9 +117,9 @@ void EngineDebugger::line_poll() {
poll_every++;
}
void EngineDebugger::iteration(uint64_t p_frame_ticks, uint64_t p_idle_ticks, uint64_t p_physics_ticks, float p_physics_frame_time) {
void EngineDebugger::iteration(uint64_t p_frame_ticks, uint64_t p_process_ticks, uint64_t p_physics_ticks, float p_physics_frame_time) {
frame_time = USEC_TO_SEC(p_frame_ticks);
idle_time = USEC_TO_SEC(p_idle_ticks);
process_time = USEC_TO_SEC(p_process_ticks);
physics_time = USEC_TO_SEC(p_physics_ticks);
physics_frame_time = p_physics_frame_time;
// Notify tick to running profilers
@ -128,7 +128,7 @@ void EngineDebugger::iteration(uint64_t p_frame_ticks, uint64_t p_idle_ticks, ui
if (!p.active || !p.tick) {
continue;
}
p.tick(p.data, frame_time, idle_time, physics_time, physics_frame_time);
p.tick(p.data, frame_time, process_time, physics_time, physics_frame_time);
}
singleton->poll_events(true);
}

6
core/debugger/engine_debugger.h
View file

@ -44,7 +44,7 @@ class ScriptDebugger;
class EngineDebugger {
public:
typedef void (*ProfilingToggle)(void *p_user, bool p_enable, const Array &p_opts);
typedef void (*ProfilingTick)(void *p_user, float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time);
typedef void (*ProfilingTick)(void *p_user, float p_frame_time, float p_process_time, float p_physics_time, float p_physics_frame_time);
typedef void (*ProfilingAdd)(void *p_user, const Array &p_arr);
typedef Error (*CaptureFunc)(void *p_user, const String &p_msg, const Array &p_args, bool &r_captured);
@ -86,7 +86,7 @@ public:
private:
float frame_time = 0.0;
float idle_time = 0.0;
float process_time = 0.0;
float physics_time = 0.0;
float physics_frame_time = 0.0;
@ -120,7 +120,7 @@ public:
static void register_uri_handler(const String &p_protocol, CreatePeerFunc p_func);
void iteration(uint64_t p_frame_ticks, uint64_t p_idle_ticks, uint64_t p_physics_ticks, float p_physics_frame_time);
void iteration(uint64_t p_frame_ticks, uint64_t p_process_ticks, uint64_t p_physics_ticks, float p_physics_frame_time);
void profiler_enable(const StringName &p_name, bool p_enabled, const Array &p_opts = Array());
Error capture_parse(const StringName &p_name, const String &p_msg, const Array &p_args, bool &r_captured);

2
core/debugger/remote_debugger.cpp
View file

@ -317,7 +317,7 @@ struct RemoteDebugger::ServersProfiler {
void _send_frame_data(bool p_final) {
DebuggerMarshalls::ServersProfilerFrame frame;
frame.frame_number = Engine::get_singleton()->get_idle_frames();
frame.frame_number = Engine::get_singleton()->get_process_frames();
frame.frame_time = frame_time;
frame.idle_time = idle_time;
frame.physics_time = physics_time;

10
core/input/input.cpp
View file

@ -247,7 +247,7 @@ bool Input::is_action_just_pressed(const StringName &p_action) const {
if (Engine::get_singleton()->is_in_physics_frame()) {
return E->get().pressed && E->get().physics_frame == Engine::get_singleton()->get_physics_frames();
} else {
return E->get().pressed && E->get().idle_frame == Engine::get_singleton()->get_idle_frames();
return E->get().pressed && E->get().process_frame == Engine::get_singleton()->get_process_frames();
}
}
@ -260,7 +260,7 @@ bool Input::is_action_just_released(const StringName &p_action) const {
if (Engine::get_singleton()->is_in_physics_frame()) {
return !E->get().pressed && E->get().physics_frame == Engine::get_singleton()->get_physics_frames();
} else {
return !E->get().pressed && E->get().idle_frame == Engine::get_singleton()->get_idle_frames();
return !E->get().pressed && E->get().process_frame == Engine::get_singleton()->get_process_frames();
}
}
@ -588,7 +588,7 @@ void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_em
if (!p_event->is_echo() && is_action_pressed(E->key()) != p_event->is_action_pressed(E->key())) {
Action action;
action.physics_frame = Engine::get_singleton()->get_physics_frames();
action.idle_frame = Engine::get_singleton()->get_idle_frames();
action.process_frame = Engine::get_singleton()->get_process_frames();
action.pressed = p_event->is_action_pressed(E->key());
action.strength = 0.0f;
action.raw_strength = 0.0f;
@ -714,7 +714,7 @@ void Input::action_press(const StringName &p_action, float p_strength) {
Action action;
action.physics_frame = Engine::get_singleton()->get_physics_frames();
action.idle_frame = Engine::get_singleton()->get_idle_frames();
action.process_frame = Engine::get_singleton()->get_process_frames();
action.pressed = true;
action.strength = p_strength;
@ -725,7 +725,7 @@ void Input::action_release(const StringName &p_action) {
Action action;
action.physics_frame = Engine::get_singleton()->get_physics_frames();
action.idle_frame = Engine::get_singleton()->get_idle_frames();
action.process_frame = Engine::get_singleton()->get_process_frames();
action.pressed = false;
action.strength = 0.f;

2
core/input/input.h
View file

@ -114,7 +114,7 @@ private:
struct Action {
uint64_t physics_frame;
uint64_t idle_frame;
uint64_t process_frame;
bool pressed;
float strength;
float raw_strength;

24
core/os/main_loop.cpp
View file

@ -34,8 +34,8 @@
void MainLoop::_bind_methods() {
BIND_VMETHOD(MethodInfo("_initialize"));
BIND_VMETHOD(MethodInfo(Variant::BOOL, "_iteration", PropertyInfo(Variant::FLOAT, "delta")));
BIND_VMETHOD(MethodInfo(Variant::BOOL, "_idle", PropertyInfo(Variant::FLOAT, "delta")));
BIND_VMETHOD(MethodInfo(Variant::BOOL, "_physics_process", PropertyInfo(Variant::FLOAT, "delta")));
BIND_VMETHOD(MethodInfo(Variant::BOOL, "_process", PropertyInfo(Variant::FLOAT, "delta")));
BIND_VMETHOD(MethodInfo("_finalize"));
BIND_CONSTANT(NOTIFICATION_OS_MEMORY_WARNING);
@ -52,13 +52,13 @@ void MainLoop::_bind_methods() {
ADD_SIGNAL(MethodInfo("on_request_permissions_result", PropertyInfo(Variant::STRING, "permission"), PropertyInfo(Variant::BOOL, "granted")));
};
void MainLoop::set_init_script(const Ref<Script> &p_init_script) {
init_script = p_init_script;
void MainLoop::set_initialize_script(const Ref<Script> &p_initialize_script) {
initialize_script = p_initialize_script;
}
void MainLoop::init() {
if (init_script.is_valid()) {
set_script(init_script);
void MainLoop::initialize() {
if (initialize_script.is_valid()) {
set_script(initialize_script);
}
if (get_script_instance()) {
@ -66,23 +66,23 @@ void MainLoop::init() {
}
}
bool MainLoop::iteration(float p_time) {
bool MainLoop::physics_process(float p_time) {
if (get_script_instance()) {
return get_script_instance()->call("_iteration", p_time);
return get_script_instance()->call("_physics_process", p_time);
}
return false;
}
bool MainLoop::idle(float p_time) {
bool MainLoop::process(float p_time) {
if (get_script_instance()) {
return get_script_instance()->call("_idle", p_time);
return get_script_instance()->call("_process", p_time);
}
return false;
}
void MainLoop::finish() {
void MainLoop::finalize() {
if (get_script_instance()) {
get_script_instance()->call("_finalize");
set_script(Variant()); //clear script

12
core/os/main_loop.h
View file

@ -39,7 +39,7 @@ class MainLoop : public Object {
GDCLASS(MainLoop, Object);
OBJ_CATEGORY("Main Loop");
Ref<Script> init_script;
Ref<Script> initialize_script;
protected:
static void _bind_methods();
@ -59,12 +59,12 @@ public:
NOTIFICATION_TEXT_SERVER_CHANGED = 2018,
};
virtual void init();
virtual bool iteration(float p_time);
virtual bool idle(float p_time);
virtual void finish();
virtual void initialize();
virtual bool physics_process(float p_time);
virtual bool process(float p_time);
virtual void finalize();
void set_init_script(const Ref<Script> &p_init_script);
void set_initialize_script(const Ref<Script> &p_initialize_script);
MainLoop() {}
virtual ~MainLoop() {}

6
doc/classes/Engine.xml
View file

@ -41,7 +41,7 @@
<return type="int">
</return>
<description>
Returns the total number of frames drawn. If the render loop is disabled with [code]--disable-render-loop[/code] via command line, this returns [code]0[/code]. See also [method get_idle_frames].
Returns the total number of frames drawn. If the render loop is disabled with [code]--disable-render-loop[/code] via command line, this returns [code]0[/code]. See also [method get_process_frames].
</description>
</method>
<method name="get_frames_per_second" qualifiers="const">
@ -51,11 +51,11 @@
Returns the frames per second of the running game.
</description>
</method>
<method name="get_idle_frames" qualifiers="const">
<method name="get_process_frames" qualifiers="const">
<return type="int">
</return>
<description>
Returns the total number of frames passed since engine initialization which is advanced on each [b]idle frame[/b], regardless of whether the render loop is enabled. See also [method get_frames_drawn].
Returns the total number of frames passed since engine initialization which is advanced on each [b]process frame[/b], regardless of whether the render loop is enabled. See also [method get_frames_drawn].
</description>
</method>
<method name="get_license_info" qualifiers="const">

47
main/main.cpp
View file

@ -2007,7 +2007,7 @@ bool Main::start() {
script));
}
script_loop->set_init_script(script_res);
script_loop->set_initialize_script(script_res);
main_loop = script_loop;
} else {
return false;
@ -2026,7 +2026,7 @@ bool Main::start() {
DisplayServer::get_singleton()->alert("Error: Invalid MainLoop script base type: " + script_base);
ERR_FAIL_V_MSG(false, vformat("The global class %s does not inherit from SceneTree or MainLoop.", main_loop_type));
}
script_loop->set_init_script(script_res);
script_loop->set_initialize_script(script_res);
main_loop = script_loop;
}
}
@ -2422,7 +2422,7 @@ bool Main::is_iterating() {
// For performance metrics.
static uint64_t physics_process_max = 0;
static uint64_t idle_process_max = 0;
static uint64_t process_max = 0;
bool Main::iteration() {
//for now do not error on this
@ -2438,19 +2438,19 @@ bool Main::iteration() {
uint64_t ticks_elapsed = ticks - last_ticks;
int physics_fps = Engine::get_singleton()->get_iterations_per_second();
float frame_slice = 1.0 / physics_fps;
float physics_step = 1.0 / physics_fps;
float time_scale = Engine::get_singleton()->get_time_scale();
MainFrameTime advance = main_timer_sync.advance(frame_slice, physics_fps);
double step = advance.idle_step;
double scaled_step = step * time_scale;
MainFrameTime advance = main_timer_sync.advance(physics_step, physics_fps);
double process_step = advance.process_step;
double scaled_step = process_step * time_scale;
Engine::get_singleton()->_frame_step = step;
Engine::get_singleton()->_process_step = process_step;
Engine::get_singleton()->_physics_interpolation_fraction = advance.interpolation_fraction;
uint64_t physics_process_ticks = 0;
uint64_t idle_process_ticks = 0;
uint64_t process_ticks = 0;
frame += ticks_elapsed;
@ -2458,7 +2458,7 @@ bool Main::iteration() {
static const int max_physics_steps = 8;
if (fixed_fps == -1 && advance.physics_steps > max_physics_steps) {
step -= (advance.physics_steps - max_physics_steps) * frame_slice;
process_step -= (advance.physics_steps - max_physics_steps) * physics_step;
advance.physics_steps = max_physics_steps;
}
@ -2474,33 +2474,32 @@ bool Main::iteration() {
PhysicsServer2D::get_singleton()->sync();
PhysicsServer2D::get_singleton()->flush_queries();
if (OS::get_singleton()->get_main_loop()->iteration(frame_slice * time_scale)) {
if (OS::get_singleton()->get_main_loop()->physics_process(physics_step * time_scale)) {
exit = true;
break;
}
NavigationServer3D::get_singleton_mut()->process(frame_slice * time_scale);
NavigationServer3D::get_singleton_mut()->process(physics_step * time_scale);
message_queue->flush();
PhysicsServer3D::get_singleton()->step(frame_slice * time_scale);
PhysicsServer3D::get_singleton()->step(physics_step * time_scale);
PhysicsServer2D::get_singleton()->end_sync();
PhysicsServer2D::get_singleton()->step(frame_slice * time_scale);
PhysicsServer2D::get_singleton()->step(physics_step * time_scale);
message_queue->flush();
physics_process_ticks = MAX(physics_process_ticks, OS::get_singleton()->get_ticks_usec() -
physics_begin); // keep the largest one for reference
physics_process_ticks = MAX(physics_process_ticks, OS::get_singleton()->get_ticks_usec() - physics_begin); // keep the largest one for reference
physics_process_max = MAX(OS::get_singleton()->get_ticks_usec() - physics_begin, physics_process_max);
Engine::get_singleton()->_physics_frames++;
}
Engine::get_singleton()->_in_physics = false;
uint64_t idle_begin = OS::get_singleton()->get_ticks_usec();
uint64_t process_begin = OS::get_singleton()->get_ticks_usec();
if (OS::get_singleton()->get_main_loop()->idle(step * time_scale)) {
if (OS::get_singleton()->get_main_loop()->process(process_step * time_scale)) {
exit = true;
}
message_queue->flush();
@ -2521,8 +2520,8 @@ bool Main::iteration() {
}
}
idle_process_ticks = OS::get_singleton()->get_ticks_usec() - idle_begin;
idle_process_max = MAX(idle_process_ticks, idle_process_max);
process_ticks = OS::get_singleton()->get_ticks_usec() - process_begin;
process_max = MAX(process_ticks, process_max);
uint64_t frame_time = OS::get_singleton()->get_ticks_usec() - ticks;
for (int i = 0; i < ScriptServer::get_language_count(); i++) {
@ -2532,11 +2531,11 @@ bool Main::iteration() {
AudioServer::get_singleton()->update();
if (EngineDebugger::is_active()) {
EngineDebugger::get_singleton()->iteration(frame_time, idle_process_ticks, physics_process_ticks, frame_slice);
EngineDebugger::get_singleton()->iteration(frame_time, process_ticks, physics_process_ticks, physics_step);
}
frames++;
Engine::get_singleton()->_idle_frames++;
Engine::get_singleton()->_process_frames++;
if (frame > 1000000) {
if (editor || project_manager) {
@ -2548,9 +2547,9 @@ bool Main::iteration() {
}
Engine::get_singleton()->_fps = frames;
performance->set_process_time(USEC_TO_SEC(idle_process_max));
performance->set_process_time(USEC_TO_SEC(process_max));
performance->set_physics_process_time(USEC_TO_SEC(physics_process_max));
idle_process_max = 0;
process_max = 0;
physics_process_max = 0;
frame %= 1000000;

72
main/main_timer_sync.cpp
View file

@ -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);
}

18
main/main_timer_sync.h
View file

@ -34,11 +34,11 @@
#include "core/config/engine.h"
struct MainFrameTime {
float idle_step; // time to advance idles for (argument to process())
float process_step; // delta time to advance during process()
int physics_steps; // number of times to iterate the physics engine
float interpolation_fraction; // fraction through the current physics tick
void clamp_idle(float min_idle_step, float max_idle_step);
void clamp_process_step(float min_process_step, float max_process_step);
};
class MainTimerSync {
@ -49,7 +49,7 @@ class MainTimerSync {
// logical game time since last physics timestep
float time_accum = 0;
// current difference between wall clock time and reported sum of idle_steps
// current difference between wall clock time and reported sum of process_steps
float time_deficit = 0;
// number of frames back for keeping accumulated physics steps roughly constant.
@ -67,7 +67,7 @@ class MainTimerSync {
int fixed_fps = 0;
protected:
// 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 get_physics_jitter_fix();
@ -76,14 +76,14 @@ protected:
// return value: number of frames back this data is consistent
int get_average_physics_steps(float &p_min, float &p_max);
// advance physics clock by p_idle_step, return appropriate number of steps to simulate
MainFrameTime 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 advance_core(float p_physics_step, int p_physics_fps, float p_process_step);
// calls advance_core, keeps track of deficit it adds to animaption_step, make sure the deficit sum stays close to zero
MainFrameTime advance_checked(float p_frame_slice, int p_iterations_per_second, float p_idle_step);
MainFrameTime advance_checked(float p_physics_step, int p_physics_fps, float p_process_step);
// determine wall clock step since last iteration
float get_cpu_idle_step();
float get_cpu_process_step();
public:
MainTimerSync();
@ -96,7 +96,7 @@ public:
void set_fixed_fps(int p_fixed_fps);
// advance one frame, return timesteps to take
MainFrameTime advance(float p_frame_slice, int p_iterations_per_second);
MainFrameTime advance(float p_physics_step, int p_physics_fps);
};
#endif // MAIN_TIMER_SYNC_H

4
platform/android/os_android.cpp
View file

@ -139,7 +139,7 @@ MainLoop *OS_Android::get_main_loop() const {
void OS_Android::main_loop_begin() {
if (main_loop)
main_loop->init();
main_loop->initialize();
}
bool OS_Android::main_loop_iterate() {
@ -151,7 +151,7 @@ bool OS_Android::main_loop_iterate() {
void OS_Android::main_loop_end() {
if (main_loop)
main_loop->finish();
main_loop->finalize();
}
void OS_Android::main_loop_focusout() {

4
platform/iphone/os_iphone.mm
View file

@ -149,7 +149,7 @@ void OSIPhone::set_main_loop(MainLoop *p_main_loop) {
main_loop = p_main_loop;
if (main_loop) {
main_loop->init();
main_loop->initialize();
}
}
@ -159,7 +159,7 @@ MainLoop *OSIPhone::get_main_loop() const {
void OSIPhone::delete_main_loop() {
if (main_loop) {
main_loop->finish();
main_loop->finalize();
memdelete(main_loop);
};

4
platform/linuxbsd/os_linuxbsd.cpp
View file

@ -246,7 +246,7 @@ void OS_LinuxBSD::run() {
return;
}
main_loop->init();
main_loop->initialize();
//uint64_t last_ticks=get_ticks_usec();
@ -263,7 +263,7 @@ void OS_LinuxBSD::run() {
}
};
main_loop->finish();
main_loop->finalize();
}
void OS_LinuxBSD::disable_crash_handler() {

4
platform/osx/os_osx.mm
View file

@ -312,7 +312,7 @@ void OS_OSX::run() {
if (!main_loop)
return;
main_loop->init();
main_loop->initialize();
bool quit = false;
while (!force_quit && !quit) {
@ -329,7 +329,7 @@ void OS_OSX::run() {
ERR_PRINT("NSException: " + String([exception reason].UTF8String));
}
};
main_loop->finish();
main_loop->finalize();
}
Error OS_OSX::move_to_trash(const String &p_path) {

4
platform/windows/os_windows.cpp
View file

@ -614,7 +614,7 @@ void OS_Windows::run() {
if (!main_loop)
return;
main_loop->init();
main_loop->initialize();
while (!force_quit) {
DisplayServer::get_singleton()->process_events(); // get rid of pending events
@ -622,7 +622,7 @@ void OS_Windows::run() {
break;
};
main_loop->finish();
main_loop->finalize();
}
MainLoop *OS_Windows::get_main_loop() const {

6
scene/3d/velocity_tracker_3d.cpp
View file

@ -45,7 +45,7 @@ void VelocityTracker3D::update_position(const Vector3 &p_position) {
if (physics_step) {
ph.frame = Engine::get_singleton()->get_physics_frames();
} else {
ph.frame = Engine::get_singleton()->get_idle_frame_ticks();
ph.frame = Engine::get_singleton()->get_frame_ticks();
}
if (position_history_len == 0 || position_history[0].frame != ph.frame) { //in same frame, use latest
@ -72,7 +72,7 @@ Vector3 VelocityTracker3D::get_tracked_linear_velocity() const {
uint64_t base = Engine::get_singleton()->get_physics_frames();
base_time = float(base - position_history[0].frame) / Engine::get_singleton()->get_iterations_per_second();
} else {
uint64_t base = Engine::get_singleton()->get_idle_frame_ticks();
uint64_t base = Engine::get_singleton()->get_frame_ticks();
base_time = double(base - position_history[0].frame) / 1000000.0;
}
}
@ -109,7 +109,7 @@ void VelocityTracker3D::reset(const Vector3 &p_new_pos) {
if (physics_step) {
ph.frame = Engine::get_singleton()->get_physics_frames();
} else {
ph.frame = Engine::get_singleton()->get_idle_frame_ticks();
ph.frame = Engine::get_singleton()->get_frame_ticks();
}
position_history.write[0] = ph;

42
scene/main/node.cpp
View file

@ -797,9 +797,9 @@ bool Node::can_process_notification(int p_what) const {
case NOTIFICATION_PHYSICS_PROCESS:
return data.physics_process;
case NOTIFICATION_PROCESS:
return data.idle_process;
return data.process;
case NOTIFICATION_INTERNAL_PROCESS:
return data.idle_process_internal;
return data.process_internal;
case NOTIFICATION_INTERNAL_PHYSICS_PROCESS:
return data.physics_process_internal;
}
@ -845,50 +845,50 @@ float Node::get_physics_process_delta_time() const {
float Node::get_process_delta_time() const {
if (data.tree) {
return data.tree->get_idle_process_time();
return data.tree->get_process_time();
} else {
return 0;
}
}
void Node::set_process(bool p_idle_process) {
if (data.idle_process == p_idle_process) {
void Node::set_process(bool p_process) {
if (data.process == p_process) {
return;
}
data.idle_process = p_idle_process;
data.process = p_process;
if (data.idle_process) {
add_to_group("idle_process", false);
if (data.process) {
add_to_group("process", false);
} else {
remove_from_group("idle_process");
remove_from_group("process");
}
_change_notify("idle_process");
_change_notify("process");
}
bool Node::is_processing() const {
return data.idle_process;
return data.process;
}
void Node::set_process_internal(bool p_idle_process_internal) {
if (data.idle_process_internal == p_idle_process_internal) {
void Node::set_process_internal(bool p_process_internal) {
if (data.process_internal == p_process_internal) {
return;
}
data.idle_process_internal = p_idle_process_internal;
data.process_internal = p_process_internal;
if (data.idle_process_internal) {
add_to_group("idle_process_internal", false);
if (data.process_internal) {
add_to_group("process_internal", false);
} else {
remove_from_group("idle_process_internal");
remove_from_group("process_internal");
}
_change_notify("idle_process_internal");
_change_notify("process_internal");
}
bool Node::is_processing_internal() const {
return data.idle_process_internal;
return data.process_internal;
}
void Node::set_process_priority(int p_priority) {
@ -900,11 +900,11 @@ void Node::set_process_priority(int p_priority) {
}
if (is_processing()) {
data.tree->make_group_changed("idle_process");
data.tree->make_group_changed("process");
}
if (is_processing_internal()) {
data.tree->make_group_changed("idle_process_internal");
data.tree->make_group_changed("process_internal");
}
if (is_physics_processing()) {

8
scene/main/node.h
View file

@ -121,11 +121,11 @@ private:
// Variables used to properly sort the node when processing, ignored otherwise.
// TODO: Should move all the stuff below to bits.
bool physics_process = false;
bool idle_process = false;
bool process = false;
int process_priority = 0;
bool physics_process_internal = false;
bool idle_process_internal = false;
bool process_internal = false;
bool input = false;
bool unhandled_input = false;
@ -339,14 +339,14 @@ public:
float get_physics_process_delta_time() const;
bool is_physics_processing() const;
void set_process(bool p_idle_process);
void set_process(bool p_process);
float get_process_delta_time() const;
bool is_processing() const;
void set_physics_process_internal(bool p_process_internal);
bool is_physics_processing_internal() const;
void set_process_internal(bool p_idle_process_internal);
void set_process_internal(bool p_process_internal);
bool is_processing_internal() const;
void set_process_priority(int p_priority);

30
scene/main/scene_tree.cpp
View file

@ -390,20 +390,20 @@ void SceneTree::set_group(const StringName &p_group, const String &p_name, const
set_group_flags(0, p_group, p_name, p_value);
}
void SceneTree::init() {
void SceneTree::initialize() {
initialized = true;
root->_set_tree(this);
MainLoop::init();
MainLoop::initialize();
}
bool SceneTree::iteration(float p_time) {
bool SceneTree::physics_process(float p_time) {
root_lock++;
current_frame++;
flush_transform_notifications();
MainLoop::iteration(p_time);
MainLoop::physics_process(p_time);
physics_process_time = p_time;
emit_signal("physics_frame");
@ -422,29 +422,25 @@ bool SceneTree::iteration(float p_time) {
return _quit;
}
bool SceneTree::idle(float p_time) {
//print_line("ram: "+itos(OS::get_singleton()->get_static_memory_usage())+" sram: "+itos(OS::get_singleton()->get_dynamic_memory_usage()));
//print_line("node count: "+itos(get_node_count()));
//print_line("TEXTURE RAM: "+itos(RS::get_singleton()->get_render_info(RS::INFO_TEXTURE_MEM_USED)));
bool SceneTree::process(float p_time) {
root_lock++;
MainLoop::idle(p_time);
MainLoop::process(p_time);
idle_process_time = p_time;
process_time = p_time;
if (multiplayer_poll) {
multiplayer->poll();
}
emit_signal("idle_frame");
emit_signal("process_frame");
MessageQueue::get_singleton()->flush(); //small little hack
flush_transform_notifications();
_notify_group_pause("idle_process_internal", Node::NOTIFICATION_INTERNAL_PROCESS);
_notify_group_pause("idle_process", Node::NOTIFICATION_PROCESS);
_notify_group_pause("process_internal", Node::NOTIFICATION_INTERNAL_PROCESS);
_notify_group_pause("process", Node::NOTIFICATION_PROCESS);
_flush_ugc();
MessageQueue::get_singleton()->flush(); //small little hack
@ -516,14 +512,14 @@ bool SceneTree::idle(float p_time) {
return _quit;
}
void SceneTree::finish() {
void SceneTree::finalize() {
_flush_delete_queue();
_flush_ugc();
initialized = false;
MainLoop::finish();
MainLoop::finalize();
if (root) {
root->_set_tree(nullptr);
@ -1265,7 +1261,7 @@ void SceneTree::_bind_methods() {
ADD_SIGNAL(MethodInfo("node_renamed", PropertyInfo(Variant::OBJECT, "node", PROPERTY_HINT_RESOURCE_TYPE, "Node")));
ADD_SIGNAL(MethodInfo("node_configuration_warning_changed", PropertyInfo(Variant::OBJECT, "node", PROPERTY_HINT_RESOURCE_TYPE, "Node")));
ADD_SIGNAL(MethodInfo("idle_frame"));
ADD_SIGNAL(MethodInfo("process_frame"));
ADD_SIGNAL(MethodInfo("physics_frame"));
ADD_SIGNAL(MethodInfo("files_dropped", PropertyInfo(Variant::PACKED_STRING_ARRAY, "files"), PropertyInfo(Variant::INT, "screen")));

12
scene/main/scene_tree.h
View file

@ -88,7 +88,7 @@ private:
uint64_t tree_version = 1;
float physics_process_time = 1.0;
float idle_process_time = 1.0;
float process_time = 1.0;
bool accept_quit = true;
bool quit_on_go_back = true;
@ -236,12 +236,12 @@ public:
void flush_transform_notifications();
virtual void init() override;
virtual void initialize() override;
virtual bool iteration(float p_time) override;
virtual bool idle(float p_time) override;
virtual bool physics_process(float p_time) override;
virtual bool process(float p_time) override;
virtual void finish() override;
virtual void finalize() override;
void set_auto_accept_quit(bool p_enable);
void set_quit_on_go_back(bool p_enable);
@ -249,7 +249,7 @@ public:
void quit(int p_exit_code = -1);
_FORCE_INLINE_ float get_physics_process_time() const { return physics_process_time; }
_FORCE_INLINE_ float get_idle_process_time() const { return idle_process_time; }
_FORCE_INLINE_ float get_process_time() const { return process_time; }
#ifdef TOOLS_ENABLED
bool is_node_being_edited(const Node *p_node) const;

4
tests/test_gui.cpp
View file

@ -63,8 +63,8 @@ public:
virtual void request_quit() {
quit();
}
virtual void init() {
SceneTree::init();
virtual void initialize() {
SceneTree::initialize();
Panel *frame = memnew(Panel);
frame->set_anchor(MARGIN_RIGHT, Control::ANCHOR_END);

6
tests/test_physics_2d.cpp
View file

@ -315,7 +315,7 @@ protected:
}
public:
virtual void init() override {
virtual void initialize() override {
RenderingServer *vs = RenderingServer::get_singleton();
PhysicsServer2D *ps = PhysicsServer2D::get_singleton();
@ -389,10 +389,10 @@ public:
//_add_plane(Vector2(-1,0).normalized(),-600);
}
virtual bool idle(float p_time) override {
virtual bool process(float p_time) override {
return false;
}
virtual void finish() override {
virtual void finalize() override {
}
TestPhysics2DMainLoop() {}

12
tests/test_physics_3d.cpp
View file

@ -122,7 +122,7 @@ protected:
ps->body_set_param(p_body, PhysicsServer3D::BODY_PARAM_BOUNCE, p_bounce);
}
void init_shapes() {
void initialize_shapes() {
RenderingServer *vs = RenderingServer::get_singleton();
PhysicsServer3D *ps = PhysicsServer3D::get_singleton();
@ -269,9 +269,9 @@ public:
virtual void request_quit() {
quit = true;
}
virtual void init() override {
virtual void initialize() override {
ofs_x = ofs_y = 0;
init_shapes();
initialize_shapes();
PhysicsServer3D *ps = PhysicsServer3D::get_singleton();
space = ps->space_create();
@ -310,7 +310,7 @@ public:
test_fall();
quit = false;
}
virtual bool iteration(float p_time) override {
virtual bool physics_process(float p_time) override {
if (mover.is_valid()) {
static float joy_speed = 10;
PhysicsServer3D *ps = PhysicsServer3D::get_singleton();
@ -328,7 +328,7 @@ public:
return quit;
}
virtual void finish() override {
virtual void finalize() override {
}
void test_joint() {
@ -396,7 +396,7 @@ public:
create_static_plane(Plane(Vector3(0, 1, 0), -1));
}
virtual bool idle(float p_time) override {
virtual bool process(float p_time) override {
return false;
}