asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use doubles for time in many other places

Browse source
This commit is contained in:
Aaron Franke 2021-02-01 21:16:37 -05:00
parent 78d33a6e24
commit 84f720966c
No known key found for this signature in database
GPG key ID: 40A1750B977E56BF
47 changed files with 291 additions and 288 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
core/config/engine.cpp
View file

@ -46,14 +46,14 @@ int Engine::get_iterations_per_second() const {
return ips;
}
void Engine::set_physics_jitter_fix(float p_threshold) {
void Engine::set_physics_jitter_fix(double p_threshold) {
if (p_threshold < 0) {
p_threshold = 0;
}
physics_jitter_fix = p_threshold;
}
float Engine::get_physics_jitter_fix() const {
double Engine::get_physics_jitter_fix() const {
return physics_jitter_fix;
}
@ -77,11 +77,11 @@ uint32_t Engine::get_frame_delay() const {
return _frame_delay;
}
void Engine::set_time_scale(float p_scale) {
void Engine::set_time_scale(double p_scale) {
_time_scale = p_scale;
}
float Engine::get_time_scale() const {
double Engine::get_time_scale() const {
return _time_scale;
}

24
core/config/engine.h
View file

@ -51,15 +51,15 @@ private:
uint64_t frames_drawn = 0;
uint32_t _frame_delay = 0;
uint64_t _frame_ticks = 0;
float _process_step = 0;
double _process_step = 0;
int ips = 60;
float physics_jitter_fix = 0.5;
float _fps = 1;
double physics_jitter_fix = 0.5;
double _fps = 1;
int _target_fps = 0;
float _time_scale = 1.0;
double _time_scale = 1.0;
uint64_t _physics_frames = 0;
float _physics_interpolation_fraction = 0.0f;
double _physics_interpolation_fraction = 0.0f;
bool abort_on_gpu_errors = false;
bool use_validation_layers = false;
@ -81,13 +81,13 @@ public:
virtual void set_iterations_per_second(int p_ips);
virtual int get_iterations_per_second() const;
void set_physics_jitter_fix(float p_threshold);
float get_physics_jitter_fix() const;
void set_physics_jitter_fix(double p_threshold);
double get_physics_jitter_fix() const;
virtual void set_target_fps(int p_fps);
virtual int get_target_fps() const;
virtual float get_frames_per_second() const { return _fps; }
virtual double get_frames_per_second() const { return _fps; }
uint64_t get_frames_drawn();
@ -95,11 +95,11 @@ public:
uint64_t get_process_frames() const { return _process_frames; }
bool is_in_physics_frame() const { return _in_physics; }
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; }
double get_process_step() const { return _process_step; }
double get_physics_interpolation_fraction() const { return _physics_interpolation_fraction; }
void set_time_scale(float p_scale);
float get_time_scale() const;
void set_time_scale(double p_scale);
double get_time_scale() const;
void set_print_error_messages(bool p_enabled);
bool is_printing_error_messages() const;

14
core/core_bind.cpp
View file

@ -2085,15 +2085,15 @@ int _Engine::get_iterations_per_second() const {
return Engine::get_singleton()->get_iterations_per_second();
}
void _Engine::set_physics_jitter_fix(float p_threshold) {
void _Engine::set_physics_jitter_fix(double p_threshold) {
Engine::get_singleton()->set_physics_jitter_fix(p_threshold);
}
float _Engine::get_physics_jitter_fix() const {
double _Engine::get_physics_jitter_fix() const {
return Engine::get_singleton()->get_physics_jitter_fix();
}
float _Engine::get_physics_interpolation_fraction() const {
double _Engine::get_physics_interpolation_fraction() const {
return Engine::get_singleton()->get_physics_interpolation_fraction();
}
@ -2105,7 +2105,7 @@ int _Engine::get_target_fps() const {
return Engine::get_singleton()->get_target_fps();
}
float _Engine::get_frames_per_second() const {
double _Engine::get_frames_per_second() const {
return Engine::get_singleton()->get_frames_per_second();
}
@ -2117,11 +2117,11 @@ uint64_t _Engine::get_process_frames() const {
return Engine::get_singleton()->get_process_frames();
}
void _Engine::set_time_scale(float p_scale) {
void _Engine::set_time_scale(double p_scale) {
Engine::get_singleton()->set_time_scale(p_scale);
}
float _Engine::get_time_scale() {
double _Engine::get_time_scale() {
return Engine::get_singleton()->get_time_scale();
}
@ -2342,7 +2342,7 @@ void _EngineDebugger::call_add(void *p_user, const Array &p_data) {
ERR_FAIL_COND_MSG(err.error != Callable::CallError::CALL_OK, "Error calling 'add' to callable: " + Variant::get_callable_error_text(add, args, 1, err));
}
void _EngineDebugger::call_tick(void *p_user, float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
void _EngineDebugger::call_tick(void *p_user, double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
Callable &tick = ((ProfilerCallable *)p_user)->callable_tick;
if (tick.is_null()) {
return;

14
core/core_bind.h
View file

@ -626,21 +626,21 @@ public:
void set_iterations_per_second(int p_ips);
int get_iterations_per_second() const;
void set_physics_jitter_fix(float p_threshold);
float get_physics_jitter_fix() const;
float get_physics_interpolation_fraction() const;
void set_physics_jitter_fix(double p_threshold);
double get_physics_jitter_fix() const;
double get_physics_interpolation_fraction() const;
void set_target_fps(int p_fps);
int get_target_fps() const;
float get_frames_per_second() const;
double get_frames_per_second() const;
uint64_t get_physics_frames() const;
uint64_t get_process_frames() const;
int get_frames_drawn();
void set_time_scale(float p_scale);
float get_time_scale();
void set_time_scale(double p_scale);
double get_time_scale();
MainLoop *get_main_loop() const;
@ -712,7 +712,7 @@ public:
static void call_toggle(void *p_user, bool p_enable, const Array &p_opts);
static void call_add(void *p_user, const Array &p_data);
static void call_tick(void *p_user, float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time);
static void call_tick(void *p_user, double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time);
static Error call_capture(void *p_user, const String &p_cmd, const Array &p_data, bool &r_captured);
_EngineDebugger() { singleton = this; }

16
core/debugger/debugger_marshalls.h
View file

@ -83,14 +83,14 @@ struct DebuggerMarshalls {
StringName name;
int sig_id = -1;
int call_count = 0;
float self_time = 0;
float total_time = 0;
double self_time = 0;
double total_time = 0;
};
// Servers profiler
struct ServerFunctionInfo {
StringName name;
float time = 0;
double time = 0;
};
struct ServerInfo {
@ -100,11 +100,11 @@ struct DebuggerMarshalls {
struct ServersProfilerFrame {
int frame_number = 0;
float frame_time = 0;
float idle_time = 0;
float physics_time = 0;
float physics_frame_time = 0;
float script_time = 0;
double frame_time = 0;
double idle_time = 0;
double physics_time = 0;
double physics_frame_time = 0;
double script_time = 0;
List<ServerInfo> servers;
Vector<ScriptFunctionInfo> script_functions;

2
core/debugger/engine_debugger.cpp
View file

@ -117,7 +117,7 @@ void EngineDebugger::line_poll() {
poll_every++;
}
void EngineDebugger::iteration(uint64_t p_frame_ticks, uint64_t p_process_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, double p_physics_frame_time) {
frame_time = USEC_TO_SEC(p_frame_ticks);
process_time = USEC_TO_SEC(p_process_ticks);
physics_time = USEC_TO_SEC(p_physics_ticks);

12
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_process_time, float p_physics_time, float p_physics_frame_time);
typedef void (*ProfilingTick)(void *p_user, double p_frame_time, double p_process_time, double p_physics_time, double 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);
@ -85,10 +85,10 @@ public:
};
private:
float frame_time = 0.0;
float process_time = 0.0;
float physics_time = 0.0;
float physics_frame_time = 0.0;
double frame_time = 0.0;
double process_time = 0.0;
double physics_time = 0.0;
double physics_frame_time = 0.0;
uint32_t poll_every = 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_process_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, double 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);

14
core/debugger/local_debugger.cpp
View file

@ -41,7 +41,7 @@ struct LocalDebugger::ScriptsProfiler {
}
};
float frame_time = 0;
double frame_time = 0;
uint64_t idle_accum = 0;
Vector<ScriptLanguage::ProfilingInfo> pinfo;
@ -61,7 +61,7 @@ struct LocalDebugger::ScriptsProfiler {
}
}
void tick(float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
void tick(double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
frame_time = p_frame_time;
_print_frame_data(false);
}
@ -92,8 +92,8 @@ struct LocalDebugger::ScriptsProfiler {
for (int i = 0; i < ofs; i++) {
script_time_us += pinfo[i].self_time;
}
float script_time = USEC_TO_SEC(script_time_us);
float total_time = p_accumulated ? script_time : frame_time;
double script_time = USEC_TO_SEC(script_time_us);
double total_time = p_accumulated ? script_time : frame_time;
if (!p_accumulated) {
print_line("FRAME: total: " + rtos(total_time) + " script: " + rtos(script_time) + "/" + itos(script_time * 100 / total_time) + " %");
@ -103,8 +103,8 @@ struct LocalDebugger::ScriptsProfiler {
for (int i = 0; i < ofs; i++) {
print_line(itos(i) + ":" + pinfo[i].signature);
float tt = USEC_TO_SEC(pinfo[i].total_time);
float st = USEC_TO_SEC(pinfo[i].self_time);
double tt = USEC_TO_SEC(pinfo[i].total_time);
double st = USEC_TO_SEC(pinfo[i].self_time);
print_line("\ttotal: " + rtos(tt) + "/" + itos(tt * 100 / total_time) + " % \tself: " + rtos(st) + "/" + itos(st * 100 / total_time) + " % tcalls: " + itos(pinfo[i].call_count));
}
}
@ -373,7 +373,7 @@ LocalDebugger::LocalDebugger() {
((ScriptsProfiler *)p_user)->toggle(p_enable, p_opts);
},
nullptr,
[](void *p_user, float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
[](void *p_user, double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
((ScriptsProfiler *)p_user)->tick(p_frame_time, p_idle_time, p_physics_time, p_physics_frame_time);
});
register_profiler("scripts", scr_prof);

18
core/debugger/remote_debugger.cpp
View file

@ -50,7 +50,7 @@ void RemoteDebugger::_bind_profiler(const String &p_name, T *p_prof) {
[](void *p_user, const Array &p_data) {
((T *)p_user)->add(p_data);
},
[](void *p_user, float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
[](void *p_user, double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
((T *)p_user)->tick(p_frame_time, p_idle_time, p_physics_time, p_physics_frame_time);
});
EngineDebugger::register_profiler(p_name, prof);
@ -164,7 +164,7 @@ public:
}
}
void tick(float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
void tick(double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
uint64_t pt = OS::get_singleton()->get_ticks_msec();
if (pt - last_bandwidth_time > 200) {
last_bandwidth_time = pt;
@ -278,10 +278,10 @@ struct RemoteDebugger::ServersProfiler {
Map<StringName, ServerInfo> server_data;
ScriptsProfiler scripts_profiler;
float frame_time = 0;
float idle_time = 0;
float physics_time = 0;
float physics_frame_time = 0;
double frame_time = 0;
double idle_time = 0;
double physics_time = 0;
double physics_frame_time = 0;
void toggle(bool p_enable, const Array &p_opts) {
skip_profile_frame = false;
@ -308,7 +308,7 @@ struct RemoteDebugger::ServersProfiler {
srv.functions.push_back(fi);
}
void tick(float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
void tick(double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
frame_time = p_frame_time;
idle_time = p_idle_time;
physics_time = p_physics_time;
@ -358,7 +358,7 @@ struct RemoteDebugger::VisualProfiler {
void add(const Array &p_data) {}
void tick(float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
void tick(double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
Vector<RS::FrameProfileArea> profile_areas = RS::get_singleton()->get_frame_profile();
DebuggerMarshalls::VisualProfilerFrame frame;
if (!profile_areas.size()) {
@ -378,7 +378,7 @@ struct RemoteDebugger::PerformanceProfiler {
void toggle(bool p_enable, const Array &p_opts) {}
void add(const Array &p_data) {}
void tick(float p_frame_time, float p_idle_time, float p_physics_time, float p_physics_frame_time) {
void tick(double p_frame_time, double p_idle_time, double p_physics_time, double p_physics_frame_time) {
if (!performance) {
return;
}

2
editor/plugins/canvas_item_editor_plugin.cpp
View file

@ -4073,7 +4073,7 @@ void CanvasItemEditor::_popup_warning_depop(Control *p_control) {
info_overlay->set_offset(SIDE_LEFT, (show_rulers ? RULER_WIDTH : 0) + 10);
}
void CanvasItemEditor::_popup_warning_temporarily(Control *p_control, const float p_duration) {
void CanvasItemEditor::_popup_warning_temporarily(Control *p_control, const double p_duration) {
Timer *timer;
if (!popup_temporarily_timers.has(p_control)) {
timer = memnew(Timer);

2
editor/plugins/canvas_item_editor_plugin.h
View file

@ -540,7 +540,7 @@ private:
VSplitContainer *bottom_split;
void _update_context_menu_stylebox();
void _popup_warning_temporarily(Control *p_control, const float p_duration);
void _popup_warning_temporarily(Control *p_control, const double p_duration);
void _popup_warning_depop(Control *p_control);
void _set_owner_for_node_and_children(Node *p_node, Node *p_owner);

4
editor/plugins/gpu_particles_2d_editor_plugin.cpp
View file

@ -60,7 +60,7 @@ void GPUParticles2DEditorPlugin::_file_selected(const String &p_file) {
void GPUParticles2DEditorPlugin::_menu_callback(int p_idx) {
switch (p_idx) {
case MENU_GENERATE_VISIBILITY_RECT: {
float gen_time = particles->get_lifetime();
double gen_time = particles->get_lifetime();
if (gen_time < 1.0) {
generate_seconds->set_value(1.0);
} else {
@ -100,7 +100,7 @@ void GPUParticles2DEditorPlugin::_menu_callback(int p_idx) {
}
void GPUParticles2DEditorPlugin::_generate_visibility_rect() {
float time = generate_seconds->get_value();
double time = generate_seconds->get_value();
float running = 0.0;

4
editor/plugins/gpu_particles_3d_editor_plugin.cpp
View file

@ -282,9 +282,9 @@ void GPUParticles3DEditor::_menu_option(int p_option) {
}
void GPUParticles3DEditor::_generate_aabb() {
float time = generate_seconds->get_value();
double time = generate_seconds->get_value();
float running = 0.0;
double running = 0.0;
EditorProgress ep("gen_aabb", TTR("Generating AABB"), int(time));

6
editor/plugins/node_3d_editor_plugin.cpp
View file

@ -2735,7 +2735,7 @@ void Node3DEditorViewport::_notification(int p_what) {
if (show_fps) {
cpu_time_history[cpu_time_history_index] = RS::get_singleton()->viewport_get_measured_render_time_cpu(viewport->get_viewport_rid());
cpu_time_history_index = (cpu_time_history_index + 1) % FRAME_TIME_HISTORY;
float cpu_time = 0.0;
double cpu_time = 0.0;
for (int i = 0; i < FRAME_TIME_HISTORY; i++) {
cpu_time += cpu_time_history[i];
}
@ -2745,7 +2745,7 @@ void Node3DEditorViewport::_notification(int p_what) {
gpu_time_history[gpu_time_history_index] = RS::get_singleton()->viewport_get_measured_render_time_gpu(viewport->get_viewport_rid());
gpu_time_history_index = (gpu_time_history_index + 1) % FRAME_TIME_HISTORY;
float gpu_time = 0.0;
double gpu_time = 0.0;
for (int i = 0; i < FRAME_TIME_HISTORY; i++) {
gpu_time += gpu_time_history[i];
}
@ -2769,7 +2769,7 @@ void Node3DEditorViewport::_notification(int p_what) {
frame_time_gradient->get_color_at_offset(
Math::range_lerp(gpu_time, 0, 30, 0, 1)));
const float fps = 1000.0 / gpu_time;
const double fps = 1000.0 / gpu_time;
fps_label->set_text(vformat(TTR("FPS: %d"), fps));
// Middle point is at 60 FPS.
fps_label->add_theme_color_override(

6
editor/plugins/node_3d_editor_plugin.h
View file

@ -166,9 +166,9 @@ public:
};
private:
float cpu_time_history[FRAME_TIME_HISTORY];
double cpu_time_history[FRAME_TIME_HISTORY];
int cpu_time_history_index;
float gpu_time_history[FRAME_TIME_HISTORY];
double gpu_time_history[FRAME_TIME_HISTORY];
int gpu_time_history_index;
int index;
@ -336,7 +336,7 @@ private:
String last_message;
String message;
float message_time;
double message_time;
void set_message(String p_message, float p_time = 5);

6
modules/visual_script/visual_script_yield_nodes.cpp
View file

@ -93,7 +93,7 @@ String VisualScriptYield::get_text() const {
class VisualScriptNodeInstanceYield : public VisualScriptNodeInstance {
public:
VisualScriptYield::YieldMode mode;
float wait_time;
double wait_time;
virtual int get_working_memory_size() const { return 1; } //yield needs at least 1
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
@ -159,7 +159,7 @@ VisualScriptYield::YieldMode VisualScriptYield::get_yield_mode() {
return yield_mode;
}
void VisualScriptYield::set_wait_time(float p_time) {
void VisualScriptYield::set_wait_time(double p_time) {
if (wait_time == p_time) {
return;
}
@ -167,7 +167,7 @@ void VisualScriptYield::set_wait_time(float p_time) {
ports_changed_notify();
}
float VisualScriptYield::get_wait_time() {
double VisualScriptYield::get_wait_time() {
return wait_time;
}

6
modules/visual_script/visual_script_yield_nodes.h
View file

@ -47,7 +47,7 @@ public:
private:
YieldMode yield_mode;
float wait_time;
double wait_time;
protected:
virtual void _validate_property(PropertyInfo &property) const override;
@ -73,8 +73,8 @@ public:
void set_yield_mode(YieldMode p_mode);
YieldMode get_yield_mode();
void set_wait_time(float p_time);
float get_wait_time();
void set_wait_time(double p_time);
double get_wait_time();
virtual VisualScriptNodeInstance *instantiate(VisualScriptInstance *p_instance) override;

16
scene/2d/animated_sprite_2d.cpp
View file

@ -159,12 +159,12 @@ void AnimatedSprite2D::_notification(int p_what) {
return;
}
float speed = frames->get_animation_speed(animation) * speed_scale;
double speed = frames->get_animation_speed(animation) * speed_scale;
if (speed == 0) {
return; //do nothing
}
float remaining = get_process_delta_time();
double remaining = get_process_delta_time();
while (remaining) {
if (timeout <= 0) {
@ -205,7 +205,7 @@ void AnimatedSprite2D::_notification(int p_what) {
emit_signal(SceneStringNames::get_singleton()->frame_changed);
}
float to_process = MIN(timeout, remaining);
double to_process = MIN(timeout, remaining);
remaining -= to_process;
timeout -= to_process;
}
@ -310,8 +310,8 @@ int AnimatedSprite2D::get_frame() const {
return frame;
}
void AnimatedSprite2D::set_speed_scale(float p_speed_scale) {
float elapsed = _get_frame_duration() - timeout;
void AnimatedSprite2D::set_speed_scale(double p_speed_scale) {
double elapsed = _get_frame_duration() - timeout;
speed_scale = MAX(p_speed_scale, 0.0f);
@ -320,7 +320,7 @@ void AnimatedSprite2D::set_speed_scale(float p_speed_scale) {
timeout -= elapsed;
}
float AnimatedSprite2D::get_speed_scale() const {
double AnimatedSprite2D::get_speed_scale() const {
return speed_scale;
}
@ -402,9 +402,9 @@ bool AnimatedSprite2D::is_playing() const {
return playing;
}
float AnimatedSprite2D::_get_frame_duration() {
double AnimatedSprite2D::_get_frame_duration() {
if (frames.is_valid() && frames->has_animation(animation)) {
float speed = frames->get_animation_speed(animation) * speed_scale;
double speed = frames->get_animation_speed(animation) * speed_scale;
if (speed > 0) {
return 1.0 / speed;
}

6
scene/2d/animated_sprite_2d.h
View file

@ -56,7 +56,7 @@ class AnimatedSprite2D : public Node2D {
void _res_changed();
float _get_frame_duration();
double _get_frame_duration();
void _reset_timeout();
void _set_playing(bool p_playing);
bool _is_playing() const;
@ -94,8 +94,8 @@ public:
void set_frame(int p_frame);
int get_frame() const;
void set_speed_scale(float p_speed_scale);
float get_speed_scale() const;
void set_speed_scale(double p_speed_scale);
double get_speed_scale() const;
void set_centered(bool p_center);
bool is_centered() const;

46
scene/2d/cpu_particles_2d.cpp
View file

@ -65,7 +65,7 @@ void CPUParticles2D::set_amount(int p_amount) {
particle_order.resize(p_amount);
}
void CPUParticles2D::set_lifetime(float p_lifetime) {
void CPUParticles2D::set_lifetime(double p_lifetime) {
ERR_FAIL_COND_MSG(p_lifetime <= 0, "Particles lifetime must be greater than 0.");
lifetime = p_lifetime;
}
@ -74,7 +74,7 @@ void CPUParticles2D::set_one_shot(bool p_one_shot) {
one_shot = p_one_shot;
}
void CPUParticles2D::set_pre_process_time(float p_time) {
void CPUParticles2D::set_pre_process_time(double p_time) {
pre_process_time = p_time;
}
@ -86,7 +86,7 @@ void CPUParticles2D::set_randomness_ratio(real_t p_ratio) {
randomness_ratio = p_ratio;
}
void CPUParticles2D::set_lifetime_randomness(float p_random) {
void CPUParticles2D::set_lifetime_randomness(double p_random) {
lifetime_randomness = p_random;
}
@ -95,7 +95,7 @@ void CPUParticles2D::set_use_local_coordinates(bool p_enable) {
set_notify_transform(!p_enable);
}
void CPUParticles2D::set_speed_scale(real_t p_scale) {
void CPUParticles2D::set_speed_scale(double p_scale) {
speed_scale = p_scale;
}
@ -107,7 +107,7 @@ int CPUParticles2D::get_amount() const {
return particles.size();
}
float CPUParticles2D::get_lifetime() const {
double CPUParticles2D::get_lifetime() const {
return lifetime;
}
@ -115,7 +115,7 @@ bool CPUParticles2D::get_one_shot() const {
return one_shot;
}
float CPUParticles2D::get_pre_process_time() const {
double CPUParticles2D::get_pre_process_time() const {
return pre_process_time;
}
@ -127,7 +127,7 @@ real_t CPUParticles2D::get_randomness_ratio() const {
return randomness_ratio;
}
float CPUParticles2D::get_lifetime_randomness() const {
double CPUParticles2D::get_lifetime_randomness() const {
return lifetime_randomness;
}
@ -135,7 +135,7 @@ bool CPUParticles2D::get_use_local_coordinates() const {
return local_coords;
}
real_t CPUParticles2D::get_speed_scale() const {
double CPUParticles2D::get_speed_scale() const {
return speed_scale;
}
@ -516,7 +516,7 @@ void CPUParticles2D::_update_internal() {
return;
}
float delta = get_process_delta_time();
double delta = get_process_delta_time();
if (emitting) {
inactive_time = 0;
} else {
@ -536,14 +536,14 @@ void CPUParticles2D::_update_internal() {
_set_redraw(true);
if (time == 0 && pre_process_time > 0.0) {
float frame_time;
double frame_time;
if (fixed_fps > 0) {
frame_time = 1.0 / fixed_fps;
} else {
frame_time = 1.0 / 30.0;
}
float todo = pre_process_time;
double todo = pre_process_time;
while (todo >= 0) {
_particles_process(frame_time);
@ -552,16 +552,16 @@ void CPUParticles2D::_update_internal() {
}
if (fixed_fps > 0) {
float frame_time = 1.0 / fixed_fps;
float decr = frame_time;
double frame_time = 1.0 / fixed_fps;
double decr = frame_time;
float ldelta = delta;
double ldelta = delta;
if (ldelta > 0.1) { //avoid recursive stalls if fps goes below 10
ldelta = 0.1;
} else if (ldelta <= 0.0) { //unlikely but..
ldelta = 0.001;
}
float todo = frame_remainder + ldelta;
double todo = frame_remainder + ldelta;
while (todo >= frame_time) {
_particles_process(frame_time);
@ -577,7 +577,7 @@ void CPUParticles2D::_update_internal() {
_update_particle_data_buffer();
}
void CPUParticles2D::_particles_process(float p_delta) {
void CPUParticles2D::_particles_process(double p_delta) {
p_delta *= speed_scale;
int pcount = particles.size();
@ -585,7 +585,7 @@ void CPUParticles2D::_particles_process(float p_delta) {
Particle *parray = w;
float prev_time = time;
double prev_time = time;
time += p_delta;
if (time > lifetime) {
time = Math::fmod(time, lifetime);
@ -604,7 +604,7 @@ void CPUParticles2D::_particles_process(float p_delta) {
velocity_xform[2] = Vector2();
}
float system_phase = time / lifetime;
double system_phase = time / lifetime;
for (int i = 0; i < pcount; i++) {
Particle &p = parray[i];
@ -613,12 +613,12 @@ void CPUParticles2D::_particles_process(float p_delta) {
continue;
}
float local_delta = p_delta;
double local_delta = p_delta;
// The phase is a ratio between 0 (birth) and 1 (end of life) for each particle.
// While we use time in tests later on, for randomness we use the phase as done in the
// original shader code, and we later multiply by lifetime to get the time.
real_t restart_phase = real_t(i) / real_t(pcount);
double restart_phase = double(i) / double(pcount);
if (randomness_ratio > 0.0) {
uint32_t seed = cycle;
@ -627,12 +627,12 @@ void CPUParticles2D::_particles_process(float p_delta) {
}
seed *= uint32_t(pcount);
seed += uint32_t(i);
real_t random = (idhash(seed) % uint32_t(65536)) / 65536.0;
restart_phase += randomness_ratio * random * 1.0 / pcount;
double random = double(idhash(seed) % uint32_t(65536)) / 65536.0;
restart_phase += randomness_ratio * random * 1.0 / double(pcount);
}
restart_phase *= (1.0 - explosiveness_ratio);
float restart_time = restart_phase * lifetime;
double restart_time = restart_phase * lifetime;
bool restart = false;
if (time > prev_time) {

36
scene/2d/cpu_particles_2d.h
View file

@ -91,16 +91,16 @@ private:
real_t scale_rand = 0.0;
real_t hue_rot_rand = 0.0;
real_t anim_offset_rand = 0.0;
float time = 0.0;
float lifetime = 0.0;
double time = 0.0;
double lifetime = 0.0;
Color base_color;
uint32_t seed = 0;
};
float time = 0.0;
float inactive_time = 0.0;
float frame_remainder = 0.0;
double time = 0.0;
double inactive_time = 0.0;
double frame_remainder = 0.0;
int cycle = 0;
bool redraw = false;
@ -131,12 +131,12 @@ private:
bool one_shot = false;
float lifetime = 1.0;
float pre_process_time = 0.0;
double lifetime = 1.0;
double pre_process_time = 0.0;
real_t explosiveness_ratio = 0.0;
real_t randomness_ratio = 0.0;
real_t lifetime_randomness = 0.0;
real_t speed_scale = 1.0;
double lifetime_randomness = 0.0;
double speed_scale = 1.0;
bool local_coords;
int fixed_fps = 0;
bool fractional_delta = true;
@ -172,7 +172,7 @@ private:
Vector2 gravity = Vector2(0, 980);
void _update_internal();
void _particles_process(float p_delta);
void _particles_process(double p_delta);
void _update_particle_data_buffer();
Mutex update_mutex;
@ -193,27 +193,27 @@ protected:
public:
void set_emitting(bool p_emitting);
void set_amount(int p_amount);
void set_lifetime(float p_lifetime);
void set_lifetime(double p_lifetime);
void set_one_shot(bool p_one_shot);
void set_pre_process_time(float p_time);
void set_pre_process_time(double p_time);
void set_explosiveness_ratio(real_t p_ratio);
void set_randomness_ratio(real_t p_ratio);
void set_lifetime_randomness(float p_random);
void set_lifetime_randomness(double p_random);
void set_visibility_aabb(const Rect2 &p_aabb);
void set_use_local_coordinates(bool p_enable);
void set_speed_scale(real_t p_scale);
void set_speed_scale(double p_scale);
bool is_emitting() const;
int get_amount() const;
float get_lifetime() const;
double get_lifetime() const;
bool get_one_shot() const;
float get_pre_process_time() const;
double get_pre_process_time() const;
real_t get_explosiveness_ratio() const;
real_t get_randomness_ratio() const;
float get_lifetime_randomness() const;
double get_lifetime_randomness() const;
Rect2 get_visibility_aabb() const;
bool get_use_local_coordinates() const;
real_t get_speed_scale() const;
double get_speed_scale() const;
void set_fixed_fps(int p_count);
int get_fixed_fps() const;

25
scene/2d/gpu_particles_2d.cpp
View file

@ -54,7 +54,7 @@ void GPUParticles2D::set_amount(int p_amount) {
RS::get_singleton()->particles_set_amount(particles, amount);
}
void GPUParticles2D::set_lifetime(float p_lifetime) {
void GPUParticles2D::set_lifetime(double p_lifetime) {
ERR_FAIL_COND_MSG(p_lifetime <= 0, "Particles lifetime must be greater than 0.");
lifetime = p_lifetime;
RS::get_singleton()->particles_set_lifetime(particles, lifetime);
@ -76,7 +76,7 @@ void GPUParticles2D::set_one_shot(bool p_enable) {
}
}
void GPUParticles2D::set_pre_process_time(float p_time) {
void GPUParticles2D::set_pre_process_time(double p_time) {
pre_process_time = p_time;
RS::get_singleton()->particles_set_pre_process_time(particles, pre_process_time);
}
@ -148,7 +148,8 @@ void GPUParticles2D::set_trail_enabled(bool p_enabled) {
RS::get_singleton()->particles_set_transform_align(particles, p_enabled ? RS::PARTICLES_TRANSFORM_ALIGN_Y_TO_VELOCITY : RS::PARTICLES_TRANSFORM_ALIGN_DISABLED);
}
void GPUParticles2D::set_trail_length(float p_seconds) {
void GPUParticles2D::set_trail_length(double p_seconds) {
ERR_FAIL_COND(p_seconds < 0.001);
trail_length = p_seconds;
RS::get_singleton()->particles_set_trails(particles, trail_enabled, trail_length);
@ -162,6 +163,7 @@ void GPUParticles2D::set_trail_sections(int p_sections) {
trail_sections = p_sections;
update();
}
void GPUParticles2D::set_trail_section_subdivisions(int p_subdivisions) {
ERR_FAIL_COND(trail_section_subdivisions < 1);
ERR_FAIL_COND(trail_section_subdivisions > 1024);
@ -173,12 +175,13 @@ void GPUParticles2D::set_trail_section_subdivisions(int p_subdivisions) {
bool GPUParticles2D::is_trail_enabled() const {
return trail_enabled;
}
float GPUParticles2D::get_trail_length() const {
real_t GPUParticles2D::get_trail_length() const {
return trail_length;
}
void GPUParticles2D::_update_collision_size() {
float csize = collision_base_size;
real_t csize = collision_base_size;
if (texture.is_valid()) {
csize *= (texture->get_width() + texture->get_height()) / 4.0; //half size since its a radius
@ -187,16 +190,16 @@ void GPUParticles2D::_update_collision_size() {
RS::get_singleton()->particles_set_collision_base_size(particles, csize);
}
void GPUParticles2D::set_collision_base_size(float p_size) {
void GPUParticles2D::set_collision_base_size(real_t p_size) {
collision_base_size = p_size;
_update_collision_size();
}
float GPUParticles2D::get_collision_base_size() const {
real_t GPUParticles2D::get_collision_base_size() const {
return collision_base_size;
}
void GPUParticles2D::set_speed_scale(float p_scale) {
void GPUParticles2D::set_speed_scale(double p_scale) {
speed_scale = p_scale;
RS::get_singleton()->particles_set_speed_scale(particles, p_scale);
}
@ -209,7 +212,7 @@ int GPUParticles2D::get_amount() const {
return amount;
}
float GPUParticles2D::get_lifetime() const {
double GPUParticles2D::get_lifetime() const {
return lifetime;
}
@ -224,7 +227,7 @@ bool GPUParticles2D::get_one_shot() const {
return one_shot;
}
float GPUParticles2D::get_pre_process_time() const {
double GPUParticles2D::get_pre_process_time() const {
return pre_process_time;
}
@ -248,7 +251,7 @@ Ref<Material> GPUParticles2D::get_process_material() const {
return process_material;
}
float GPUParticles2D::get_speed_scale() const {
double GPUParticles2D::get_speed_scale() const {
return speed_scale;
}

22
scene/2d/gpu_particles_2d.h
View file

@ -51,11 +51,11 @@ private:
bool one_shot;
int amount;
float lifetime;
float pre_process_time;
double lifetime;
double pre_process_time;
float explosiveness_ratio;
float randomness_ratio;
float speed_scale;
double speed_scale;
Rect2 visibility_rect;
bool local_coords;
int fixed_fps;
@ -89,32 +89,32 @@ protected:
public:
void set_emitting(bool p_emitting);
void set_amount(int p_amount);
void set_lifetime(float p_lifetime);
void set_lifetime(double p_lifetime);
void set_one_shot(bool p_enable);
void set_pre_process_time(float p_time);
void set_pre_process_time(double p_time);
void set_explosiveness_ratio(float p_ratio);
void set_randomness_ratio(float p_ratio);
void set_visibility_rect(const Rect2 &p_visibility_rect);
void set_use_local_coordinates(bool p_enable);
void set_process_material(const Ref<Material> &p_material);
void set_speed_scale(float p_scale);
void set_collision_base_size(float p_ratio);
void set_speed_scale(double p_scale);
void set_collision_base_size(real_t p_ratio);
void set_trail_enabled(bool p_enabled);
void set_trail_length(float p_seconds);
void set_trail_length(double p_seconds);
void set_trail_sections(int p_sections);
void set_trail_section_subdivisions(int p_subdivisions);
bool is_emitting() const;
int get_amount() const;
float get_lifetime() const;
double get_lifetime() const;
bool get_one_shot() const;
float get_pre_process_time() const;
double get_pre_process_time() const;
float get_explosiveness_ratio() const;
float get_randomness_ratio() const;
Rect2 get_visibility_rect() const;
bool get_use_local_coordinates() const;
Ref<Material> get_process_material() const;
float get_speed_scale() const;
double get_speed_scale() const;
float get_collision_base_size() const;
bool is_trail_enabled() const;

46
scene/3d/cpu_particles_3d.cpp
View file

@ -78,7 +78,7 @@ void CPUParticles3D::set_amount(int p_amount) {
particle_order.resize(p_amount);
}
void CPUParticles3D::set_lifetime(float p_lifetime) {
void CPUParticles3D::set_lifetime(double p_lifetime) {
ERR_FAIL_COND_MSG(p_lifetime <= 0, "Particles lifetime must be greater than 0.");
lifetime = p_lifetime;
}
@ -87,7 +87,7 @@ void CPUParticles3D::set_one_shot(bool p_one_shot) {
one_shot = p_one_shot;
}
void CPUParticles3D::set_pre_process_time(float p_time) {
void CPUParticles3D::set_pre_process_time(double p_time) {
pre_process_time = p_time;
}
@ -99,7 +99,7 @@ void CPUParticles3D::set_randomness_ratio(real_t p_ratio) {
randomness_ratio = p_ratio;
}
void CPUParticles3D::set_lifetime_randomness(float p_random) {
void CPUParticles3D::set_lifetime_randomness(double p_random) {
lifetime_randomness = p_random;
}
@ -107,7 +107,7 @@ void CPUParticles3D::set_use_local_coordinates(bool p_enable) {
local_coords = p_enable;
}
void CPUParticles3D::set_speed_scale(real_t p_scale) {
void CPUParticles3D::set_speed_scale(double p_scale) {
speed_scale = p_scale;
}
@ -119,7 +119,7 @@ int CPUParticles3D::get_amount() const {
return particles.size();
}
float CPUParticles3D::get_lifetime() const {
double CPUParticles3D::get_lifetime() const {
return lifetime;
}
@ -127,7 +127,7 @@ bool CPUParticles3D::get_one_shot() const {
return one_shot;
}
float CPUParticles3D::get_pre_process_time() const {
double CPUParticles3D::get_pre_process_time() const {
return pre_process_time;
}
@ -139,7 +139,7 @@ real_t CPUParticles3D::get_randomness_ratio() const {
return randomness_ratio;
}
float CPUParticles3D::get_lifetime_randomness() const {
double CPUParticles3D::get_lifetime_randomness() const {
return lifetime_randomness;
}
@ -147,7 +147,7 @@ bool CPUParticles3D::get_use_local_coordinates() const {
return local_coords;
}
real_t CPUParticles3D::get_speed_scale() const {
double CPUParticles3D::get_speed_scale() const {
return speed_scale;
}
@ -519,7 +519,7 @@ void CPUParticles3D::_update_internal() {
return;
}
float delta = get_process_delta_time();
double delta = get_process_delta_time();
if (emitting) {
inactive_time = 0;
} else {
@ -541,14 +541,14 @@ void CPUParticles3D::_update_internal() {
bool processed = false;
if (time == 0 && pre_process_time > 0.0) {
float frame_time;
double frame_time;
if (fixed_fps > 0) {
frame_time = 1.0 / fixed_fps;
} else {
frame_time = 1.0 / 30.0;
}
float todo = pre_process_time;
double todo = pre_process_time;
while (todo >= 0) {
_particles_process(frame_time);
@ -558,16 +558,16 @@ void CPUParticles3D::_update_internal() {
}
if (fixed_fps > 0) {
float frame_time = 1.0 / fixed_fps;
float decr = frame_time;
double frame_time = 1.0 / fixed_fps;
double decr = frame_time;
float ldelta = delta;
double ldelta = delta;
if (ldelta > 0.1) { //avoid recursive stalls if fps goes below 10
ldelta = 0.1;
} else if (ldelta <= 0.0) { //unlikely but..
ldelta = 0.001;
}
float todo = frame_remainder + ldelta;
double todo = frame_remainder + ldelta;
while (todo >= frame_time) {
_particles_process(frame_time);
@ -587,7 +587,7 @@ void CPUParticles3D::_update_internal() {
}
}
void CPUParticles3D::_particles_process(float p_delta) {
void CPUParticles3D::_particles_process(double p_delta) {
p_delta *= speed_scale;
int pcount = particles.size();
@ -595,7 +595,7 @@ void CPUParticles3D::_particles_process(float p_delta) {
Particle *parray = w;
float prev_time = time;
double prev_time = time;
time += p_delta;
if (time > lifetime) {
time = Math::fmod(time, lifetime);
@ -613,7 +613,7 @@ void CPUParticles3D::_particles_process(float p_delta) {
velocity_xform = emission_xform.basis;
}
float system_phase = time / lifetime;
double system_phase = time / lifetime;
for (int i = 0; i < pcount; i++) {
Particle &p = parray[i];
@ -622,12 +622,12 @@ void CPUParticles3D::_particles_process(float p_delta) {
continue;
}
float local_delta = p_delta;
double local_delta = p_delta;
// The phase is a ratio between 0 (birth) and 1 (end of life) for each particle.
// While we use time in tests later on, for randomness we use the phase as done in the
// original shader code, and we later multiply by lifetime to get the time.
real_t restart_phase = real_t(i) / real_t(pcount);
double restart_phase = double(i) / double(pcount);
if (randomness_ratio > 0.0) {
uint32_t seed = cycle;
@ -636,12 +636,12 @@ void CPUParticles3D::_particles_process(float p_delta) {
}
seed *= uint32_t(pcount);
seed += uint32_t(i);
real_t random = (idhash(seed) % uint32_t(65536)) / real_t(65536.0);
restart_phase += randomness_ratio * random * 1.0 / pcount;
double random = double(idhash(seed) % uint32_t(65536)) / 65536.0;
restart_phase += randomness_ratio * random * 1.0 / double(pcount);
}
restart_phase *= (1.0 - explosiveness_ratio);
float restart_time = restart_phase * lifetime;
double restart_time = restart_phase * lifetime;
bool restart = false;
if (time > prev_time) {

36
scene/3d/cpu_particles_3d.h
View file

@ -93,16 +93,16 @@ private:
real_t scale_rand = 0.0;
real_t hue_rot_rand = 0.0;
real_t anim_offset_rand = 0.0;
float time = 0.0;
float lifetime = 0.0;
double time = 0.0;
double lifetime = 0.0;
Color base_color;
uint32_t seed = 0;
};
float time = 0.0;
float inactive_time = 0.0;
float frame_remainder = 0.0;
double time = 0.0;
double inactive_time = 0.0;
double frame_remainder = 0.0;
int cycle = 0;
bool redraw = false;
@ -132,12 +132,12 @@ private:
bool one_shot = false;
float lifetime = 1.0;
float pre_process_time = 0.0;
double lifetime = 1.0;
double pre_process_time = 0.0;
real_t explosiveness_ratio = 0.0;
real_t randomness_ratio = 0.0;
float lifetime_randomness = 0.0;
float speed_scale = 1.0;
double lifetime_randomness = 0.0;
double speed_scale = 1.0;
bool local_coords = true;
int fixed_fps = 0;
bool fractional_delta = true;
@ -180,7 +180,7 @@ private:
Vector3 gravity = Vector3(0, -9.8, 0);
void _update_internal();
void _particles_process(float p_delta);
void _particles_process(double p_delta);
void _update_particle_data_buffer();
Mutex update_mutex;
@ -200,27 +200,27 @@ public:
void set_emitting(bool p_emitting);
void set_amount(int p_amount);
void set_lifetime(float p_lifetime);
void set_lifetime(double p_lifetime);
void set_one_shot(bool p_one_shot);
void set_pre_process_time(float p_time);
void set_pre_process_time(double p_time);
void set_explosiveness_ratio(real_t p_ratio);
void set_randomness_ratio(real_t p_ratio);
void set_lifetime_randomness(float p_random);
void set_lifetime_randomness(double p_random);
void set_visibility_aabb(const AABB &p_aabb);
void set_use_local_coordinates(bool p_enable);
void set_speed_scale(real_t p_scale);
void set_speed_scale(double p_scale);
bool is_emitting() const;
int get_amount() const;
float get_lifetime() const;
double get_lifetime() const;
bool get_one_shot() const;
float get_pre_process_time() const;
double get_pre_process_time() const;
real_t get_explosiveness_ratio() const;
real_t get_randomness_ratio() const;
float get_lifetime_randomness() const;
double get_lifetime_randomness() const;
AABB get_visibility_aabb() const;
bool get_use_local_coordinates() const;
real_t get_speed_scale() const;
double get_speed_scale() const;
void set_fixed_fps(int p_count);
int get_fixed_fps() const;

12
scene/3d/gpu_particles_3d.cpp
View file

@ -59,7 +59,7 @@ void GPUParticles3D::set_amount(int p_amount) {
RS::get_singleton()->particles_set_amount(particles, amount);
}
void GPUParticles3D::set_lifetime(float p_lifetime) {
void GPUParticles3D::set_lifetime(double p_lifetime) {
ERR_FAIL_COND_MSG(p_lifetime <= 0, "Particles lifetime must be greater than 0.");
lifetime = p_lifetime;
RS::get_singleton()->particles_set_lifetime(particles, lifetime);
@ -81,7 +81,7 @@ void GPUParticles3D::set_one_shot(bool p_one_shot) {
}
}
void GPUParticles3D::set_pre_process_time(float p_time) {
void GPUParticles3D::set_pre_process_time(double p_time) {
pre_process_time = p_time;
RS::get_singleton()->particles_set_pre_process_time(particles, pre_process_time);
}
@ -118,7 +118,7 @@ void GPUParticles3D::set_process_material(const Ref<Material> &p_material) {
update_configuration_warnings();
}
void GPUParticles3D::set_speed_scale(float p_scale) {
void GPUParticles3D::set_speed_scale(double p_scale) {
speed_scale = p_scale;
RS::get_singleton()->particles_set_speed_scale(particles, p_scale);
}
@ -136,7 +136,7 @@ int GPUParticles3D::get_amount() const {
return amount;
}
float GPUParticles3D::get_lifetime() const {
double GPUParticles3D::get_lifetime() const {
return lifetime;
}
@ -144,7 +144,7 @@ bool GPUParticles3D::get_one_shot() const {
return one_shot;
}
float GPUParticles3D::get_pre_process_time() const {
double GPUParticles3D::get_pre_process_time() const {
return pre_process_time;
}
@ -168,7 +168,7 @@ Ref<Material> GPUParticles3D::get_process_material() const {
return process_material;
}
float GPUParticles3D::get_speed_scale() const {
double GPUParticles3D::get_speed_scale() const {
return speed_scale;
}

18
scene/3d/gpu_particles_3d.h
View file

@ -64,11 +64,11 @@ private:
bool one_shot;
int amount;
float lifetime;
float pre_process_time;
double lifetime;
double pre_process_time;
float explosiveness_ratio;
float randomness_ratio;
float speed_scale;
double speed_scale;
AABB visibility_aabb;
bool local_coords;
int fixed_fps;
@ -104,30 +104,30 @@ public:
void set_emitting(bool p_emitting);
void set_amount(int p_amount);
void set_lifetime(float p_lifetime);
void set_lifetime(double p_lifetime);
void set_one_shot(bool p_one_shot);
void set_pre_process_time(float p_time);
void set_pre_process_time(double p_time);
void set_explosiveness_ratio(float p_ratio);
void set_randomness_ratio(float p_ratio);
void set_visibility_aabb(const AABB &p_aabb);
void set_use_local_coordinates(bool p_enable);
void set_process_material(const Ref<Material> &p_material);
void set_speed_scale(float p_scale);
void set_speed_scale(double p_scale);
void set_collision_base_size(float p_ratio);
void set_trail_enabled(bool p_enabled);
void set_trail_length(float p_seconds);
bool is_emitting() const;
int get_amount() const;
float get_lifetime() const;
double get_lifetime() const;
bool get_one_shot() const;
float get_pre_process_time() const;
double get_pre_process_time() const;
float get_explosiveness_ratio() const;
float get_randomness_ratio() const;
AABB get_visibility_aabb() const;
bool get_use_local_coordinates() const;
Ref<Material> get_process_material() const;
float get_speed_scale() const;
double get_speed_scale() const;
float get_collision_base_size() const;
bool is_trail_enabled() const;
float get_trail_length() const;

4
scene/3d/sprite_3d.cpp
View file

@ -1037,7 +1037,7 @@ void AnimatedSprite3D::_notification(int p_what) {
return; //do nothing
}
float remaining = get_process_delta_time();
double remaining = get_process_delta_time();
while (remaining) {
if (timeout <= 0) {
@ -1059,7 +1059,7 @@ void AnimatedSprite3D::_notification(int p_what) {
emit_signal(SceneStringNames::get_singleton()->frame_changed);
}
float to_process = MIN(timeout, remaining);
double to_process = MIN(timeout, remaining);
remaining -= to_process;
timeout -= to_process;
}

2
scene/3d/sprite_3d.h
View file

@ -213,7 +213,7 @@ class AnimatedSprite3D : public SpriteBase3D {
bool centered = false;
float timeout = 0;
double timeout = 0.0;
void _res_changed();

12
scene/3d/velocity_tracker_3d.cpp
View file

@ -61,16 +61,16 @@ void VelocityTracker3D::update_position(const Vector3 &p_position) {
Vector3 VelocityTracker3D::get_tracked_linear_velocity() const {
Vector3 linear_velocity;
float max_time = 1 / 5.0; //maximum time to interpolate a velocity
double max_time = 1 / 5.0; //maximum time to interpolate a velocity
Vector3 distance_accum;
float time_accum = 0.0;
float base_time = 0.0;
double time_accum = 0.0;
double base_time = 0.0;
if (position_history_len) {
if (physics_step) {
uint64_t base = Engine::get_singleton()->get_physics_frames();
base_time = float(base - position_history[0].frame) / Engine::get_singleton()->get_iterations_per_second();
base_time = double(base - position_history[0].frame) / Engine::get_singleton()->get_iterations_per_second();
} else {
uint64_t base = Engine::get_singleton()->get_frame_ticks();
base_time = double(base - position_history[0].frame) / 1000000.0;
@ -78,12 +78,12 @@ Vector3 VelocityTracker3D::get_tracked_linear_velocity() const {
}
for (int i = 0; i < position_history_len - 1; i++) {
float delta = 0.0;
double delta = 0.0;
uint64_t diff = position_history[i].frame - position_history[i + 1].frame;
Vector3 distance = position_history[i].position - position_history[i + 1].position;
if (physics_step) {
delta = float(diff) / Engine::get_singleton()->get_iterations_per_second();
delta = double(diff) / Engine::get_singleton()->get_iterations_per_second();
} else {
delta = double(diff) / 1000000.0;
}

6
scene/gui/rich_text_effect.h
View file

@ -59,7 +59,7 @@ public:
bool outline = false;
Point2 offset;
Color color;
float elapsed_time = 0.0f;
double elapsed_time = 0.0f;
Dictionary environment;
uint32_t glpyh_index = 0;
RID font;
@ -69,8 +69,8 @@ public:
Vector2i get_range() { return range; }
void set_range(const Vector2i &p_range) { range = p_range; }
float get_elapsed_time() { return elapsed_time; }
void set_elapsed_time(float p_elapsed_time) { elapsed_time = p_elapsed_time; }
double get_elapsed_time() { return elapsed_time; }
void set_elapsed_time(double p_elapsed_time) { elapsed_time = p_elapsed_time; }
bool is_visible() { return visibility; }
void set_visibility(bool p_visibility) { visibility = p_visibility; }
bool is_outline() { return outline; }

4
scene/gui/rich_text_label.cpp
View file

@ -1323,7 +1323,7 @@ void RichTextLabel::_update_scroll() {
}
}
void RichTextLabel::_update_fx(RichTextLabel::ItemFrame *p_frame, float p_delta_time) {
void RichTextLabel::_update_fx(RichTextLabel::ItemFrame *p_frame, double p_delta_time) {
Item *it = p_frame;
while (it) {
ItemFX *ifx = nullptr;
@ -1441,7 +1441,7 @@ void RichTextLabel::_notification(int p_what) {
} break;
case NOTIFICATION_INTERNAL_PROCESS: {
if (is_visible_in_tree()) {
float dt = get_process_delta_time();
double dt = get_process_delta_time();
_update_fx(main, dt);
update();
}

4
scene/gui/rich_text_label.h
View file

@ -260,7 +260,7 @@ private:
};
struct ItemFX : public Item {
float elapsed_time = 0.f;
double elapsed_time = 0.f;
};
struct ItemShake : public ItemFX {
@ -440,7 +440,7 @@ private:
void _fetch_item_fx_stack(Item *p_item, Vector<ItemFX *> &r_stack);
void _update_scroll();
void _update_fx(ItemFrame *p_frame, float p_delta_time);
void _update_fx(ItemFrame *p_frame, double p_delta_time);
void _scroll_changed(double);
void _gui_input(Ref<InputEvent> p_event);

4
scene/main/node.cpp
View file

@ -712,7 +712,7 @@ bool Node::is_enabled() const {
return _is_enabled();
}
float Node::get_physics_process_delta_time() const {
double Node::get_physics_process_delta_time() const {
if (data.tree) {
return data.tree->get_physics_process_time();
} else {
@ -720,7 +720,7 @@ float Node::get_physics_process_delta_time() const {
}
}
float Node::get_process_delta_time() const {
double Node::get_process_delta_time() const {
if (data.tree) {
return data.tree->get_process_time();
} else {

4
scene/main/node.h
View file

@ -340,11 +340,11 @@ public:
/* PROCESSING */
void set_physics_process(bool p_process);
float get_physics_process_delta_time() const;
double get_physics_process_delta_time() const;
bool is_physics_processing() const;
void set_process(bool p_process);
float get_process_delta_time() const;
double get_process_delta_time() const;
bool is_processing() const;
void set_physics_process_internal(bool p_process_internal);

2
scene/main/viewport.h
View file

@ -375,7 +375,7 @@ private:
Variant drag_data;
ObjectID drag_preview_id;
Ref<SceneTreeTimer> tooltip_timer;
float tooltip_delay = 0.0;
double tooltip_delay = 0.0;
Transform2D focus_inv_xform;
bool roots_order_dirty = false;
List<Control *> roots;

4
scene/resources/sprite_frames.cpp
View file

@ -122,14 +122,14 @@ Vector<String> SpriteFrames::get_animation_names() const {
return names;
}
void SpriteFrames::set_animation_speed(const StringName &p_anim, float p_fps) {
void SpriteFrames::set_animation_speed(const StringName &p_anim, double p_fps) {
ERR_FAIL_COND_MSG(p_fps < 0, "Animation speed cannot be negative (" + itos(p_fps) + ").");
Map<StringName, Anim>::Element *E = animations.find(p_anim);
ERR_FAIL_COND_MSG(!E, "Animation '" + String(p_anim) + "' doesn't exist.");
E->get().speed = p_fps;
}
float SpriteFrames::get_animation_speed(const StringName &p_anim) const {
double SpriteFrames::get_animation_speed(const StringName &p_anim) const {
const Map<StringName, Anim>::Element *E = animations.find(p_anim);
ERR_FAIL_COND_V_MSG(!E, 0, "Animation '" + String(p_anim) + "' doesn't exist.");
return E->get().speed;

6
scene/resources/sprite_frames.h
View file

@ -37,7 +37,7 @@ class SpriteFrames : public Resource {
GDCLASS(SpriteFrames, Resource);
struct Anim {
float speed = 5.0;
double speed = 5.0;
bool loop = true;
Vector<Ref<Texture2D>> frames;
};
@ -64,8 +64,8 @@ public:
void get_animation_list(List<StringName> *r_animations) const;
Vector<String> get_animation_names() const;
void set_animation_speed(const StringName &p_anim, float p_fps);
float get_animation_speed(const StringName &p_anim) const;
void set_animation_speed(const StringName &p_anim, double p_fps);
double get_animation_speed(const StringName &p_anim) const;
void set_animation_loop(const StringName &p_anim, bool p_loop);
bool get_animation_loop(const StringName &p_anim) const;

10
servers/rendering/rasterizer_dummy.h
View file

@ -540,13 +540,13 @@ public:
void particles_emit(RID p_particles, const Transform3D &p_transform, const Vector3 &p_velocity, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) override {}
void particles_set_emitting(RID p_particles, bool p_emitting) override {}
void particles_set_amount(RID p_particles, int p_amount) override {}
void particles_set_lifetime(RID p_particles, float p_lifetime) override {}
void particles_set_lifetime(RID p_particles, double p_lifetime) override {}
void particles_set_one_shot(RID p_particles, bool p_one_shot) override {}
void particles_set_pre_process_time(RID p_particles, float p_time) override {}
void particles_set_pre_process_time(RID p_particles, double p_time) override {}
void particles_set_explosiveness_ratio(RID p_particles, float p_ratio) override {}
void particles_set_randomness_ratio(RID p_particles, float p_ratio) override {}
void particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) override {}
void particles_set_speed_scale(RID p_particles, float p_scale) override {}
void particles_set_speed_scale(RID p_particles, double p_scale) override {}
void particles_set_use_local_coordinates(RID p_particles, bool p_enable) override {}
void particles_set_process_material(RID p_particles, RID p_material) override {}
void particles_set_fixed_fps(RID p_particles, int p_fps) override {}
@ -724,7 +724,7 @@ public:
class RasterizerDummy : public RendererCompositor {
private:
uint64_t frame = 1;
float delta = 0;
double delta = 0;
protected:
RasterizerCanvasDummy canvas;
@ -765,7 +765,7 @@ public:
bool is_low_end() const override { return true; }
uint64_t get_frame_number() const override { return frame; }
float get_frame_delta_time() const override { return delta; }
double get_frame_delta_time() const override { return delta; }
RasterizerDummy() {}
~RasterizerDummy() {}

2
servers/rendering/renderer_compositor.h
View file

@ -85,7 +85,7 @@ public:
virtual void end_frame(bool p_swap_buffers) = 0;
virtual void finalize() = 0;
virtual uint64_t get_frame_number() const = 0;
virtual float get_frame_delta_time() const = 0;
virtual double get_frame_delta_time() const = 0;
virtual bool is_low_end() const = 0;
virtual bool is_xr_enabled() const;

4
servers/rendering/renderer_rd/renderer_compositor_rd.h
View file

@ -80,7 +80,7 @@ protected:
Map<RID, RID> render_target_descriptors;
double time;
float delta;
double delta;
static uint64_t frame;
@ -100,7 +100,7 @@ public:
void finalize();
_ALWAYS_INLINE_ uint64_t get_frame_number() const { return frame; }
_ALWAYS_INLINE_ float get_frame_delta_time() const { return delta; }
_ALWAYS_INLINE_ double get_frame_delta_time() const { return delta; }
_ALWAYS_INLINE_ double get_total_time() const { return time; }
static Error is_viable() {

22
servers/rendering/renderer_rd/renderer_storage_rd.cpp
View file

@ -4091,7 +4091,7 @@ void RendererStorageRD::particles_set_amount(RID p_particles, int p_amount) {
particles->dependency.changed_notify(DEPENDENCY_CHANGED_PARTICLES);
}
void RendererStorageRD::particles_set_lifetime(RID p_particles, float p_lifetime) {
void RendererStorageRD::particles_set_lifetime(RID p_particles, double p_lifetime) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
particles->lifetime = p_lifetime;
@ -4103,7 +4103,7 @@ void RendererStorageRD::particles_set_one_shot(RID p_particles, bool p_one_shot)
particles->one_shot = p_one_shot;
}
void RendererStorageRD::particles_set_pre_process_time(RID p_particles, float p_time) {
void RendererStorageRD::particles_set_pre_process_time(RID p_particles, double p_time) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
particles->pre_process_time = p_time;
@ -4126,7 +4126,7 @@ void RendererStorageRD::particles_set_custom_aabb(RID p_particles, const AABB &p
particles->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
}
void RendererStorageRD::particles_set_speed_scale(RID p_particles, float p_scale) {
void RendererStorageRD::particles_set_speed_scale(RID p_particles, double p_scale) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
@ -4442,7 +4442,7 @@ void RendererStorageRD::particles_set_canvas_sdf_collision(RID p_particles, bool
particles->sdf_collision_texture = p_texture;
}
void RendererStorageRD::_particles_process(Particles *p_particles, float p_delta) {
void RendererStorageRD::_particles_process(Particles *p_particles, double p_delta) {
if (p_particles->particles_material_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(p_particles->particles_material_uniform_set)) {
Vector<RD::Uniform> uniforms;
@ -4491,7 +4491,7 @@ void RendererStorageRD::_particles_process(Particles *p_particles, float p_delta
p_particles->particles_material_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, particles_shader.default_shader_rd, 1);
}
float new_phase = Math::fmod((float)p_particles->phase + (p_delta / p_particles->lifetime) * p_particles->speed_scale, (float)1.0);
double new_phase = Math::fmod((double)p_particles->phase + (p_delta / p_particles->lifetime) * p_particles->speed_scale, 1.0);
//move back history (if there is any)
for (uint32_t i = p_particles->frame_history.size() - 1; i > 0; i--) {
@ -5131,14 +5131,14 @@ void RendererStorageRD::update_particles() {
bool zero_time_scale = Engine::get_singleton()->get_time_scale() <= 0.0;
if (particles->clear && particles->pre_process_time > 0.0) {
float frame_time;
double frame_time;
if (fixed_fps > 0) {
frame_time = 1.0 / fixed_fps;
} else {
frame_time = 1.0 / 30.0;
}
float todo = particles->pre_process_time;
double todo = particles->pre_process_time;
while (todo >= 0) {
_particles_process(particles, frame_time);
@ -5147,8 +5147,8 @@ void RendererStorageRD::update_particles() {
}
if (fixed_fps > 0) {
float frame_time;
float decr;
double frame_time;
double decr;
if (zero_time_scale) {
frame_time = 0.0;
decr = 1.0 / fixed_fps;
@ -5156,13 +5156,13 @@ void RendererStorageRD::update_particles() {
frame_time = 1.0 / fixed_fps;
decr = frame_time;
}
float delta = RendererCompositorRD::singleton->get_frame_delta_time();
double delta = RendererCompositorRD::singleton->get_frame_delta_time();
if (delta > 0.1) { //avoid recursive stalls if fps goes below 10
delta = 0.1;
} else if (delta <= 0.0) { //unlikely but..
delta = 0.001;
}
float todo = particles->frame_remainder + delta;
double todo = particles->frame_remainder + delta;
while (todo >= frame_time) {
_particles_process(particles, frame_time);

20
servers/rendering/renderer_rd/renderer_storage_rd.h
View file

@ -715,12 +715,12 @@ private:
struct Particles {
RS::ParticlesMode mode = RS::PARTICLES_MODE_3D;
bool inactive = true;
float inactive_time = 0.0;
double inactive_time = 0.0;
bool emitting = false;
bool one_shot = false;
int amount = 0;
float lifetime = 1.0;
float pre_process_time = 0.0;
double lifetime = 1.0;
double pre_process_time = 0.0;
float explosiveness = 0.0;
float randomness = 0.0;
bool restart_request = false;
@ -773,12 +773,12 @@ private:
uint32_t cycle_number = 0;
float speed_scale = 1.0;
double speed_scale = 1.0;
int fixed_fps = 30;
bool interpolate = true;
bool fractional_delta = false;
float frame_remainder = 0;
double frame_remainder = 0;
float collision_base_size = 0.01;
bool clear = true;
@ -805,14 +805,14 @@ private:
}
};
void _particles_process(Particles *p_particles, float p_delta);
void _particles_process(Particles *p_particles, double p_delta);
void _particles_allocate_emission_buffer(Particles *particles);
void _particles_free_data(Particles *particles);
void _particles_update_buffers(Particles *particles);
struct ParticlesShader {
struct PushConstant {
float lifetime;
double lifetime;
uint32_t clear;
uint32_t total_particles;
uint32_t trail_size;
@ -2144,13 +2144,13 @@ public:
void particles_set_mode(RID p_particles, RS::ParticlesMode p_mode);
void particles_set_emitting(RID p_particles, bool p_emitting);
void particles_set_amount(RID p_particles, int p_amount);
void particles_set_lifetime(RID p_particles, float p_lifetime);
void particles_set_lifetime(RID p_particles, double p_lifetime);
void particles_set_one_shot(RID p_particles, bool p_one_shot);
void particles_set_pre_process_time(RID p_particles, float p_time);
void particles_set_pre_process_time(RID p_particles, double p_time);
void particles_set_explosiveness_ratio(RID p_particles, float p_ratio);
void particles_set_randomness_ratio(RID p_particles, float p_ratio);
void particles_set_custom_aabb(RID p_particles, const AABB &p_aabb);
void particles_set_speed_scale(RID p_particles, float p_scale);
void particles_set_speed_scale(RID p_particles, double p_scale);
void particles_set_use_local_coordinates(RID p_particles, bool p_enable);
void particles_set_process_material(RID p_particles, RID p_material);
void particles_set_fixed_fps(RID p_particles, int p_fps);

6
servers/rendering/renderer_storage.h
View file

@ -468,13 +468,13 @@ public:
virtual bool particles_get_emitting(RID p_particles) = 0;
virtual void particles_set_amount(RID p_particles, int p_amount) = 0;
virtual void particles_set_lifetime(RID p_particles, float p_lifetime) = 0;
virtual void particles_set_lifetime(RID p_particles, double p_lifetime) = 0;
virtual void particles_set_one_shot(RID p_particles, bool p_one_shot) = 0;
virtual void particles_set_pre_process_time(RID p_particles, float p_time) = 0;
virtual void particles_set_pre_process_time(RID p_particles, double p_time) = 0;
virtual void particles_set_explosiveness_ratio(RID p_particles, float p_ratio) = 0;
virtual void particles_set_randomness_ratio(RID p_particles, float p_ratio) = 0;
virtual void particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) = 0;
virtual void particles_set_speed_scale(RID p_particles, float p_scale) = 0;
virtual void particles_set_speed_scale(RID p_particles, double p_scale) = 0;
virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable) = 0;
virtual void particles_set_process_material(RID p_particles, RID p_material) = 0;
virtual void particles_set_fixed_fps(RID p_particles, int p_fps) = 0;

12
servers/rendering/rendering_server_default.cpp
View file

@ -134,8 +134,8 @@ void RenderingServerDefault::_draw(bool p_swap_buffers, double frame_step) {
}
if (RSG::storage->capturing_timestamps) {
new_profile.write[i].gpu_msec = float((time_gpu - base_gpu) / 1000) / 1000.0;
new_profile.write[i].cpu_msec = float(time_cpu - base_cpu) / 1000.0;
new_profile.write[i].gpu_msec = double((time_gpu - base_gpu) / 1000) / 1000.0;
new_profile.write[i].cpu_msec = double(time_cpu - base_cpu) / 1000.0;
new_profile.write[i].name = RSG::storage->get_captured_timestamp_name(i);
}
}
@ -149,7 +149,7 @@ void RenderingServerDefault::_draw(bool p_swap_buffers, double frame_step) {
if (print_frame_profile_ticks_from == 0) {
print_frame_profile_ticks_from = OS::get_singleton()->get_ticks_usec();
}
float total_time = 0.0;
double total_time = 0.0;
for (int i = 0; i < frame_profile.size() - 1; i++) {
String name = frame_profile[i].name;
@ -157,7 +157,7 @@ void RenderingServerDefault::_draw(bool p_swap_buffers, double frame_step) {
continue;
}
float time = frame_profile[i + 1].gpu_msec - frame_profile[i].gpu_msec;
double time = frame_profile[i + 1].gpu_msec - frame_profile[i].gpu_msec;
if (name[0] != '<' && name[0] != '>') {
if (print_gpu_profile_task_time.has(name)) {
@ -179,7 +179,7 @@ void RenderingServerDefault::_draw(bool p_swap_buffers, double frame_step) {
float print_threshold = 0.01;
for (OrderedHashMap<String, float>::Element E = print_gpu_profile_task_time.front(); E; E = E.next()) {
float time = E.value() / float(print_frame_profile_frame_count);
double time = E.value() / double(print_frame_profile_frame_count);
if (time > print_threshold) {
print_line("\t-" + E.key() + ": " + rtos(time) + "ms");
}
@ -193,7 +193,7 @@ void RenderingServerDefault::_draw(bool p_swap_buffers, double frame_step) {
RSG::storage->update_memory_info();
}
float RenderingServerDefault::get_frame_setup_time_cpu() const {
double RenderingServerDefault::get_frame_setup_time_cpu() const {
return frame_setup_time;
}

14
servers/rendering/rendering_server_default.h
View file

@ -71,7 +71,7 @@ class RenderingServerDefault : public RenderingServer {
uint64_t frame_profile_frame;
Vector<FrameProfileArea> frame_profile;
float frame_setup_time = 0;
double frame_setup_time = 0;
//for printing
bool print_gpu_profile = false;
@ -440,13 +440,13 @@ public:
FUNC2(particles_set_emitting, RID, bool)
FUNC1R(bool, particles_get_emitting, RID)
FUNC2(particles_set_amount, RID, int)
FUNC2(particles_set_lifetime, RID, float)
FUNC2(particles_set_lifetime, RID, double)
FUNC2(particles_set_one_shot, RID, bool)
FUNC2(particles_set_pre_process_time, RID, float)
FUNC2(particles_set_pre_process_time, RID, double)
FUNC2(particles_set_explosiveness_ratio, RID, float)
FUNC2(particles_set_randomness_ratio, RID, float)
FUNC2(particles_set_custom_aabb, RID, const AABB &)
FUNC2(particles_set_speed_scale, RID, float)
FUNC2(particles_set_speed_scale, RID, double)
FUNC2(particles_set_use_local_coordinates, RID, bool)
FUNC2(particles_set_process_material, RID, RID)
FUNC2(particles_set_fixed_fps, RID, int)
@ -574,8 +574,8 @@ public:
FUNC2(viewport_set_debug_draw, RID, ViewportDebugDraw)
FUNC2(viewport_set_measure_render_time, RID, bool)
FUNC1RC(float, viewport_get_measured_render_time_cpu, RID)
FUNC1RC(float, viewport_get_measured_render_time_gpu, RID)
FUNC1RC(double, viewport_get_measured_render_time_cpu, RID)
FUNC1RC(double, viewport_get_measured_render_time_gpu, RID)
FUNC2(call_set_vsync_mode, DisplayServer::VSyncMode, DisplayServer::WindowID)
@ -890,7 +890,7 @@ public:
/* TESTING */
virtual float get_frame_setup_time_cpu() const override;
virtual double get_frame_setup_time_cpu() const override;
virtual void set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter = true) override;
virtual void set_default_clear_color(const Color &p_color) override;

16
servers/rendering_server.h
View file

@ -613,13 +613,13 @@ public:
virtual void particles_set_emitting(RID p_particles, bool p_enable) = 0;
virtual bool particles_get_emitting(RID p_particles) = 0;
virtual void particles_set_amount(RID p_particles, int p_amount) = 0;
virtual void particles_set_lifetime(RID p_particles, float p_lifetime) = 0;
virtual void particles_set_lifetime(RID p_particles, double p_lifetime) = 0;
virtual void particles_set_one_shot(RID p_particles, bool p_one_shot) = 0;
virtual void particles_set_pre_process_time(RID p_particles, float p_time) = 0;
virtual void particles_set_pre_process_time(RID p_particles, double p_time) = 0;
virtual void particles_set_explosiveness_ratio(RID p_particles, float p_ratio) = 0;
virtual void particles_set_randomness_ratio(RID p_particles, float p_ratio) = 0;
virtual void particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) = 0;
virtual void particles_set_speed_scale(RID p_particles, float p_scale) = 0;
virtual void particles_set_speed_scale(RID p_particles, double p_scale) = 0;
virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable) = 0;
virtual void particles_set_process_material(RID p_particles, RID p_material) = 0;
virtual void particles_set_fixed_fps(RID p_particles, int p_fps) = 0;
@ -900,8 +900,8 @@ public:
virtual void viewport_set_debug_draw(RID p_viewport, ViewportDebugDraw p_draw) = 0;
virtual void viewport_set_measure_render_time(RID p_viewport, bool p_enable) = 0;
virtual float viewport_get_measured_render_time_cpu(RID p_viewport) const = 0;
virtual float viewport_get_measured_render_time_gpu(RID p_viewport) const = 0;
virtual double viewport_get_measured_render_time_cpu(RID p_viewport) const = 0;
virtual double viewport_get_measured_render_time_gpu(RID p_viewport) const = 0;
/* SKY API */
@ -1436,15 +1436,15 @@ public:
struct FrameProfileArea {
String name;
float gpu_msec;
float cpu_msec;
double gpu_msec;
double cpu_msec;
};
virtual void set_frame_profiling_enabled(bool p_enable) = 0;
virtual Vector<FrameProfileArea> get_frame_profile() = 0;
virtual uint64_t get_frame_profile_frame() = 0;
virtual float get_frame_setup_time_cpu() const = 0;
virtual double get_frame_setup_time_cpu() const = 0;
virtual void gi_set_use_half_resolution(bool p_enable) = 0;