1 files changed, 79 insertions, 99 deletions
diff --git a/core/os/os.cpp b/core/os/os.cpp
index 425132fbec..182bab4058 100644
--- a/core/os/os.cpp
+++ b/core/os/os.cpp
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -30,20 +30,20 @@
 
 #include "os.h"
 
+#include "core/config/project_settings.h"
 #include "core/input/input.h"
 #include "core/os/dir_access.h"
 #include "core/os/file_access.h"
 #include "core/os/midi_driver.h"
-#include "core/project_settings.h"
 #include "core/version_generated.gen.h"
 #include "servers/audio_server.h"
 
 #include <stdarg.h>
 
 OS *OS::singleton = nullptr;
+uint64_t OS::target_ticks = 0;
 
 OS *OS::get_singleton() {
-
 	return singleton;
 }
 
@@ -80,23 +80,13 @@ String OS::get_iso_date_time(bool local) const {
 		   timezone;
 }
 
-uint64_t OS::get_splash_tick_msec() const {
-	return _msec_splash;
-}
-uint64_t OS::get_unix_time() const {
-
-	return 0;
-};
-uint64_t OS::get_system_time_secs() const {
-	return 0;
-}
-uint64_t OS::get_system_time_msecs() const {
+double OS::get_unix_time() const {
 	return 0;
 }
-void OS::debug_break(){
 
+void OS::debug_break() {
 	// something
-};
+}
 
 void OS::_set_logger(CompositeLogger *p_logger) {
 	if (_logger) {
@@ -116,19 +106,17 @@ void OS::add_logger(Logger *p_logger) {
 }
 
 void OS::print_error(const char *p_function, const char *p_file, int p_line, const char *p_code, const char *p_rationale, Logger::ErrorType p_type) {
-
 	_logger->log_error(p_function, p_file, p_line, p_code, p_rationale, p_type);
 }
 
 void OS::print(const char *p_format, ...) {
-
 	va_list argp;
 	va_start(argp, p_format);
 
 	_logger->logv(p_format, argp, false);
 
 	va_end(argp);
-};
+}
 
 void OS::printerr(const char *p_format, ...) {
 	va_list argp;
@@ -137,73 +125,67 @@ void OS::printerr(const char *p_format, ...) {
 	_logger->logv(p_format, argp, true);
 
 	va_end(argp);
-};
+}
 
 void OS::set_low_processor_usage_mode(bool p_enabled) {
-
 	low_processor_usage_mode = p_enabled;
 }
 
 bool OS::is_in_low_processor_usage_mode() const {
-
 	return low_processor_usage_mode;
 }
 
 void OS::set_low_processor_usage_mode_sleep_usec(int p_usec) {
-
 	low_processor_usage_mode_sleep_usec = p_usec;
 }
 
 int OS::get_low_processor_usage_mode_sleep_usec() const {
-
 	return low_processor_usage_mode_sleep_usec;
 }
 
 String OS::get_executable_path() const {
-
 	return _execpath;
 }
 
 int OS::get_process_id() const {
-
 	return -1;
-};
+}
 
 void OS::vibrate_handheld(int p_duration_ms) {
-
 	WARN_PRINT("vibrate_handheld() only works with Android and iOS");
 }
 
 bool OS::is_stdout_verbose() const {
-
 	return _verbose_stdout;
 }
 
-void OS::dump_memory_to_file(const char *p_file) {
+bool OS::is_stdout_debug_enabled() const {
+	return _debug_stdout;
+}
 
+void OS::dump_memory_to_file(const char *p_file) {
 	//Memory::dump_static_mem_to_file(p_file);
 }
 
 static FileAccess *_OSPRF = nullptr;
 
 static void _OS_printres(Object *p_obj) {
-
 	Resource *res = Object::cast_to<Resource>(p_obj);
-	if (!res)
+	if (!res) {
 		return;
+	}
 
 	String str = itos(res->get_instance_id()) + String(res->get_class()) + ":" + String(res->get_name()) + " - " + res->get_path();
-	if (_OSPRF)
+	if (_OSPRF) {
 		_OSPRF->store_line(str);
-	else
+	} else {
 		print_line(str);
+	}
 }
 
 void OS::print_all_resources(String p_to_file) {
-
 	ERR_FAIL_COND(p_to_file != "" && _OSPRF);
 	if (p_to_file != "") {
-
 		Error err;
 		_OSPRF = FileAccess::open(p_to_file, FileAccess::WRITE, &err);
 		if (err != OK) {
@@ -215,50 +197,43 @@ void OS::print_all_resources(String p_to_file) {
 	ObjectDB::debug_objects(_OS_printres);
 
 	if (p_to_file != "") {
-
-		if (_OSPRF)
+		if (_OSPRF) {
 			memdelete(_OSPRF);
+		}
 		_OSPRF = nullptr;
 	}
 }
 
 void OS::print_resources_in_use(bool p_short) {
-
 	ResourceCache::dump(nullptr, p_short);
 }
 
 void OS::dump_resources_to_file(const char *p_file) {
-
 	ResourceCache::dump(p_file);
 }
 
 void OS::set_no_window_mode(bool p_enable) {
-
 	_no_window = p_enable;
 }
 
 bool OS::is_no_window_mode_enabled() const {
-
 	return _no_window;
 }
 
 int OS::get_exit_code() const {
-
 	return _exit_code;
 }
-void OS::set_exit_code(int p_code) {
 
+void OS::set_exit_code(int p_code) {
 	_exit_code = p_code;
 }
 
 String OS::get_locale() const {
-
 	return "en";
 }
 
 // Helper function to ensure that a dir name/path will be valid on the OS
 String OS::get_safe_dir_name(const String &p_dir_name, bool p_allow_dir_separator) const {
-
 	Vector<String> invalid_chars = String(": * ? \" < > |").split(" ");
 	if (p_allow_dir_separator) {
 		// Dir separators are allowed, but disallow ".." to avoid going up the filesystem
@@ -278,76 +253,64 @@ String OS::get_safe_dir_name(const String &p_dir_name, bool p_allow_dir_separato
 
 // Get properly capitalized engine name for system paths
 String OS::get_godot_dir_name() const {
-
 	// Default to lowercase, so only override when different case is needed
 	return String(VERSION_SHORT_NAME).to_lower();
 }
 
 // OS equivalent of XDG_DATA_HOME
 String OS::get_data_path() const {
-
 	return ".";
 }
 
 // OS equivalent of XDG_CONFIG_HOME
 String OS::get_config_path() const {
-
 	return ".";
 }
 
 // OS equivalent of XDG_CACHE_HOME
 String OS::get_cache_path() const {
-
 	return ".";
 }
 
 // Path to macOS .app bundle resources
 String OS::get_bundle_resource_dir() const {
-
 	return ".";
-};
+}
 
 // OS specific path for user://
 String OS::get_user_data_dir() const {
-
 	return ".";
-};
+}
 
 // Absolute path to res://
 String OS::get_resource_dir() const {
-
 	return ProjectSettings::get_singleton()->get_resource_path();
 }
 
 // Access system-specific dirs like Documents, Downloads, etc.
 String OS::get_system_dir(SystemDir p_dir) const {
-
 	return ".";
 }
 
 Error OS::shell_open(String p_uri) {
 	return ERR_UNAVAILABLE;
-};
+}
 
 // implement these with the canvas?
 
 uint64_t OS::get_static_memory_usage() const {
-
 	return Memory::get_mem_usage();
 }
 
 uint64_t OS::get_static_memory_peak_usage() const {
-
 	return Memory::get_mem_max_usage();
 }
 
 Error OS::set_cwd(const String &p_cwd) {
-
 	return ERR_CANT_OPEN;
 }
 
 uint64_t OS::get_free_static_memory() const {
-
 	return Memory::get_mem_available();
 }
 
@@ -355,7 +318,6 @@ void OS::yield() {
 }
 
 void OS::ensure_user_data_dir() {
-
 	String dd = get_user_data_dir();
 	DirAccess *da = DirAccess::open(dd);
 	if (da) {
@@ -371,28 +333,23 @@ void OS::ensure_user_data_dir() {
 }
 
 String OS::get_model_name() const {
-
 	return "GenericDevice";
 }
 
 void OS::set_cmdline(const char *p_execpath, const List<String> &p_args) {
-
 	_execpath = p_execpath;
 	_cmdline = p_args;
-};
+}
 
 String OS::get_unique_id() const {
-
 	ERR_FAIL_V("");
 }
 
 int OS::get_processor_count() const {
-
 	return 1;
 }
 
 bool OS::can_use_threads() const {
-
 #ifdef NO_THREADS
 	return false;
 #else
@@ -401,24 +358,25 @@ bool OS::can_use_threads() const {
 }
 
 void OS::set_has_server_feature_callback(HasServerFeatureCallback p_callback) {
-
 	has_server_feature_callback = p_callback;
 }
 
 bool OS::has_feature(const String &p_feature) {
-
-	if (p_feature == get_name())
+	if (p_feature == get_name()) {
 		return true;
+	}
 #ifdef DEBUG_ENABLED
-	if (p_feature == "debug")
+	if (p_feature == "debug") {
 		return true;
+	}
 #else
 	if (p_feature == "release")
 		return true;
 #endif
 #ifdef TOOLS_ENABLED
-	if (p_feature == "editor")
+	if (p_feature == "editor") {
 		return true;
+	}
 #else
 	if (p_feature == "standalone")
 		return true;
@@ -458,15 +416,17 @@ bool OS::has_feature(const String &p_feature) {
 	}
 #endif
 
-	if (_check_internal_feature_support(p_feature))
+	if (_check_internal_feature_support(p_feature)) {
 		return true;
+	}
 
 	if (has_server_feature_callback && has_server_feature_callback(p_feature)) {
 		return true;
 	}
 
-	if (ProjectSettings::get_singleton()->has_custom_feature(p_feature))
+	if (ProjectSettings::get_singleton()->has_custom_feature(p_feature)) {
 		return true;
+	}
 
 	return false;
 }
@@ -485,47 +445,67 @@ List<String> OS::get_restart_on_exit_arguments() const {
 }
 
 PackedStringArray OS::get_connected_midi_inputs() {
-
-	if (MIDIDriver::get_singleton())
+	if (MIDIDriver::get_singleton()) {
 		return MIDIDriver::get_singleton()->get_connected_inputs();
+	}
 
 	PackedStringArray list;
-	return list;
+	ERR_FAIL_V_MSG(list, vformat("MIDI input isn't supported on %s.", OS::get_singleton()->get_name()));
 }
 
 void OS::open_midi_inputs() {
-
-	if (MIDIDriver::get_singleton())
+	if (MIDIDriver::get_singleton()) {
 		MIDIDriver::get_singleton()->open();
+	} else {
+		ERR_PRINT(vformat("MIDI input isn't supported on %s.", OS::get_singleton()->get_name()));
+	}
 }
 
 void OS::close_midi_inputs() {
-
-	if (MIDIDriver::get_singleton())
+	if (MIDIDriver::get_singleton()) {
 		MIDIDriver::get_singleton()->close();
+	} else {
+		ERR_PRINT(vformat("MIDI input isn't supported on %s.", OS::get_singleton()->get_name()));
+	}
 }
 
-OS::OS() {
-	void *volatile stack_bottom;
+void OS::add_frame_delay(bool p_can_draw) {
+	const uint32_t frame_delay = Engine::get_singleton()->get_frame_delay();
+	if (frame_delay) {
+		// Add fixed frame delay to decrease CPU/GPU usage. This doesn't take
+		// the actual frame time into account.
+		// Due to the high fluctuation of the actual sleep duration, it's not recommended
+		// to use this as a FPS limiter.
+		delay_usec(frame_delay * 1000);
+	}
 
-	restart_on_exit = false;
-	singleton = this;
-	_keep_screen_on = true; // set default value to true, because this had been true before godot 2.0.
-	low_processor_usage_mode = false;
-	low_processor_usage_mode_sleep_usec = 10000;
-	_verbose_stdout = false;
-	_no_window = false;
-	_exit_code = 0;
+	// Add a dynamic frame delay to decrease CPU/GPU usage. This takes the
+	// previous frame time into account for a smoother result.
+	uint64_t dynamic_delay = 0;
+	if (is_in_low_processor_usage_mode() || !p_can_draw) {
+		dynamic_delay = get_low_processor_usage_mode_sleep_usec();
+	}
+	const int target_fps = Engine::get_singleton()->get_target_fps();
+	if (target_fps > 0 && !Engine::get_singleton()->is_editor_hint()) {
+		// Override the low processor usage mode sleep delay if the target FPS is lower.
+		dynamic_delay = MAX(dynamic_delay, (uint64_t)(1000000 / target_fps));
+	}
 
-	_render_thread_mode = RENDER_THREAD_SAFE;
+	if (dynamic_delay > 0) {
+		target_ticks += dynamic_delay;
+		uint64_t current_ticks = get_ticks_usec();
 
-	_allow_hidpi = false;
-	_allow_layered = false;
-	_stack_bottom = (void *)(&stack_bottom);
+		if (current_ticks < target_ticks) {
+			delay_usec(target_ticks - current_ticks);
+		}
 
-	_logger = nullptr;
+		current_ticks = get_ticks_usec();
+		target_ticks = MIN(MAX(target_ticks, current_ticks - dynamic_delay), current_ticks + dynamic_delay);
+	}
+}
 
-	has_server_feature_callback = nullptr;
+OS::OS() {
+	singleton = this;
 
 	Vector<Logger *> loggers;
 	loggers.push_back(memnew(StdLogger));