summaryrefslogtreecommitdiff
path: root/core/config
diff options
context:
space:
mode:
authorreduz <reduzio@gmail.com>2020-11-07 19:33:38 -0300
committerreduz <reduzio@gmail.com>2020-11-07 20:17:12 -0300
commit127458ed175c5aeac8dee7f09d23fae4c8928eb7 (patch)
treea1dd3ae46bf575cb8296df38568dfce237c6ecd8 /core/config
parent30b6db99a99a94c64d906c1b828ff44f79a1bc75 (diff)
Reorganized core/ directory, it was too fatty already
-Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
Diffstat (limited to 'core/config')
-rw-r--r--core/config/SCsub7
-rw-r--r--core/config/engine.cpp221
-rw-r--r--core/config/engine.h134
-rw-r--r--core/config/project_settings.cpp1268
-rw-r--r--core/config/project_settings.h185
5 files changed, 1815 insertions, 0 deletions
diff --git a/core/config/SCsub b/core/config/SCsub
new file mode 100644
index 0000000000..bf70285490
--- /dev/null
+++ b/core/config/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env_config = env.Clone()
+
+env_config.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/config/engine.cpp b/core/config/engine.cpp
new file mode 100644
index 0000000000..b0037ffb37
--- /dev/null
+++ b/core/config/engine.cpp
@@ -0,0 +1,221 @@
+/*************************************************************************/
+/* engine.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#include "engine.h"
+
+#include "core/authors.gen.h"
+#include "core/donors.gen.h"
+#include "core/license.gen.h"
+#include "core/version.h"
+#include "core/version_hash.gen.h"
+
+void Engine::set_iterations_per_second(int p_ips) {
+ ERR_FAIL_COND_MSG(p_ips <= 0, "Engine iterations per second must be greater than 0.");
+ ips = p_ips;
+}
+
+int Engine::get_iterations_per_second() const {
+ return ips;
+}
+
+void Engine::set_physics_jitter_fix(float p_threshold) {
+ if (p_threshold < 0) {
+ p_threshold = 0;
+ }
+ physics_jitter_fix = p_threshold;
+}
+
+float Engine::get_physics_jitter_fix() const {
+ return physics_jitter_fix;
+}
+
+void Engine::set_target_fps(int p_fps) {
+ _target_fps = p_fps > 0 ? p_fps : 0;
+}
+
+int Engine::get_target_fps() const {
+ return _target_fps;
+}
+
+uint64_t Engine::get_frames_drawn() {
+ return frames_drawn;
+}
+
+void Engine::set_frame_delay(uint32_t p_msec) {
+ _frame_delay = p_msec;
+}
+
+uint32_t Engine::get_frame_delay() const {
+ return _frame_delay;
+}
+
+void Engine::set_time_scale(float p_scale) {
+ _time_scale = p_scale;
+}
+
+float Engine::get_time_scale() const {
+ return _time_scale;
+}
+
+Dictionary Engine::get_version_info() const {
+ Dictionary dict;
+ dict["major"] = VERSION_MAJOR;
+ dict["minor"] = VERSION_MINOR;
+ dict["patch"] = VERSION_PATCH;
+ dict["hex"] = VERSION_HEX;
+ dict["status"] = VERSION_STATUS;
+ dict["build"] = VERSION_BUILD;
+ dict["year"] = VERSION_YEAR;
+
+ String hash = VERSION_HASH;
+ dict["hash"] = hash.length() == 0 ? String("unknown") : hash;
+
+ String stringver = String(dict["major"]) + "." + String(dict["minor"]);
+ if ((int)dict["patch"] != 0) {
+ stringver += "." + String(dict["patch"]);
+ }
+ stringver += "-" + String(dict["status"]) + " (" + String(dict["build"]) + ")";
+ dict["string"] = stringver;
+
+ return dict;
+}
+
+static Array array_from_info(const char *const *info_list) {
+ Array arr;
+ for (int i = 0; info_list[i] != nullptr; i++) {
+ arr.push_back(info_list[i]);
+ }
+ return arr;
+}
+
+static Array array_from_info_count(const char *const *info_list, int info_count) {
+ Array arr;
+ for (int i = 0; i < info_count; i++) {
+ arr.push_back(info_list[i]);
+ }
+ return arr;
+}
+
+Dictionary Engine::get_author_info() const {
+ Dictionary dict;
+
+ dict["lead_developers"] = array_from_info(AUTHORS_LEAD_DEVELOPERS);
+ dict["project_managers"] = array_from_info(AUTHORS_PROJECT_MANAGERS);
+ dict["founders"] = array_from_info(AUTHORS_FOUNDERS);
+ dict["developers"] = array_from_info(AUTHORS_DEVELOPERS);
+
+ return dict;
+}
+
+Array Engine::get_copyright_info() const {
+ Array components;
+ for (int component_index = 0; component_index < COPYRIGHT_INFO_COUNT; component_index++) {
+ const ComponentCopyright &cp_info = COPYRIGHT_INFO[component_index];
+ Dictionary component_dict;
+ component_dict["name"] = cp_info.name;
+ Array parts;
+ for (int i = 0; i < cp_info.part_count; i++) {
+ const ComponentCopyrightPart &cp_part = cp_info.parts[i];
+ Dictionary part_dict;
+ part_dict["files"] = array_from_info_count(cp_part.files, cp_part.file_count);
+ part_dict["copyright"] = array_from_info_count(cp_part.copyright_statements, cp_part.copyright_count);
+ part_dict["license"] = cp_part.license;
+ parts.push_back(part_dict);
+ }
+ component_dict["parts"] = parts;
+
+ components.push_back(component_dict);
+ }
+ return components;
+}
+
+Dictionary Engine::get_donor_info() const {
+ Dictionary donors;
+ donors["platinum_sponsors"] = array_from_info(DONORS_SPONSOR_PLATINUM);
+ donors["gold_sponsors"] = array_from_info(DONORS_SPONSOR_GOLD);
+ donors["silver_sponsors"] = array_from_info(DONORS_SPONSOR_SILVER);
+ donors["bronze_sponsors"] = array_from_info(DONORS_SPONSOR_BRONZE);
+ donors["mini_sponsors"] = array_from_info(DONORS_SPONSOR_MINI);
+ donors["gold_donors"] = array_from_info(DONORS_GOLD);
+ donors["silver_donors"] = array_from_info(DONORS_SILVER);
+ donors["bronze_donors"] = array_from_info(DONORS_BRONZE);
+ return donors;
+}
+
+Dictionary Engine::get_license_info() const {
+ Dictionary licenses;
+ for (int i = 0; i < LICENSE_COUNT; i++) {
+ licenses[LICENSE_NAMES[i]] = LICENSE_BODIES[i];
+ }
+ return licenses;
+}
+
+String Engine::get_license_text() const {
+ return String(GODOT_LICENSE_TEXT);
+}
+
+bool Engine::is_abort_on_gpu_errors_enabled() const {
+ return abort_on_gpu_errors;
+}
+
+bool Engine::is_validation_layers_enabled() const {
+ return use_validation_layers;
+}
+
+void Engine::add_singleton(const Singleton &p_singleton) {
+ singletons.push_back(p_singleton);
+ singleton_ptrs[p_singleton.name] = p_singleton.ptr;
+}
+
+Object *Engine::get_singleton_object(const String &p_name) const {
+ const Map<StringName, Object *>::Element *E = singleton_ptrs.find(p_name);
+ ERR_FAIL_COND_V_MSG(!E, nullptr, "Failed to retrieve non-existent singleton '" + p_name + "'.");
+ return E->get();
+}
+
+bool Engine::has_singleton(const String &p_name) const {
+ return singleton_ptrs.has(p_name);
+}
+
+void Engine::get_singletons(List<Singleton> *p_singletons) {
+ for (List<Singleton>::Element *E = singletons.front(); E; E = E->next()) {
+ p_singletons->push_back(E->get());
+ }
+}
+
+Engine *Engine::singleton = nullptr;
+
+Engine *Engine::get_singleton() {
+ return singleton;
+}
+
+Engine::Engine() {
+ singleton = this;
+}
diff --git a/core/config/engine.h b/core/config/engine.h
new file mode 100644
index 0000000000..1d3d963b39
--- /dev/null
+++ b/core/config/engine.h
@@ -0,0 +1,134 @@
+/*************************************************************************/
+/* engine.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef ENGINE_H
+#define ENGINE_H
+
+#include "core/os/main_loop.h"
+#include "core/string/ustring.h"
+#include "core/templates/list.h"
+#include "core/templates/vector.h"
+
+class Engine {
+public:
+ struct Singleton {
+ StringName name;
+ Object *ptr;
+ Singleton(const StringName &p_name = StringName(), Object *p_ptr = nullptr) :
+ name(p_name),
+ ptr(p_ptr) {
+ }
+ };
+
+private:
+ friend class Main;
+
+ uint64_t frames_drawn = 0;
+ uint32_t _frame_delay = 0;
+ uint64_t _frame_ticks = 0;
+ float _frame_step = 0;
+
+ int ips = 60;
+ float physics_jitter_fix = 0.5;
+ float _fps = 1;
+ int _target_fps = 0;
+ float _time_scale = 1.0;
+ uint64_t _physics_frames = 0;
+ float _physics_interpolation_fraction = 0.0f;
+ bool abort_on_gpu_errors = false;
+ bool use_validation_layers = false;
+
+ uint64_t _idle_frames = 0;
+ bool _in_physics = false;
+
+ List<Singleton> singletons;
+ Map<StringName, Object *> singleton_ptrs;
+
+ bool editor_hint = false;
+
+ static Engine *singleton;
+
+public:
+ static Engine *get_singleton();
+
+ 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;
+
+ virtual void set_target_fps(int p_fps);
+ virtual int get_target_fps() const;
+
+ virtual float get_frames_per_second() const { return _fps; }
+
+ uint64_t get_frames_drawn();
+
+ uint64_t get_physics_frames() const { return _physics_frames; }
+ uint64_t get_idle_frames() const { return _idle_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; }
+ float get_physics_interpolation_fraction() const { return _physics_interpolation_fraction; }
+
+ void set_time_scale(float p_scale);
+ float get_time_scale() const;
+
+ void set_frame_delay(uint32_t p_msec);
+ uint32_t get_frame_delay() const;
+
+ void add_singleton(const Singleton &p_singleton);
+ void get_singletons(List<Singleton> *p_singletons);
+ bool has_singleton(const String &p_name) const;
+ Object *get_singleton_object(const String &p_name) const;
+
+#ifdef TOOLS_ENABLED
+ _FORCE_INLINE_ void set_editor_hint(bool p_enabled) { editor_hint = p_enabled; }
+ _FORCE_INLINE_ bool is_editor_hint() const { return editor_hint; }
+#else
+ _FORCE_INLINE_ void set_editor_hint(bool p_enabled) {}
+ _FORCE_INLINE_ bool is_editor_hint() const { return false; }
+#endif
+
+ Dictionary get_version_info() const;
+ Dictionary get_author_info() const;
+ Array get_copyright_info() const;
+ Dictionary get_donor_info() const;
+ Dictionary get_license_info() const;
+ String get_license_text() const;
+
+ bool is_abort_on_gpu_errors_enabled() const;
+ bool is_validation_layers_enabled() const;
+
+ Engine();
+ virtual ~Engine() {}
+};
+
+#endif // ENGINE_H
diff --git a/core/config/project_settings.cpp b/core/config/project_settings.cpp
new file mode 100644
index 0000000000..aa954ed300
--- /dev/null
+++ b/core/config/project_settings.cpp
@@ -0,0 +1,1268 @@
+/*************************************************************************/
+/* project_settings.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#include "project_settings.h"
+
+#include "core/core_bind.h"
+#include "core/core_string_names.h"
+#include "core/io/file_access_network.h"
+#include "core/io/file_access_pack.h"
+#include "core/io/marshalls.h"
+#include "core/os/dir_access.h"
+#include "core/os/file_access.h"
+#include "core/os/keyboard.h"
+#include "core/os/os.h"
+#include "core/variant/variant_parser.h"
+
+#include <zlib.h>
+
+ProjectSettings *ProjectSettings::singleton = nullptr;
+
+ProjectSettings *ProjectSettings::get_singleton() {
+ return singleton;
+}
+
+String ProjectSettings::get_resource_path() const {
+ return resource_path;
+}
+
+const String ProjectSettings::IMPORTED_FILES_PATH("res://.godot/imported");
+
+String ProjectSettings::localize_path(const String &p_path) const {
+ if (resource_path == "") {
+ return p_path; //not initialized yet
+ }
+
+ if (p_path.begins_with("res://") || p_path.begins_with("user://") ||
+ (p_path.is_abs_path() && !p_path.begins_with(resource_path))) {
+ return p_path.simplify_path();
+ }
+
+ DirAccess *dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
+
+ String path = p_path.replace("\\", "/").simplify_path();
+
+ if (dir->change_dir(path) == OK) {
+ String cwd = dir->get_current_dir();
+ cwd = cwd.replace("\\", "/");
+
+ memdelete(dir);
+
+ // Ensure that we end with a '/'.
+ // This is important to ensure that we do not wrongly localize the resource path
+ // in an absolute path that just happens to contain this string but points to a
+ // different folder (e.g. "/my/project" as resource_path would be contained in
+ // "/my/project_data", even though the latter is not part of res://.
+ // `plus_file("")` is an easy way to ensure we have a trailing '/'.
+ const String res_path = resource_path.plus_file("");
+
+ // DirAccess::get_current_dir() is not guaranteed to return a path that with a trailing '/',
+ // so we must make sure we have it as well in order to compare with 'res_path'.
+ cwd = cwd.plus_file("");
+
+ if (!cwd.begins_with(res_path)) {
+ return p_path;
+ }
+
+ return cwd.replace_first(res_path, "res://");
+ } else {
+ memdelete(dir);
+
+ int sep = path.rfind("/");
+ if (sep == -1) {
+ return "res://" + path;
+ }
+
+ String parent = path.substr(0, sep);
+
+ String plocal = localize_path(parent);
+ if (plocal == "") {
+ return "";
+ }
+ // Only strip the starting '/' from 'path' if its parent ('plocal') ends with '/'
+ if (plocal[plocal.length() - 1] == '/') {
+ sep += 1;
+ }
+ return plocal + path.substr(sep, path.size() - sep);
+ }
+}
+
+void ProjectSettings::set_initial_value(const String &p_name, const Variant &p_value) {
+ ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
+ props[p_name].initial = p_value;
+}
+
+void ProjectSettings::set_restart_if_changed(const String &p_name, bool p_restart) {
+ ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
+ props[p_name].restart_if_changed = p_restart;
+}
+
+void ProjectSettings::set_ignore_value_in_docs(const String &p_name, bool p_ignore) {
+ ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
+#ifdef DEBUG_METHODS_ENABLED
+ props[p_name].ignore_value_in_docs = p_ignore;
+#endif
+}
+
+bool ProjectSettings::get_ignore_value_in_docs(const String &p_name) const {
+ ERR_FAIL_COND_V_MSG(!props.has(p_name), false, "Request for nonexistent project setting: " + p_name + ".");
+#ifdef DEBUG_METHODS_ENABLED
+ return props[p_name].ignore_value_in_docs;
+#else
+ return false;
+#endif
+}
+
+String ProjectSettings::globalize_path(const String &p_path) const {
+ if (p_path.begins_with("res://")) {
+ if (resource_path != "") {
+ return p_path.replace("res:/", resource_path);
+ }
+ return p_path.replace("res://", "");
+ } else if (p_path.begins_with("user://")) {
+ String data_dir = OS::get_singleton()->get_user_data_dir();
+ if (data_dir != "") {
+ return p_path.replace("user:/", data_dir);
+ }
+ return p_path.replace("user://", "");
+ }
+
+ return p_path;
+}
+
+bool ProjectSettings::_set(const StringName &p_name, const Variant &p_value) {
+ _THREAD_SAFE_METHOD_
+
+ if (p_value.get_type() == Variant::NIL) {
+ props.erase(p_name);
+ if (p_name.operator String().begins_with("autoload/")) {
+ String node_name = p_name.operator String().split("/")[1];
+ if (autoloads.has(node_name)) {
+ remove_autoload(node_name);
+ }
+ }
+ } else {
+ if (p_name == CoreStringNames::get_singleton()->_custom_features) {
+ Vector<String> custom_feature_array = String(p_value).split(",");
+ for (int i = 0; i < custom_feature_array.size(); i++) {
+ custom_features.insert(custom_feature_array[i]);
+ }
+ return true;
+ }
+
+ if (!disable_feature_overrides) {
+ int dot = p_name.operator String().find(".");
+ if (dot != -1) {
+ Vector<String> s = p_name.operator String().split(".");
+
+ bool override_valid = false;
+ for (int i = 1; i < s.size(); i++) {
+ String feature = s[i].strip_edges();
+ if (OS::get_singleton()->has_feature(feature) || custom_features.has(feature)) {
+ override_valid = true;
+ break;
+ }
+ }
+
+ if (override_valid) {
+ feature_overrides[s[0]] = p_name;
+ }
+ }
+ }
+
+ if (props.has(p_name)) {
+ if (!props[p_name].overridden) {
+ props[p_name].variant = p_value;
+ }
+
+ } else {
+ props[p_name] = VariantContainer(p_value, last_order++);
+ }
+ if (p_name.operator String().begins_with("autoload/")) {
+ String node_name = p_name.operator String().split("/")[1];
+ AutoloadInfo autoload;
+ autoload.name = node_name;
+ String path = p_value;
+ if (path.begins_with("*")) {
+ autoload.is_singleton = true;
+ autoload.path = path.substr(1);
+ } else {
+ autoload.path = path;
+ }
+ add_autoload(autoload);
+ }
+ }
+
+ return true;
+}
+
+bool ProjectSettings::_get(const StringName &p_name, Variant &r_ret) const {
+ _THREAD_SAFE_METHOD_
+
+ StringName name = p_name;
+ if (!disable_feature_overrides && feature_overrides.has(name)) {
+ name = feature_overrides[name];
+ }
+ if (!props.has(name)) {
+ WARN_PRINT("Property not found: " + String(name));
+ return false;
+ }
+ r_ret = props[name].variant;
+ return true;
+}
+
+struct _VCSort {
+ String name;
+ Variant::Type type;
+ int order;
+ int flags;
+
+ bool operator<(const _VCSort &p_vcs) const { return order == p_vcs.order ? name < p_vcs.name : order < p_vcs.order; }
+};
+
+void ProjectSettings::_get_property_list(List<PropertyInfo> *p_list) const {
+ _THREAD_SAFE_METHOD_
+
+ Set<_VCSort> vclist;
+
+ for (Map<StringName, VariantContainer>::Element *E = props.front(); E; E = E->next()) {
+ const VariantContainer *v = &E->get();
+
+ if (v->hide_from_editor) {
+ continue;
+ }
+
+ _VCSort vc;
+ vc.name = E->key();
+ vc.order = v->order;
+ vc.type = v->variant.get_type();
+ if (vc.name.begins_with("input/") || vc.name.begins_with("import/") || vc.name.begins_with("export/") || vc.name.begins_with("/remap") || vc.name.begins_with("/locale") || vc.name.begins_with("/autoload")) {
+ vc.flags = PROPERTY_USAGE_STORAGE;
+ } else {
+ vc.flags = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE;
+ }
+
+ if (v->restart_if_changed) {
+ vc.flags |= PROPERTY_USAGE_RESTART_IF_CHANGED;
+ }
+ vclist.insert(vc);
+ }
+
+ for (Set<_VCSort>::Element *E = vclist.front(); E; E = E->next()) {
+ String prop_info_name = E->get().name;
+ int dot = prop_info_name.find(".");
+ if (dot != -1) {
+ prop_info_name = prop_info_name.substr(0, dot);
+ }
+
+ if (custom_prop_info.has(prop_info_name)) {
+ PropertyInfo pi = custom_prop_info[prop_info_name];
+ pi.name = E->get().name;
+ pi.usage = E->get().flags;
+ p_list->push_back(pi);
+ } else {
+ p_list->push_back(PropertyInfo(E->get().type, E->get().name, PROPERTY_HINT_NONE, "", E->get().flags));
+ }
+ }
+}
+
+bool ProjectSettings::_load_resource_pack(const String &p_pack, bool p_replace_files, int p_offset) {
+ if (PackedData::get_singleton()->is_disabled()) {
+ return false;
+ }
+
+ bool ok = PackedData::get_singleton()->add_pack(p_pack, p_replace_files, p_offset) == OK;
+
+ if (!ok) {
+ return false;
+ }
+
+ //if data.pck is found, all directory access will be from here
+ DirAccess::make_default<DirAccessPack>(DirAccess::ACCESS_RESOURCES);
+ using_datapack = true;
+
+ return true;
+}
+
+void ProjectSettings::_convert_to_last_version(int p_from_version) {
+ if (p_from_version <= 3) {
+ // Converts the actions from array to dictionary (array of events to dictionary with deadzone + events)
+ for (Map<StringName, ProjectSettings::VariantContainer>::Element *E = props.front(); E; E = E->next()) {
+ Variant value = E->get().variant;
+ if (String(E->key()).begins_with("input/") && value.get_type() == Variant::ARRAY) {
+ Array array = value;
+ Dictionary action;
+ action["deadzone"] = Variant(0.5f);
+ action["events"] = array;
+ E->get().variant = action;
+ }
+ }
+ }
+}
+
+/*
+ * This method is responsible for loading a project.godot file and/or data file
+ * using the following merit order:
+ * - If using NetworkClient, try to lookup project file or fail.
+ * - If --main-pack was passed by the user (`p_main_pack`), load it or fail.
+ * - Search for project PCKs automatically. For each step we try loading a potential
+ * PCK, and if it doesn't work, we proceed to the next step. If any step succeeds,
+ * we try loading the project settings, and abort if it fails. Steps:
+ * o Bundled PCK in the executable.
+ * o [macOS only] PCK with same basename as the binary in the .app resource dir.
+ * o PCK with same basename as the binary in the binary's directory. We handle both
+ * changing the extension to '.pck' (e.g. 'win_game.exe' -> 'win_game.pck') and
+ * appending '.pck' to the binary name (e.g. 'linux_game' -> 'linux_game.pck').
+ * o PCK with the same basename as the binary in the current working directory.
+ * Same as above for the two possible PCK file names.
+ * - On relevant platforms (Android/iOS), lookup project file in OS resource path.
+ * If found, load it or fail.
+ * - Lookup project file in passed `p_path` (--path passed by the user), i.e. we
+ * are running from source code.
+ * If not found and `p_upwards` is true (--upwards passed by the user), look for
+ * project files in parent folders up to the system root (used to run a game
+ * from command line while in a subfolder).
+ * If a project file is found, load it or fail.
+ * If nothing was found, error out.
+ */
+Error ProjectSettings::_setup(const String &p_path, const String &p_main_pack, bool p_upwards) {
+ // If looking for files in a network client, use it directly
+
+ if (FileAccessNetworkClient::get_singleton()) {
+ Error err = _load_settings_text_or_binary("res://project.godot", "res://project.binary");
+ if (err == OK) {
+ // Optional, we don't mind if it fails
+ _load_settings_text("res://override.cfg");
+ }
+ return err;
+ }
+
+ // Attempt with a user-defined main pack first
+
+ if (p_main_pack != "") {
+ bool ok = _load_resource_pack(p_main_pack);
+ ERR_FAIL_COND_V_MSG(!ok, ERR_CANT_OPEN, "Cannot open resource pack '" + p_main_pack + "'.");
+
+ Error err = _load_settings_text_or_binary("res://project.godot", "res://project.binary");
+ if (err == OK) {
+ // Load override from location of the main pack
+ // Optional, we don't mind if it fails
+ _load_settings_text(p_main_pack.get_base_dir().plus_file("override.cfg"));
+ }
+ return err;
+ }
+
+ String exec_path = OS::get_singleton()->get_executable_path();
+
+ if (exec_path != "") {
+ // We do several tests sequentially until one succeeds to find a PCK,
+ // and if so we attempt loading it at the end.
+
+ // Attempt with PCK bundled into executable.
+ bool found = _load_resource_pack(exec_path);
+
+ // Attempt with exec_name.pck.
+ // (This is the usual case when distributing a Godot game.)
+ String exec_dir = exec_path.get_base_dir();
+ String exec_filename = exec_path.get_file();
+ String exec_basename = exec_filename.get_basename();
+
+ // Based on the OS, it can be the exec path + '.pck' (Linux w/o extension, macOS in .app bundle)
+ // or the exec path's basename + '.pck' (Windows).
+ // We need to test both possibilities as extensions for Linux binaries are optional
+ // (so both 'mygame.bin' and 'mygame' should be able to find 'mygame.pck').
+
+#ifdef OSX_ENABLED
+ if (!found) {
+ // Attempt to load PCK from macOS .app bundle resources.
+ found = _load_resource_pack(OS::get_singleton()->get_bundle_resource_dir().plus_file(exec_basename + ".pck"));
+ }
+#endif
+
+ if (!found) {
+ // Try to load data pack at the location of the executable.
+ // As mentioned above, we have two potential names to attempt.
+ found = _load_resource_pack(exec_dir.plus_file(exec_basename + ".pck")) || _load_resource_pack(exec_dir.plus_file(exec_filename + ".pck"));
+ }
+
+ if (!found) {
+ // If we couldn't find them next to the executable, we attempt
+ // the current working directory. Same story, two tests.
+ found = _load_resource_pack(exec_basename + ".pck") || _load_resource_pack(exec_filename + ".pck");
+ }
+
+ // If we opened our package, try and load our project.
+ if (found) {
+ Error err = _load_settings_text_or_binary("res://project.godot", "res://project.binary");
+ if (err == OK) {
+ // Load override from location of the executable.
+ // Optional, we don't mind if it fails.
+ _load_settings_text(exec_path.get_base_dir().plus_file("override.cfg"));
+ }
+ return err;
+ }
+ }
+
+ // Try to use the filesystem for files, according to OS.
+ // (Only Android -when reading from pck- and iOS use this.)
+
+ if (OS::get_singleton()->get_resource_dir() != "") {
+ // OS will call ProjectSettings->get_resource_path which will be empty if not overridden!
+ // If the OS would rather use a specific location, then it will not be empty.
+ resource_path = OS::get_singleton()->get_resource_dir().replace("\\", "/");
+ if (resource_path != "" && resource_path[resource_path.length() - 1] == '/') {
+ resource_path = resource_path.substr(0, resource_path.length() - 1); // Chop end.
+ }
+
+ Error err = _load_settings_text_or_binary("res://project.godot", "res://project.binary");
+ if (err == OK) {
+ // Optional, we don't mind if it fails.
+ _load_settings_text("res://override.cfg");
+ }
+ return err;
+ }
+
+ // Nothing was found, try to find a project file in provided path (`p_path`)
+ // or, if requested (`p_upwards`) in parent directories.
+
+ DirAccess *d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
+ ERR_FAIL_COND_V_MSG(!d, ERR_CANT_CREATE, "Cannot create DirAccess for path '" + p_path + "'.");
+ d->change_dir(p_path);
+
+ String current_dir = d->get_current_dir();
+ String candidate = current_dir;
+ bool found = false;
+ Error err;
+
+ while (true) {
+ err = _load_settings_text_or_binary(current_dir.plus_file("project.godot"), current_dir.plus_file("project.binary"));
+ if (err == OK) {
+ // Optional, we don't mind if it fails.
+ _load_settings_text(current_dir.plus_file("override.cfg"));
+ candidate = current_dir;
+ found = true;
+ break;
+ }
+
+ if (p_upwards) {
+ // Try to load settings ascending through parent directories
+ d->change_dir("..");
+ if (d->get_current_dir() == current_dir) {
+ break; // not doing anything useful
+ }
+ current_dir = d->get_current_dir();
+ } else {
+ break;
+ }
+ }
+
+ resource_path = candidate;
+ resource_path = resource_path.replace("\\", "/"); // Windows path to Unix path just in case.
+ memdelete(d);
+
+ if (!found) {
+ return err;
+ }
+
+ if (resource_path.length() && resource_path[resource_path.length() - 1] == '/') {
+ resource_path = resource_path.substr(0, resource_path.length() - 1); // Chop end.
+ }
+
+ return OK;
+}
+
+Error ProjectSettings::setup(const String &p_path, const String &p_main_pack, bool p_upwards) {
+ Error err = _setup(p_path, p_main_pack, p_upwards);
+ if (err == OK) {
+ String custom_settings = GLOBAL_DEF("application/config/project_settings_override", "");
+ if (custom_settings != "") {
+ _load_settings_text(custom_settings);
+ }
+ }
+ // Using GLOBAL_GET on every block for compressing can be slow, so assigning here.
+ Compression::zstd_long_distance_matching = GLOBAL_GET("compression/formats/zstd/long_distance_matching");
+ Compression::zstd_level = GLOBAL_GET("compression/formats/zstd/compression_level");
+ Compression::zstd_window_log_size = GLOBAL_GET("compression/formats/zstd/window_log_size");
+
+ Compression::zlib_level = GLOBAL_GET("compression/formats/zlib/compression_level");
+
+ Compression::gzip_level = GLOBAL_GET("compression/formats/gzip/compression_level");
+
+ return err;
+}
+
+bool ProjectSettings::has_setting(String p_var) const {
+ _THREAD_SAFE_METHOD_
+
+ return props.has(p_var);
+}
+
+void ProjectSettings::set_registering_order(bool p_enable) {
+ registering_order = p_enable;
+}
+
+Error ProjectSettings::_load_settings_binary(const String &p_path) {
+ Error err;
+ FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
+ if (err != OK) {
+ return err;
+ }
+
+ uint8_t hdr[4];
+ f->get_buffer(hdr, 4);
+ if (hdr[0] != 'E' || hdr[1] != 'C' || hdr[2] != 'F' || hdr[3] != 'G') {
+ memdelete(f);
+ ERR_FAIL_V_MSG(ERR_FILE_CORRUPT, "Corrupted header in binary project.binary (not ECFG).");
+ }
+
+ uint32_t count = f->get_32();
+
+ for (uint32_t i = 0; i < count; i++) {
+ uint32_t slen = f->get_32();
+ CharString cs;
+ cs.resize(slen + 1);
+ cs[slen] = 0;
+ f->get_buffer((uint8_t *)cs.ptr(), slen);
+ String key;
+ key.parse_utf8(cs.ptr());
+
+ uint32_t vlen = f->get_32();
+ Vector<uint8_t> d;
+ d.resize(vlen);
+ f->get_buffer(d.ptrw(), vlen);
+ Variant value;
+ err = decode_variant(value, d.ptr(), d.size(), nullptr, true);
+ ERR_CONTINUE_MSG(err != OK, "Error decoding property: " + key + ".");
+ set(key, value);
+ }
+
+ f->close();
+ memdelete(f);
+ return OK;
+}
+
+Error ProjectSettings::_load_settings_text(const String &p_path) {
+ Error err;
+ FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
+
+ if (!f) {
+ // FIXME: Above 'err' error code is ERR_FILE_CANT_OPEN if the file is missing
+ // This needs to be streamlined if we want decent error reporting
+ return ERR_FILE_NOT_FOUND;
+ }
+
+ VariantParser::StreamFile stream;
+ stream.f = f;
+
+ String assign;
+ Variant value;
+ VariantParser::Tag next_tag;
+
+ int lines = 0;
+ String error_text;
+ String section;
+ int config_version = 0;
+
+ while (true) {
+ assign = Variant();
+ next_tag.fields.clear();
+ next_tag.name = String();
+
+ err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, nullptr, true);
+ if (err == ERR_FILE_EOF) {
+ memdelete(f);
+ // If we're loading a project.godot from source code, we can operate some
+ // ProjectSettings conversions if need be.
+ _convert_to_last_version(config_version);
+ return OK;
+ } else if (err != OK) {
+ ERR_PRINT("Error parsing " + p_path + " at line " + itos(lines) + ": " + error_text + " File might be corrupted.");
+ memdelete(f);
+ return err;
+ }
+
+ if (assign != String()) {
+ if (section == String() && assign == "config_version") {
+ config_version = value;
+ if (config_version > CONFIG_VERSION) {
+ memdelete(f);
+ ERR_FAIL_V_MSG(ERR_FILE_CANT_OPEN, vformat("Can't open project at '%s', its `config_version` (%d) is from a more recent and incompatible version of the engine. Expected config version: %d.", p_path, config_version, CONFIG_VERSION));
+ }
+ } else {
+ if (section == String()) {
+ set(assign, value);
+ } else {
+ set(section + "/" + assign, value);
+ }
+ }
+ } else if (next_tag.name != String()) {
+ section = next_tag.name;
+ }
+ }
+}
+
+Error ProjectSettings::_load_settings_text_or_binary(const String &p_text_path, const String &p_bin_path) {
+ // Attempt first to load the binary project.godot file.
+ Error err = _load_settings_binary(p_bin_path);
+ if (err == OK) {
+ return OK;
+ } else if (err != ERR_FILE_NOT_FOUND) {
+ // If the file exists but can't be loaded, we want to know it.
+ ERR_PRINT("Couldn't load file '" + p_bin_path + "', error code " + itos(err) + ".");
+ return err;
+ }
+
+ // Fallback to text-based project.godot file if binary was not found.
+ err = _load_settings_text(p_text_path);
+ if (err == OK) {
+ return OK;
+ } else if (err != ERR_FILE_NOT_FOUND) {
+ ERR_PRINT("Couldn't load file '" + p_text_path + "', error code " + itos(err) + ".");
+ return err;
+ }
+
+ return err;
+}
+
+int ProjectSettings::get_order(const String &p_name) const {
+ ERR_FAIL_COND_V_MSG(!props.has(p_name), -1, "Request for nonexistent project setting: " + p_name + ".");
+ return props[p_name].order;
+}
+
+void ProjectSettings::set_order(const String &p_name, int p_order) {
+ ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
+ props[p_name].order = p_order;
+}
+
+void ProjectSettings::set_builtin_order(const String &p_name) {
+ ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
+ if (props[p_name].order >= NO_BUILTIN_ORDER_BASE) {
+ props[p_name].order = last_builtin_order++;
+ }
+}
+
+bool ProjectSettings::is_builtin_setting(const String &p_name) const {
+ // Return true because a false negative is worse than a false positive.
+ ERR_FAIL_COND_V_MSG(!props.has(p_name), true, "Request for nonexistent project setting: " + p_name + ".");
+ return props[p_name].order < NO_BUILTIN_ORDER_BASE;
+}
+
+void ProjectSettings::clear(const String &p_name) {
+ ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
+ props.erase(p_name);
+}
+
+Error ProjectSettings::save() {
+ return save_custom(get_resource_path().plus_file("project.godot"));
+}
+
+Error ProjectSettings::_save_settings_binary(const String &p_file, const Map<String, List<String>> &props, const CustomMap &p_custom, const String &p_custom_features) {
+ Error err;
+ FileAccess *file = FileAccess::open(p_file, FileAccess::WRITE, &err);
+ ERR_FAIL_COND_V_MSG(err != OK, err, "Couldn't save project.binary at " + p_file + ".");
+
+ uint8_t hdr[4] = { 'E', 'C', 'F', 'G' };
+ file->store_buffer(hdr, 4);
+
+ int count = 0;
+
+ for (Map<String, List<String>>::Element *E = props.front(); E; E = E->next()) {
+ for (List<String>::Element *F = E->get().front(); F; F = F->next()) {
+ count++;
+ }
+ }
+
+ if (p_custom_features != String()) {
+ file->store_32(count + 1);
+ //store how many properties are saved, add one for custom featuers, which must always go first
+ String key = CoreStringNames::get_singleton()->_custom_features;
+ file->store_32(key.length());
+ file->store_string(key);
+
+ int len;
+ err = encode_variant(p_custom_features, nullptr, len, false);
+ if (err != OK) {
+ memdelete(file);
+ ERR_FAIL_V(err);
+ }
+
+ Vector<uint8_t> buff;
+ buff.resize(len);
+
+ err = encode_variant(p_custom_features, buff.ptrw(), len, false);
+ if (err != OK) {
+ memdelete(file);
+ ERR_FAIL_V(err);
+ }
+ file->store_32(len);
+ file->store_buffer(buff.ptr(), buff.size());
+
+ } else {
+ file->store_32(count); //store how many properties are saved
+ }
+
+ for (Map<String, List<String>>::Element *E = props.front(); E; E = E->next()) {
+ for (List<String>::Element *F = E->get().front(); F; F = F->next()) {
+ String key = F->get();
+ if (E->key() != "") {
+ key = E->key() + "/" + key;
+ }
+ Variant value;
+ if (p_custom.has(key)) {
+ value = p_custom[key];
+ } else {
+ value = get(key);
+ }
+
+ file->store_32(key.length());
+ file->store_string(key);
+
+ int len;
+ err = encode_variant(value, nullptr, len, true);
+ if (err != OK) {
+ memdelete(file);
+ }
+ ERR_FAIL_COND_V_MSG(err != OK, ERR_INVALID_DATA, "Error when trying to encode Variant.");
+
+ Vector<uint8_t> buff;
+ buff.resize(len);
+
+ err = encode_variant(value, buff.ptrw(), len, true);
+ if (err != OK) {
+ memdelete(file);
+ }
+ ERR_FAIL_COND_V_MSG(err != OK, ERR_INVALID_DATA, "Error when trying to encode Variant.");
+ file->store_32(len);
+ file->store_buffer(buff.ptr(), buff.size());
+ }
+ }
+
+ file->close();
+ memdelete(file);
+
+ return OK;
+}
+
+Error ProjectSettings::_save_settings_text(const String &p_file, const Map<String, List<String>> &props, const CustomMap &p_custom, const String &p_custom_features) {
+ Error err;
+ FileAccess *file = FileAccess::open(p_file, FileAccess::WRITE, &err);
+
+ ERR_FAIL_COND_V_MSG(err != OK, err, "Couldn't save project.godot - " + p_file + ".");
+
+ file->store_line("; Engine configuration file.");
+ file->store_line("; It's best edited using the editor UI and not directly,");
+ file->store_line("; since the parameters that go here are not all obvious.");
+ file->store_line(";");
+ file->store_line("; Format:");
+ file->store_line("; [section] ; section goes between []");
+ file->store_line("; param=value ; assign values to parameters");
+ file->store_line("");
+
+ file->store_string("config_version=" + itos(CONFIG_VERSION) + "\n");
+ if (p_custom_features != String()) {
+ file->store_string("custom_features=\"" + p_custom_features + "\"\n");
+ }
+ file->store_string("\n");
+
+ for (Map<String, List<String>>::Element *E = props.front(); E; E = E->next()) {
+ if (E != props.front()) {
+ file->store_string("\n");
+ }
+
+ if (E->key() != "") {
+ file->store_string("[" + E->key() + "]\n\n");
+ }
+ for (List<String>::Element *F = E->get().front(); F; F = F->next()) {
+ String key = F->get();
+ if (E->key() != "") {
+ key = E->key() + "/" + key;
+ }
+ Variant value;
+ if (p_custom.has(key)) {
+ value = p_custom[key];
+ } else {
+ value = get(key);
+ }
+
+ String vstr;
+ VariantWriter::write_to_string(value, vstr);
+ file->store_string(F->get().property_name_encode() + "=" + vstr + "\n");
+ }
+ }
+
+ file->close();
+ memdelete(file);
+
+ return OK;
+}
+
+Error ProjectSettings::_save_custom_bnd(const String &p_file) { // add other params as dictionary and array?
+
+ return save_custom(p_file);
+}
+
+Error ProjectSettings::save_custom(const String &p_path, const CustomMap &p_custom, const Vector<String> &p_custom_features, bool p_merge_with_current) {
+ ERR_FAIL_COND_V_MSG(p_path == "", ERR_INVALID_PARAMETER, "Project settings save path cannot be empty.");
+
+ Set<_VCSort> vclist;
+
+ if (p_merge_with_current) {
+ for (Map<StringName, VariantContainer>::Element *G = props.front(); G; G = G->next()) {
+ const VariantContainer *v = &G->get();
+
+ if (v->hide_from_editor) {
+ continue;
+ }
+
+ if (p_custom.has(G->key())) {
+ continue;
+ }
+
+ _VCSort vc;
+ vc.name = G->key(); //*k;
+ vc.order = v->order;
+ vc.type = v->variant.get_type();
+ vc.flags = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE;
+ if (v->variant == v->initial) {
+ continue;
+ }
+
+ vclist.insert(vc);
+ }
+ }
+
+ for (const Map<String, Variant>::Element *E = p_custom.front(); E; E = E->next()) {
+ // Lookup global prop to store in the same order
+ Map<StringName, VariantContainer>::Element *global_prop = props.find(E->key());
+
+ _VCSort vc;
+ vc.name = E->key();
+ vc.order = global_prop ? global_prop->get().order : 0xFFFFFFF;
+ vc.type = E->get().get_type();
+ vc.flags = PROPERTY_USAGE_STORAGE;
+ vclist.insert(vc);
+ }
+
+ Map<String, List<String>> props;
+
+ for (Set<_VCSort>::Element *E = vclist.front(); E; E = E->next()) {
+ String category = E->get().name;
+ String name = E->get().name;
+
+ int div = category.find("/");
+
+ if (div < 0) {
+ category = "";
+ } else {
+ category = category.substr(0, div);
+ name = name.substr(div + 1, name.size());
+ }
+ props[category].push_back(name);
+ }
+
+ String custom_features;
+
+ for (int i = 0; i < p_custom_features.size(); i++) {
+ if (i > 0) {
+ custom_features += ",";
+ }
+
+ String f = p_custom_features[i].strip_edges().replace("\"", "");
+ custom_features += f;
+ }
+
+ if (p_path.ends_with(".godot")) {
+ return _save_settings_text(p_path, props, p_custom, custom_features);
+ } else if (p_path.ends_with(".binary")) {
+ return _save_settings_binary(p_path, props, p_custom, custom_features);
+ } else {
+ ERR_FAIL_V_MSG(ERR_FILE_UNRECOGNIZED, "Unknown config file format: " + p_path + ".");
+ }
+}
+
+Variant _GLOBAL_DEF(const String &p_var, const Variant &p_default, bool p_restart_if_changed, bool p_ignore_value_in_docs) {
+ Variant ret;
+ if (!ProjectSettings::get_singleton()->has_setting(p_var)) {
+ ProjectSettings::get_singleton()->set(p_var, p_default);
+ }
+ ret = ProjectSettings::get_singleton()->get(p_var);
+
+ ProjectSettings::get_singleton()->set_initial_value(p_var, p_default);
+ ProjectSettings::get_singleton()->set_builtin_order(p_var);
+ ProjectSettings::get_singleton()->set_restart_if_changed(p_var, p_restart_if_changed);
+ ProjectSettings::get_singleton()->set_ignore_value_in_docs(p_var, p_ignore_value_in_docs);
+ return ret;
+}
+
+Vector<String> ProjectSettings::get_optimizer_presets() const {
+ List<PropertyInfo> pi;
+ ProjectSettings::get_singleton()->get_property_list(&pi);
+ Vector<String> names;
+
+ for (List<PropertyInfo>::Element *E = pi.front(); E; E = E->next()) {
+ if (!E->get().name.begins_with("optimizer_presets/")) {
+ continue;
+ }
+ names.push_back(E->get().name.get_slicec('/', 1));
+ }
+
+ names.sort();
+
+ return names;
+}
+
+void ProjectSettings::_add_property_info_bind(const Dictionary &p_info) {
+ ERR_FAIL_COND(!p_info.has("name"));
+ ERR_FAIL_COND(!p_info.has("type"));
+
+ PropertyInfo pinfo;
+ pinfo.name = p_info["name"];
+ ERR_FAIL_COND(!props.has(pinfo.name));
+ pinfo.type = Variant::Type(p_info["type"].operator int());
+ ERR_FAIL_INDEX(pinfo.type, Variant::VARIANT_MAX);
+
+ if (p_info.has("hint")) {
+ pinfo.hint = PropertyHint(p_info["hint"].operator int());
+ }
+ if (p_info.has("hint_string")) {
+ pinfo.hint_string = p_info["hint_string"];
+ }
+
+ set_custom_property_info(pinfo.name, pinfo);
+}
+
+void ProjectSettings::set_custom_property_info(const String &p_prop, const PropertyInfo &p_info) {
+ ERR_FAIL_COND(!props.has(p_prop));
+ custom_prop_info[p_prop] = p_info;
+ custom_prop_info[p_prop].name = p_prop;
+}
+
+const Map<StringName, PropertyInfo> &ProjectSettings::get_custom_property_info() const {
+ return custom_prop_info;
+}
+
+void ProjectSettings::set_disable_feature_overrides(bool p_disable) {
+ disable_feature_overrides = p_disable;
+}
+
+bool ProjectSettings::is_using_datapack() const {
+ return using_datapack;
+}
+
+bool ProjectSettings::property_can_revert(const String &p_name) {
+ if (!props.has(p_name)) {
+ return false;
+ }
+
+ return props[p_name].initial != props[p_name].variant;
+}
+
+Variant ProjectSettings::property_get_revert(const String &p_name) {
+ if (!props.has(p_name)) {
+ return Variant();
+ }
+
+ return props[p_name].initial;
+}
+
+void ProjectSettings::set_setting(const String &p_setting, const Variant &p_value) {
+ set(p_setting, p_value);
+}
+
+Variant ProjectSettings::get_setting(const String &p_setting) const {
+ return get(p_setting);
+}
+
+bool ProjectSettings::has_custom_feature(const String &p_feature) const {
+ return custom_features.has(p_feature);
+}
+
+Map<StringName, ProjectSettings::AutoloadInfo> ProjectSettings::get_autoload_list() const {
+ return autoloads;
+}
+
+void ProjectSettings::add_autoload(const AutoloadInfo &p_autoload) {
+ ERR_FAIL_COND_MSG(p_autoload.name == StringName(), "Trying to add autoload with no name.");
+ autoloads[p_autoload.name] = p_autoload;
+}
+
+void ProjectSettings::remove_autoload(const StringName &p_autoload) {
+ ERR_FAIL_COND_MSG(!autoloads.has(p_autoload), "Trying to remove non-existent autoload.");
+ autoloads.erase(p_autoload);
+}
+
+bool ProjectSettings::has_autoload(const StringName &p_autoload) const {
+ return autoloads.has(p_autoload);
+}
+
+ProjectSettings::AutoloadInfo ProjectSettings::get_autoload(const StringName &p_name) const {
+ ERR_FAIL_COND_V_MSG(!autoloads.has(p_name), AutoloadInfo(), "Trying to get non-existent autoload.");
+ return autoloads[p_name];
+}
+
+void ProjectSettings::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("has_setting", "name"), &ProjectSettings::has_setting);
+ ClassDB::bind_method(D_METHOD("set_setting", "name", "value"), &ProjectSettings::set_setting);
+ ClassDB::bind_method(D_METHOD("get_setting", "name"), &ProjectSettings::get_setting);
+ ClassDB::bind_method(D_METHOD("set_order", "name", "position"), &ProjectSettings::set_order);
+ ClassDB::bind_method(D_METHOD("get_order", "name"), &ProjectSettings::get_order);
+ ClassDB::bind_method(D_METHOD("set_initial_value", "name", "value"), &ProjectSettings::set_initial_value);
+ ClassDB::bind_method(D_METHOD("add_property_info", "hint"), &ProjectSettings::_add_property_info_bind);
+ ClassDB::bind_method(D_METHOD("clear", "name"), &ProjectSettings::clear);
+ ClassDB::bind_method(D_METHOD("localize_path", "path"), &ProjectSettings::localize_path);
+ ClassDB::bind_method(D_METHOD("globalize_path", "path"), &ProjectSettings::globalize_path);
+ ClassDB::bind_method(D_METHOD("save"), &ProjectSettings::save);
+ ClassDB::bind_method(D_METHOD("load_resource_pack", "pack", "replace_files", "offset"), &ProjectSettings::_load_resource_pack, DEFVAL(true), DEFVAL(0));
+ ClassDB::bind_method(D_METHOD("property_can_revert", "name"), &ProjectSettings::property_can_revert);
+ ClassDB::bind_method(D_METHOD("property_get_revert", "name"), &ProjectSettings::property_get_revert);
+
+ ClassDB::bind_method(D_METHOD("save_custom", "file"), &ProjectSettings::_save_custom_bnd);
+}
+
+ProjectSettings::ProjectSettings() {
+ // Initialization of engine variables should be done in the setup() method,
+ // so that the values can be overridden from project.godot or project.binary.
+
+ singleton = this;
+
+ Array events;
+ Dictionary action;
+ Ref<InputEventKey> key;
+ Ref<InputEventJoypadButton> joyb;
+
+ GLOBAL_DEF("application/config/name", "");
+ GLOBAL_DEF("application/config/description", "");
+ custom_prop_info["application/config/description"] = PropertyInfo(Variant::STRING, "application/config/description", PROPERTY_HINT_MULTILINE_TEXT);
+ GLOBAL_DEF("application/run/main_scene", "");
+ custom_prop_info["application/run/main_scene"] = PropertyInfo(Variant::STRING, "application/run/main_scene", PROPERTY_HINT_FILE, "*.tscn,*.scn,*.res");
+ GLOBAL_DEF("application/run/disable_stdout", false);
+ GLOBAL_DEF("application/run/disable_stderr", false);
+ GLOBAL_DEF("application/config/use_custom_user_dir", false);
+ GLOBAL_DEF("application/config/custom_user_dir_name", "");
+ GLOBAL_DEF("application/config/project_settings_override", "");
+ GLOBAL_DEF("audio/default_bus_layout", "res://default_bus_layout.tres");
+ custom_prop_info["audio/default_bus_layout"] = PropertyInfo(Variant::STRING, "audio/default_bus_layout", PROPERTY_HINT_FILE, "*.tres");
+
+ PackedStringArray extensions = PackedStringArray();
+ extensions.push_back("gd");
+ if (Engine::get_singleton()->has_singleton("GodotSharp")) {
+ extensions.push_back("cs");
+ }
+ extensions.push_back("shader");
+
+ GLOBAL_DEF("editor/search_in_file_extensions", extensions);
+ custom_prop_info["editor/search_in_file_extensions"] = PropertyInfo(Variant::PACKED_STRING_ARRAY, "editor/search_in_file_extensions");
+
+ GLOBAL_DEF("editor/script_templates_search_path", "res://script_templates");
+ custom_prop_info["editor/script_templates_search_path"] = PropertyInfo(Variant::STRING, "editor/script_templates_search_path", PROPERTY_HINT_DIR);
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_ENTER);
+ events.push_back(key);
+ key.instance();
+ key->set_keycode(KEY_KP_ENTER);
+ events.push_back(key);
+ key.instance();
+ key->set_keycode(KEY_SPACE);
+ events.push_back(key);
+ joyb.instance();
+ joyb->set_button_index(JOY_BUTTON_A);
+ events.push_back(joyb);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_accept", action);
+ input_presets.push_back("input/ui_accept");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_SPACE);
+ events.push_back(key);
+ joyb.instance();
+ joyb->set_button_index(JOY_BUTTON_Y);
+ events.push_back(joyb);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_select", action);
+ input_presets.push_back("input/ui_select");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_ESCAPE);
+ events.push_back(key);
+ joyb.instance();
+ joyb->set_button_index(JOY_BUTTON_B);
+ events.push_back(joyb);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_cancel", action);
+ input_presets.push_back("input/ui_cancel");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_TAB);
+ events.push_back(key);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_focus_next", action);
+ input_presets.push_back("input/ui_focus_next");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_TAB);
+ key->set_shift(true);
+ events.push_back(key);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_focus_prev", action);
+ input_presets.push_back("input/ui_focus_prev");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_LEFT);
+ events.push_back(key);
+ joyb.instance();
+ joyb->set_button_index(JOY_BUTTON_DPAD_LEFT);
+ events.push_back(joyb);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_left", action);
+ input_presets.push_back("input/ui_left");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_RIGHT);
+ events.push_back(key);
+ joyb.instance();
+ joyb->set_button_index(JOY_BUTTON_DPAD_RIGHT);
+ events.push_back(joyb);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_right", action);
+ input_presets.push_back("input/ui_right");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_UP);
+ events.push_back(key);
+ joyb.instance();
+ joyb->set_button_index(JOY_BUTTON_DPAD_UP);
+ events.push_back(joyb);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_up", action);
+ input_presets.push_back("input/ui_up");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_DOWN);
+ events.push_back(key);
+ joyb.instance();
+ joyb->set_button_index(JOY_BUTTON_DPAD_DOWN);
+ events.push_back(joyb);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_down", action);
+ input_presets.push_back("input/ui_down");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_PAGEUP);
+ events.push_back(key);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_page_up", action);
+ input_presets.push_back("input/ui_page_up");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_PAGEDOWN);
+ events.push_back(key);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_page_down", action);
+ input_presets.push_back("input/ui_page_down");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_HOME);
+ events.push_back(key);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_home", action);
+ input_presets.push_back("input/ui_home");
+
+ action = Dictionary();
+ action["deadzone"] = Variant(0.5f);
+ events = Array();
+ key.instance();
+ key->set_keycode(KEY_END);
+ events.push_back(key);
+ action["events"] = events;
+ GLOBAL_DEF("input/ui_end", action);
+ input_presets.push_back("input/ui_end");
+
+ custom_prop_info["display/window/handheld/orientation"] = PropertyInfo(Variant::STRING, "display/window/handheld/orientation", PROPERTY_HINT_ENUM, "landscape,portrait,reverse_landscape,reverse_portrait,sensor_landscape,sensor_portrait,sensor");
+ custom_prop_info["rendering/threads/thread_model"] = PropertyInfo(Variant::INT, "rendering/threads/thread_model", PROPERTY_HINT_ENUM, "Single-Unsafe,Single-Safe,Multi-Threaded");
+ custom_prop_info["physics/2d/thread_model"] = PropertyInfo(Variant::INT, "physics/2d/thread_model", PROPERTY_HINT_ENUM, "Single-Unsafe,Single-Safe,Multi-Threaded");
+ custom_prop_info["rendering/quality/intended_usage/framebuffer_allocation"] = PropertyInfo(Variant::INT, "rendering/quality/intended_usage/framebuffer_allocation", PROPERTY_HINT_ENUM, "2D,2D Without Sampling,3D,3D Without Effects");
+
+ GLOBAL_DEF("debug/settings/profiler/max_functions", 16384);
+ custom_prop_info["debug/settings/profiler/max_functions"] = PropertyInfo(Variant::INT, "debug/settings/profiler/max_functions", PROPERTY_HINT_RANGE, "128,65535,1");
+
+ GLOBAL_DEF("compression/formats/zstd/long_distance_matching", Compression::zstd_long_distance_matching);
+ custom_prop_info["compression/formats/zstd/long_distance_matching"] = PropertyInfo(Variant::BOOL, "compression/formats/zstd/long_distance_matching");
+ GLOBAL_DEF("compression/formats/zstd/compression_level", Compression::zstd_level);
+ custom_prop_info["compression/formats/zstd/compression_level"] = PropertyInfo(Variant::INT, "compression/formats/zstd/compression_level", PROPERTY_HINT_RANGE, "1,22,1");
+ GLOBAL_DEF("compression/formats/zstd/window_log_size", Compression::zstd_window_log_size);
+ custom_prop_info["compression/formats/zstd/window_log_size"] = PropertyInfo(Variant::INT, "compression/formats/zstd/window_log_size", PROPERTY_HINT_RANGE, "10,30,1");
+
+ GLOBAL_DEF("compression/formats/zlib/compression_level", Compression::zlib_level);
+ custom_prop_info["compression/formats/zlib/compression_level"] = PropertyInfo(Variant::INT, "compression/formats/zlib/compression_level", PROPERTY_HINT_RANGE, "-1,9,1");
+
+ GLOBAL_DEF("compression/formats/gzip/compression_level", Compression::gzip_level);
+ custom_prop_info["compression/formats/gzip/compression_level"] = PropertyInfo(Variant::INT, "compression/formats/gzip/compression_level", PROPERTY_HINT_RANGE, "-1,9,1");
+}
+
+ProjectSettings::~ProjectSettings() {
+ singleton = nullptr;
+}
diff --git a/core/config/project_settings.h b/core/config/project_settings.h
new file mode 100644
index 0000000000..a8c9adc587
--- /dev/null
+++ b/core/config/project_settings.h
@@ -0,0 +1,185 @@
+/*************************************************************************/
+/* project_settings.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef PROJECT_SETTINGS_H
+#define PROJECT_SETTINGS_H
+
+#include "core/object/class_db.h"
+#include "core/os/thread_safe.h"
+#include "core/templates/set.h"
+
+class ProjectSettings : public Object {
+ GDCLASS(ProjectSettings, Object);
+ _THREAD_SAFE_CLASS_
+
+public:
+ typedef Map<String, Variant> CustomMap;
+ static const String IMPORTED_FILES_PATH;
+
+ enum {
+ //properties that are not for built in values begin from this value, so builtin ones are displayed first
+ NO_BUILTIN_ORDER_BASE = 1 << 16
+ };
+
+ struct AutoloadInfo {
+ StringName name;
+ String path;
+ bool is_singleton = false;
+ };
+
+protected:
+ struct VariantContainer {
+ int order = 0;
+ bool persist = false;
+ Variant variant;
+ Variant initial;
+ bool hide_from_editor = false;
+ bool overridden = false;
+ bool restart_if_changed = false;
+#ifdef DEBUG_METHODS_ENABLED
+ bool ignore_value_in_docs = false;
+#endif
+
+ VariantContainer() {}
+
+ VariantContainer(const Variant &p_variant, int p_order, bool p_persist = false) :
+ order(p_order),
+ persist(p_persist),
+ variant(p_variant) {
+ }
+ };
+
+ bool registering_order = true;
+ int last_order = NO_BUILTIN_ORDER_BASE;
+ int last_builtin_order = 0;
+ Map<StringName, VariantContainer> props;
+ String resource_path;
+ Map<StringName, PropertyInfo> custom_prop_info;
+ bool disable_feature_overrides = false;
+ bool using_datapack = false;
+ List<String> input_presets;
+
+ Set<String> custom_features;
+ Map<StringName, StringName> feature_overrides;
+
+ Map<StringName, AutoloadInfo> autoloads;
+
+ bool _set(const StringName &p_name, const Variant &p_value);
+ bool _get(const StringName &p_name, Variant &r_ret) const;
+ void _get_property_list(List<PropertyInfo> *p_list) const;
+
+ static ProjectSettings *singleton;
+
+ Error _load_settings_text(const String &p_path);
+ Error _load_settings_binary(const String &p_path);
+ Error _load_settings_text_or_binary(const String &p_text_path, const String &p_bin_path);
+
+ Error _save_settings_text(const String &p_file, const Map<String, List<String>> &props, const CustomMap &p_custom = CustomMap(), const String &p_custom_features = String());
+ Error _save_settings_binary(const String &p_file, const Map<String, List<String>> &props, const CustomMap &p_custom = CustomMap(), const String &p_custom_features = String());
+
+ Error _save_custom_bnd(const String &p_file);
+
+ void _convert_to_last_version(int p_from_version);
+
+ bool _load_resource_pack(const String &p_pack, bool p_replace_files = true, int p_offset = 0);
+
+ void _add_property_info_bind(const Dictionary &p_info);
+
+ Error _setup(const String &p_path, const String &p_main_pack, bool p_upwards = false);
+
+protected:
+ static void _bind_methods();
+
+public:
+ static const int CONFIG_VERSION = 4;
+
+ void set_setting(const String &p_setting, const Variant &p_value);
+ Variant get_setting(const String &p_setting) const;
+
+ bool has_setting(String p_var) const;
+ String localize_path(const String &p_path) const;
+ String globalize_path(const String &p_path) const;
+
+ void set_initial_value(const String &p_name, const Variant &p_value);
+ void set_restart_if_changed(const String &p_name, bool p_restart);
+ void set_ignore_value_in_docs(const String &p_name, bool p_ignore);
+ bool get_ignore_value_in_docs(const String &p_name) const;
+
+ bool property_can_revert(const String &p_name);
+ Variant property_get_revert(const String &p_name);
+
+ String get_resource_path() const;
+
+ static ProjectSettings *get_singleton();
+
+ void clear(const String &p_name);
+ int get_order(const String &p_name) const;
+ void set_order(const String &p_name, int p_order);
+ void set_builtin_order(const String &p_name);
+ bool is_builtin_setting(const String &p_name) const;
+
+ Error setup(const String &p_path, const String &p_main_pack, bool p_upwards = false);
+
+ Error save_custom(const String &p_path = "", const CustomMap &p_custom = CustomMap(), const Vector<String> &p_custom_features = Vector<String>(), bool p_merge_with_current = true);
+ Error save();
+ void set_custom_property_info(const String &p_prop, const PropertyInfo &p_info);
+ const Map<StringName, PropertyInfo> &get_custom_property_info() const;
+
+ Vector<String> get_optimizer_presets() const;
+
+ List<String> get_input_presets() const { return input_presets; }
+
+ void set_disable_feature_overrides(bool p_disable);
+
+ bool is_using_datapack() const;
+
+ void set_registering_order(bool p_enable);
+
+ bool has_custom_feature(const String &p_feature) const;
+
+ Map<StringName, AutoloadInfo> get_autoload_list() const;
+ void add_autoload(const AutoloadInfo &p_autoload);
+ void remove_autoload(const StringName &p_autoload);
+ bool has_autoload(const StringName &p_autoload) const;
+ AutoloadInfo get_autoload(const StringName &p_name) const;
+
+ ProjectSettings();
+ ~ProjectSettings();
+};
+
+//not a macro any longer
+Variant _GLOBAL_DEF(const String &p_var, const Variant &p_default, bool p_restart_if_changed = false, bool p_ignore_value_in_docs = false);
+#define GLOBAL_DEF(m_var, m_value) _GLOBAL_DEF(m_var, m_value)
+#define GLOBAL_DEF_RST(m_var, m_value) _GLOBAL_DEF(m_var, m_value, true)
+#define GLOBAL_DEF_NOVAL(m_var, m_value) _GLOBAL_DEF(m_var, m_value, false, true)
+#define GLOBAL_DEF_RST_NOVAL(m_var, m_value) _GLOBAL_DEF(m_var, m_value, true, true)
+#define GLOBAL_GET(m_var) ProjectSettings::get_singleton()->get(m_var)
+
+#endif // PROJECT_SETTINGS_H