mirror of
https://github.com/godotengine/godot.git
synced 2024-12-27 11:24:59 +08:00
691854d589
Due to the low resolution of the occlusion buffer, small gaps between occluders can be closed and incorrectly occlude instances which should show through the gaps. To ameliorate this problem, this PR jitters the occlusion buffer over time, making it more likely an instance will be seen through a gap. This is used in conjunction with an occlusion timer per instance, to prevent instances flickering on and off rapidly.
1571 lines
59 KiB
C++
1571 lines
59 KiB
C++
/**************************************************************************/
|
||
/* project_settings.cpp */
|
||
/**************************************************************************/
|
||
/* This file is part of: */
|
||
/* GODOT ENGINE */
|
||
/* https://godotengine.org */
|
||
/**************************************************************************/
|
||
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
||
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
||
/* */
|
||
/* 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" // For Compression enum.
|
||
#include "core/core_string_names.h"
|
||
#include "core/input/input_map.h"
|
||
#include "core/io/config_file.h"
|
||
#include "core/io/dir_access.h"
|
||
#include "core/io/file_access.h"
|
||
#include "core/io/file_access_pack.h"
|
||
#include "core/io/marshalls.h"
|
||
#include "core/io/resource_uid.h"
|
||
#include "core/object/script_language.h"
|
||
#include "core/os/keyboard.h"
|
||
#include "core/templates/rb_set.h"
|
||
#include "core/variant/typed_array.h"
|
||
#include "core/variant/variant_parser.h"
|
||
#include "core/version.h"
|
||
|
||
#ifdef TOOLS_ENABLED
|
||
#include "modules/modules_enabled.gen.h" // For mono.
|
||
#endif // TOOLS_ENABLED
|
||
|
||
const String ProjectSettings::PROJECT_DATA_DIR_NAME_SUFFIX = "godot";
|
||
|
||
ProjectSettings *ProjectSettings::singleton = nullptr;
|
||
|
||
ProjectSettings *ProjectSettings::get_singleton() {
|
||
return singleton;
|
||
}
|
||
|
||
String ProjectSettings::get_project_data_dir_name() const {
|
||
return project_data_dir_name;
|
||
}
|
||
|
||
String ProjectSettings::get_project_data_path() const {
|
||
return "res://" + get_project_data_dir_name();
|
||
}
|
||
|
||
String ProjectSettings::get_resource_path() const {
|
||
return resource_path;
|
||
}
|
||
|
||
String ProjectSettings::get_imported_files_path() const {
|
||
return get_project_data_path().path_join("imported");
|
||
}
|
||
|
||
#ifdef TOOLS_ENABLED
|
||
// Returns the features that a project must have when opened with this build of Godot.
|
||
// This is used by the project manager to provide the initial_settings for config/features.
|
||
const PackedStringArray ProjectSettings::get_required_features() {
|
||
PackedStringArray features;
|
||
features.append(VERSION_BRANCH);
|
||
#ifdef REAL_T_IS_DOUBLE
|
||
features.append("Double Precision");
|
||
#endif
|
||
return features;
|
||
}
|
||
|
||
// Returns the features supported by this build of Godot. Includes all required features.
|
||
const PackedStringArray ProjectSettings::_get_supported_features() {
|
||
PackedStringArray features = get_required_features();
|
||
#ifdef MODULE_MONO_ENABLED
|
||
features.append("C#");
|
||
#endif
|
||
// Allow pinning to a specific patch number or build type by marking
|
||
// them as supported. They're only used if the user adds them manually.
|
||
features.append(VERSION_BRANCH "." _MKSTR(VERSION_PATCH));
|
||
features.append(VERSION_FULL_CONFIG);
|
||
features.append(VERSION_FULL_BUILD);
|
||
|
||
#ifdef RD_ENABLED
|
||
features.append("Forward Plus");
|
||
features.append("Mobile");
|
||
#endif
|
||
|
||
#ifdef GLES3_ENABLED
|
||
features.append("GL Compatibility");
|
||
#endif
|
||
return features;
|
||
}
|
||
|
||
// Returns the features that this project needs but this build of Godot lacks.
|
||
const PackedStringArray ProjectSettings::get_unsupported_features(const PackedStringArray &p_project_features) {
|
||
PackedStringArray unsupported_features;
|
||
PackedStringArray supported_features = singleton->_get_supported_features();
|
||
for (int i = 0; i < p_project_features.size(); i++) {
|
||
if (!supported_features.has(p_project_features[i])) {
|
||
// Temporary compatibility code to ease upgrade to 4.0 beta 2+.
|
||
if (p_project_features[i].begins_with("Vulkan")) {
|
||
continue;
|
||
}
|
||
unsupported_features.append(p_project_features[i]);
|
||
}
|
||
}
|
||
unsupported_features.sort();
|
||
return unsupported_features;
|
||
}
|
||
|
||
// Returns the features that both this project has and this build of Godot has, ensuring required features exist.
|
||
const PackedStringArray ProjectSettings::_trim_to_supported_features(const PackedStringArray &p_project_features) {
|
||
// Remove unsupported features if present.
|
||
PackedStringArray features = PackedStringArray(p_project_features);
|
||
PackedStringArray supported_features = _get_supported_features();
|
||
for (int i = p_project_features.size() - 1; i > -1; i--) {
|
||
if (!supported_features.has(p_project_features[i])) {
|
||
features.remove_at(i);
|
||
}
|
||
}
|
||
// Add required features if not present.
|
||
PackedStringArray required_features = get_required_features();
|
||
for (int i = 0; i < required_features.size(); i++) {
|
||
if (!features.has(required_features[i])) {
|
||
features.append(required_features[i]);
|
||
}
|
||
}
|
||
features.sort();
|
||
return features;
|
||
}
|
||
#endif // TOOLS_ENABLED
|
||
|
||
String ProjectSettings::localize_path(const String &p_path) const {
|
||
String path = p_path.simplify_path();
|
||
|
||
if (resource_path.is_empty() || (path.is_absolute_path() && !path.begins_with(resource_path))) {
|
||
return path;
|
||
}
|
||
|
||
// Check if we have a special path (like res://) or a protocol identifier.
|
||
int p = path.find("://");
|
||
bool found = false;
|
||
if (p > 0) {
|
||
found = true;
|
||
for (int i = 0; i < p; i++) {
|
||
if (!is_ascii_alphanumeric_char(path[i])) {
|
||
found = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (found) {
|
||
return path;
|
||
}
|
||
|
||
Ref<DirAccess> dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
||
|
||
if (dir->change_dir(path) == OK) {
|
||
String cwd = dir->get_current_dir();
|
||
cwd = cwd.replace("\\", "/");
|
||
|
||
// 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://.
|
||
// `path_join("")` is an easy way to ensure we have a trailing '/'.
|
||
const String res_path = resource_path.path_join("");
|
||
|
||
// 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.path_join("");
|
||
|
||
if (!cwd.begins_with(res_path)) {
|
||
return path;
|
||
}
|
||
|
||
return cwd.replace_first(res_path, "res://");
|
||
} else {
|
||
int sep = path.rfind("/");
|
||
if (sep == -1) {
|
||
return "res://" + path;
|
||
}
|
||
|
||
String parent = path.substr(0, sep);
|
||
|
||
String plocal = localize_path(parent);
|
||
if (plocal.is_empty()) {
|
||
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 + ".");
|
||
|
||
// Duplicate so that if value is array or dictionary, changing the setting will not change the stored initial value.
|
||
props[p_name].initial = p_value.duplicate();
|
||
}
|
||
|
||
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_as_basic(const String &p_name, bool p_basic) {
|
||
ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
|
||
props[p_name].basic = p_basic;
|
||
}
|
||
|
||
void ProjectSettings::set_as_internal(const String &p_name, bool p_internal) {
|
||
ERR_FAIL_COND_MSG(!props.has(p_name), "Request for nonexistent project setting: " + p_name + ".");
|
||
props[p_name].internal = p_internal;
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
void ProjectSettings::add_hidden_prefix(const String &p_prefix) {
|
||
ERR_FAIL_COND_MSG(hidden_prefixes.find(p_prefix) > -1, vformat("Hidden prefix '%s' already exists.", p_prefix));
|
||
hidden_prefixes.push_back(p_prefix);
|
||
}
|
||
|
||
String ProjectSettings::globalize_path(const String &p_path) const {
|
||
if (p_path.begins_with("res://")) {
|
||
if (!resource_path.is_empty()) {
|
||
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.is_empty()) {
|
||
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.operator String().begins_with("global_group/")) {
|
||
String group_name = p_name.operator String().get_slice("/", 1);
|
||
if (global_groups.has(group_name)) {
|
||
remove_global_group(group_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]);
|
||
}
|
||
_queue_changed();
|
||
return true;
|
||
}
|
||
|
||
{ // Feature overrides.
|
||
int dot = p_name.operator String().find(".");
|
||
if (dot != -1) {
|
||
Vector<String> s = p_name.operator String().split(".");
|
||
|
||
for (int i = 1; i < s.size(); i++) {
|
||
String feature = s[i].strip_edges();
|
||
Pair<StringName, StringName> feature_override(feature, p_name);
|
||
|
||
if (!feature_overrides.has(s[0])) {
|
||
feature_overrides[s[0]] = LocalVector<Pair<StringName, StringName>>();
|
||
}
|
||
|
||
feature_overrides[s[0]].push_back(feature_override);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (props.has(p_name)) {
|
||
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);
|
||
} else if (p_name.operator String().begins_with("global_group/")) {
|
||
String group_name = p_name.operator String().get_slice("/", 1);
|
||
add_global_group(group_name, p_value);
|
||
}
|
||
}
|
||
|
||
_queue_changed();
|
||
return true;
|
||
}
|
||
|
||
bool ProjectSettings::_get(const StringName &p_name, Variant &r_ret) const {
|
||
_THREAD_SAFE_METHOD_
|
||
|
||
if (!props.has(p_name)) {
|
||
WARN_PRINT("Property not found: " + String(p_name));
|
||
return false;
|
||
}
|
||
r_ret = props[p_name].variant;
|
||
return true;
|
||
}
|
||
|
||
Variant ProjectSettings::get_setting_with_override(const StringName &p_name) const {
|
||
_THREAD_SAFE_METHOD_
|
||
|
||
StringName name = p_name;
|
||
if (feature_overrides.has(name)) {
|
||
const LocalVector<Pair<StringName, StringName>> &overrides = feature_overrides[name];
|
||
for (uint32_t i = 0; i < overrides.size(); i++) {
|
||
if (OS::get_singleton()->has_feature(overrides[i].first)) { // Custom features are checked in OS.has_feature() already. No need to check twice.
|
||
if (props.has(overrides[i].second)) {
|
||
name = overrides[i].second;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!props.has(name)) {
|
||
WARN_PRINT("Property not found: " + String(name));
|
||
return Variant();
|
||
}
|
||
return props[name].variant;
|
||
}
|
||
|
||
struct _VCSort {
|
||
String name;
|
||
Variant::Type type = Variant::VARIANT_MAX;
|
||
int order = 0;
|
||
uint32_t flags = 0;
|
||
|
||
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_
|
||
|
||
RBSet<_VCSort> vclist;
|
||
|
||
for (const KeyValue<StringName, VariantContainer> &E : props) {
|
||
const VariantContainer *v = &E.value;
|
||
|
||
if (v->hide_from_editor) {
|
||
continue;
|
||
}
|
||
|
||
_VCSort vc;
|
||
vc.name = E.key;
|
||
vc.order = v->order;
|
||
vc.type = v->variant.get_type();
|
||
|
||
bool internal = v->internal;
|
||
if (!internal) {
|
||
for (const String &F : hidden_prefixes) {
|
||
if (vc.name.begins_with(F)) {
|
||
internal = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (internal) {
|
||
vc.flags = PROPERTY_USAGE_STORAGE;
|
||
} else {
|
||
vc.flags = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE;
|
||
}
|
||
|
||
if (v->internal) {
|
||
vc.flags |= PROPERTY_USAGE_INTERNAL;
|
||
}
|
||
|
||
if (v->basic) {
|
||
vc.flags |= PROPERTY_USAGE_EDITOR_BASIC_SETTING;
|
||
}
|
||
|
||
if (v->restart_if_changed) {
|
||
vc.flags |= PROPERTY_USAGE_RESTART_IF_CHANGED;
|
||
}
|
||
vclist.insert(vc);
|
||
}
|
||
|
||
for (const _VCSort &E : vclist) {
|
||
String prop_info_name = E.name;
|
||
int dot = prop_info_name.find(".");
|
||
if (dot != -1 && !custom_prop_info.has(prop_info_name)) {
|
||
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.name;
|
||
pi.usage = E.flags;
|
||
p_list->push_back(pi);
|
||
} else {
|
||
p_list->push_back(PropertyInfo(E.type, E.name, PROPERTY_HINT_NONE, "", E.flags));
|
||
}
|
||
}
|
||
}
|
||
|
||
void ProjectSettings::_queue_changed() {
|
||
if (is_changed || !MessageQueue::get_singleton() || MessageQueue::get_singleton()->get_max_buffer_usage() == 0) {
|
||
return;
|
||
}
|
||
is_changed = true;
|
||
callable_mp(this, &ProjectSettings::_emit_changed).call_deferred();
|
||
}
|
||
|
||
void ProjectSettings::_emit_changed() {
|
||
if (!is_changed) {
|
||
return;
|
||
}
|
||
is_changed = false;
|
||
emit_signal("settings_changed");
|
||
}
|
||
|
||
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 (project_loaded) {
|
||
// This pack may have declared new global classes (make sure they are picked up).
|
||
refresh_global_class_list();
|
||
|
||
// This pack may have defined new UIDs, make sure they are cached.
|
||
ResourceUID::get_singleton()->load_from_cache(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 (KeyValue<StringName, ProjectSettings::VariantContainer> &E : props) {
|
||
Variant value = E.value.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.value.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, bool p_ignore_override) {
|
||
if (!OS::get_singleton()->get_resource_dir().is_empty()) {
|
||
// 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.is_empty() && resource_path[resource_path.length() - 1] == '/') {
|
||
resource_path = resource_path.substr(0, resource_path.length() - 1); // Chop end.
|
||
}
|
||
}
|
||
|
||
// Attempt with a user-defined main pack first
|
||
|
||
if (!p_main_pack.is_empty()) {
|
||
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 && !p_ignore_override) {
|
||
// 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().path_join("override.cfg"));
|
||
}
|
||
return err;
|
||
}
|
||
|
||
String exec_path = OS::get_singleton()->get_executable_path();
|
||
|
||
if (!exec_path.is_empty()) {
|
||
// 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 MACOS_ENABLED
|
||
if (!found) {
|
||
// Attempt to load PCK from macOS .app bundle resources.
|
||
found = _load_resource_pack(OS::get_singleton()->get_bundle_resource_dir().path_join(exec_basename + ".pck")) || _load_resource_pack(OS::get_singleton()->get_bundle_resource_dir().path_join(exec_filename + ".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.path_join(exec_basename + ".pck")) || _load_resource_pack(exec_dir.path_join(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 && !p_ignore_override) {
|
||
// Load overrides from the PCK and the executable location.
|
||
// Optional, we don't mind if either fails.
|
||
_load_settings_text("res://override.cfg");
|
||
_load_settings_text(exec_path.get_base_dir().path_join("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().is_empty()) {
|
||
Error err = _load_settings_text_or_binary("res://project.godot", "res://project.binary");
|
||
if (err == OK && !p_ignore_override) {
|
||
// 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.
|
||
|
||
Ref<DirAccess> d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
||
ERR_FAIL_COND_V_MSG(d.is_null(), ERR_CANT_CREATE, "Cannot create DirAccess for path '" + p_path + "'.");
|
||
d->change_dir(p_path);
|
||
|
||
String current_dir = d->get_current_dir();
|
||
bool found = false;
|
||
Error err;
|
||
|
||
while (true) {
|
||
// Set the resource path early so things can be resolved when loading.
|
||
resource_path = current_dir;
|
||
resource_path = resource_path.replace("\\", "/"); // Windows path to Unix path just in case.
|
||
err = _load_settings_text_or_binary(current_dir.path_join("project.godot"), current_dir.path_join("project.binary"));
|
||
if (err == OK && !p_ignore_override) {
|
||
// Optional, we don't mind if it fails.
|
||
_load_settings_text(current_dir.path_join("override.cfg"));
|
||
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;
|
||
}
|
||
}
|
||
|
||
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, bool p_ignore_override) {
|
||
Error err = _setup(p_path, p_main_pack, p_upwards, p_ignore_override);
|
||
if (err == OK && !p_ignore_override) {
|
||
String custom_settings = GLOBAL_GET("application/config/project_settings_override");
|
||
if (!custom_settings.is_empty()) {
|
||
_load_settings_text(custom_settings);
|
||
}
|
||
}
|
||
|
||
// Updating the default value after the project settings have loaded.
|
||
bool use_hidden_directory = GLOBAL_GET("application/config/use_hidden_project_data_directory");
|
||
project_data_dir_name = (use_hidden_directory ? "." : "") + PROJECT_DATA_DIR_NAME_SUFFIX;
|
||
|
||
// 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");
|
||
|
||
load_scene_groups_cache();
|
||
|
||
project_loaded = err == OK;
|
||
return err;
|
||
}
|
||
|
||
bool ProjectSettings::has_setting(const String &p_var) const {
|
||
_THREAD_SAFE_METHOD_
|
||
|
||
return props.has(p_var);
|
||
}
|
||
|
||
Error ProjectSettings::_load_settings_binary(const String &p_path) {
|
||
Error err;
|
||
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ, &err);
|
||
if (err != OK) {
|
||
return err;
|
||
}
|
||
|
||
uint8_t hdr[4];
|
||
f->get_buffer(hdr, 4);
|
||
ERR_FAIL_COND_V_MSG((hdr[0] != 'E' || hdr[1] != 'C' || hdr[2] != 'F' || hdr[3] != 'G'), 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);
|
||
}
|
||
|
||
return OK;
|
||
}
|
||
|
||
Error ProjectSettings::_load_settings_text(const String &p_path) {
|
||
Error err;
|
||
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ, &err);
|
||
|
||
if (f.is_null()) {
|
||
// 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) {
|
||
// 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);
|
||
last_save_time = FileAccess::get_modified_time(get_resource_path().path_join("project.godot"));
|
||
return OK;
|
||
}
|
||
ERR_FAIL_COND_V_MSG(err != OK, err, "Error parsing " + p_path + " at line " + itos(lines) + ": " + error_text + " File might be corrupted.");
|
||
|
||
if (!assign.is_empty()) {
|
||
if (section.is_empty() && assign == "config_version") {
|
||
config_version = value;
|
||
ERR_FAIL_COND_V_MSG(config_version > CONFIG_VERSION, 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.is_empty()) {
|
||
set(assign, value);
|
||
} else {
|
||
set(section + "/" + assign, value);
|
||
}
|
||
}
|
||
} else if (!next_tag.name.is_empty()) {
|
||
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) + ".");
|
||
}
|
||
|
||
// 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;
|
||
}
|
||
|
||
Error ProjectSettings::load_custom(const String &p_path) {
|
||
if (p_path.ends_with(".binary")) {
|
||
return _load_settings_binary(p_path);
|
||
}
|
||
return _load_settings_text(p_path);
|
||
}
|
||
|
||
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() {
|
||
Error error = save_custom(get_resource_path().path_join("project.godot"));
|
||
if (error == OK) {
|
||
last_save_time = FileAccess::get_modified_time(get_resource_path().path_join("project.godot"));
|
||
}
|
||
return error;
|
||
}
|
||
|
||
Error ProjectSettings::_save_settings_binary(const String &p_file, const RBMap<String, List<String>> &p_props, const CustomMap &p_custom, const String &p_custom_features) {
|
||
Error err;
|
||
Ref<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 (const KeyValue<String, List<String>> &E : p_props) {
|
||
count += E.value.size();
|
||
}
|
||
|
||
if (!p_custom_features.is_empty()) {
|
||
// Store how many properties are saved, add one for custom features, which must always go first.
|
||
file->store_32(count + 1);
|
||
String key = CoreStringNames::get_singleton()->_custom_features;
|
||
file->store_pascal_string(key);
|
||
|
||
int len;
|
||
err = encode_variant(p_custom_features, nullptr, len, false);
|
||
ERR_FAIL_COND_V(err != OK, err);
|
||
|
||
Vector<uint8_t> buff;
|
||
buff.resize(len);
|
||
|
||
err = encode_variant(p_custom_features, buff.ptrw(), len, false);
|
||
ERR_FAIL_COND_V(err != OK, err);
|
||
file->store_32(len);
|
||
file->store_buffer(buff.ptr(), buff.size());
|
||
|
||
} else {
|
||
// Store how many properties are saved.
|
||
file->store_32(count);
|
||
}
|
||
|
||
for (const KeyValue<String, List<String>> &E : p_props) {
|
||
for (const String &key : E.value) {
|
||
String k = key;
|
||
if (!E.key.is_empty()) {
|
||
k = E.key + "/" + k;
|
||
}
|
||
Variant value;
|
||
if (p_custom.has(k)) {
|
||
value = p_custom[k];
|
||
} else {
|
||
value = get(k);
|
||
}
|
||
|
||
file->store_pascal_string(k);
|
||
|
||
int len;
|
||
err = encode_variant(value, nullptr, len, true);
|
||
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);
|
||
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());
|
||
}
|
||
}
|
||
|
||
return OK;
|
||
}
|
||
|
||
Error ProjectSettings::_save_settings_text(const String &p_file, const RBMap<String, List<String>> &p_props, const CustomMap &p_custom, const String &p_custom_features) {
|
||
Error err;
|
||
Ref<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.is_empty()) {
|
||
file->store_string("custom_features=\"" + p_custom_features + "\"\n");
|
||
}
|
||
file->store_string("\n");
|
||
|
||
for (const KeyValue<String, List<String>> &E : p_props) {
|
||
if (E.key != p_props.begin()->key) {
|
||
file->store_string("\n");
|
||
}
|
||
|
||
if (!E.key.is_empty()) {
|
||
file->store_string("[" + E.key + "]\n\n");
|
||
}
|
||
for (const String &F : E.value) {
|
||
String key = F;
|
||
if (!E.key.is_empty()) {
|
||
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.property_name_encode() + "=" + vstr + "\n");
|
||
}
|
||
}
|
||
|
||
return OK;
|
||
}
|
||
|
||
Error ProjectSettings::_save_custom_bnd(const String &p_file) { // add other params as dictionary and array?
|
||
return save_custom(p_file);
|
||
}
|
||
|
||
#ifdef TOOLS_ENABLED
|
||
bool _csproj_exists(const String &p_root_dir) {
|
||
Ref<DirAccess> dir = DirAccess::open(p_root_dir);
|
||
ERR_FAIL_COND_V(dir.is_null(), false);
|
||
|
||
dir->list_dir_begin();
|
||
String file_name = dir->_get_next();
|
||
while (file_name != "") {
|
||
if (!dir->current_is_dir() && file_name.get_extension() == "csproj") {
|
||
return true;
|
||
}
|
||
file_name = dir->_get_next();
|
||
}
|
||
|
||
return false;
|
||
}
|
||
#endif // TOOLS_ENABLED
|
||
|
||
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.is_empty(), ERR_INVALID_PARAMETER, "Project settings save path cannot be empty.");
|
||
|
||
#ifdef TOOLS_ENABLED
|
||
PackedStringArray project_features = get_setting("application/config/features");
|
||
// If there is no feature list currently present, force one to generate.
|
||
if (project_features.is_empty()) {
|
||
project_features = ProjectSettings::get_required_features();
|
||
}
|
||
// Check the rendering API.
|
||
const String rendering_api = has_setting("rendering/renderer/rendering_method") ? (String)get_setting("rendering/renderer/rendering_method") : String();
|
||
if (!rendering_api.is_empty()) {
|
||
// Add the rendering API as a project feature if it doesn't already exist.
|
||
if (!project_features.has(rendering_api)) {
|
||
project_features.append(rendering_api);
|
||
}
|
||
}
|
||
// Check for the existence of a csproj file.
|
||
if (_csproj_exists(get_resource_path())) {
|
||
// If there is a csproj file, add the C# feature if it doesn't already exist.
|
||
if (!project_features.has("C#")) {
|
||
project_features.append("C#");
|
||
}
|
||
} else {
|
||
// If there isn't a csproj file, remove the C# feature if it exists.
|
||
if (project_features.has("C#")) {
|
||
project_features.remove_at(project_features.find("C#"));
|
||
}
|
||
}
|
||
project_features = _trim_to_supported_features(project_features);
|
||
set_setting("application/config/features", project_features);
|
||
#endif // TOOLS_ENABLED
|
||
|
||
RBSet<_VCSort> vclist;
|
||
|
||
if (p_merge_with_current) {
|
||
for (const KeyValue<StringName, VariantContainer> &G : props) {
|
||
const VariantContainer *v = &G.value;
|
||
|
||
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 KeyValue<String, Variant> &E : p_custom) {
|
||
// Lookup global prop to store in the same order
|
||
RBMap<StringName, VariantContainer>::Iterator global_prop = props.find(E.key);
|
||
|
||
_VCSort vc;
|
||
vc.name = E.key;
|
||
vc.order = global_prop ? global_prop->value.order : 0xFFFFFFF;
|
||
vc.type = E.value.get_type();
|
||
vc.flags = PROPERTY_USAGE_STORAGE;
|
||
vclist.insert(vc);
|
||
}
|
||
|
||
RBMap<String, List<String>> save_props;
|
||
|
||
for (const _VCSort &E : vclist) {
|
||
String category = E.name;
|
||
String name = E.name;
|
||
|
||
int div = category.find("/");
|
||
|
||
if (div < 0) {
|
||
category = "";
|
||
} else {
|
||
category = category.substr(0, div);
|
||
name = name.substr(div + 1, name.size());
|
||
}
|
||
save_props[category].push_back(name);
|
||
}
|
||
|
||
String save_features;
|
||
|
||
for (int i = 0; i < p_custom_features.size(); i++) {
|
||
if (i > 0) {
|
||
save_features += ",";
|
||
}
|
||
|
||
String f = p_custom_features[i].strip_edges().replace("\"", "");
|
||
save_features += f;
|
||
}
|
||
|
||
if (p_path.ends_with(".godot") || p_path.ends_with("override.cfg")) {
|
||
return _save_settings_text(p_path, save_props, p_custom, save_features);
|
||
} else if (p_path.ends_with(".binary")) {
|
||
return _save_settings_binary(p_path, save_props, p_custom, save_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, bool p_basic, bool p_internal) {
|
||
Variant ret;
|
||
if (!ProjectSettings::get_singleton()->has_setting(p_var)) {
|
||
ProjectSettings::get_singleton()->set(p_var, p_default);
|
||
}
|
||
ret = GLOBAL_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_as_basic(p_var, p_basic);
|
||
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);
|
||
ProjectSettings::get_singleton()->set_as_internal(p_var, p_internal);
|
||
return ret;
|
||
}
|
||
|
||
Variant _GLOBAL_DEF(const PropertyInfo &p_info, const Variant &p_default, bool p_restart_if_changed, bool p_ignore_value_in_docs, bool p_basic, bool p_internal) {
|
||
Variant ret = _GLOBAL_DEF(p_info.name, p_default, p_restart_if_changed, p_ignore_value_in_docs, p_basic, p_internal);
|
||
ProjectSettings::get_singleton()->set_custom_property_info(p_info);
|
||
return ret;
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
void ProjectSettings::set_custom_property_info(const PropertyInfo &p_info) {
|
||
const String &prop_name = p_info.name;
|
||
ERR_FAIL_COND(!props.has(prop_name));
|
||
custom_prop_info[prop_name] = p_info;
|
||
}
|
||
|
||
const HashMap<StringName, PropertyInfo> &ProjectSettings::get_custom_property_info() const {
|
||
return custom_prop_info;
|
||
}
|
||
|
||
bool ProjectSettings::is_using_datapack() const {
|
||
return using_datapack;
|
||
}
|
||
|
||
bool ProjectSettings::is_project_loaded() const {
|
||
return project_loaded;
|
||
}
|
||
|
||
bool ProjectSettings::_property_can_revert(const StringName &p_name) const {
|
||
if (!props.has(p_name)) {
|
||
return false;
|
||
}
|
||
|
||
return props[p_name].initial != props[p_name].variant;
|
||
}
|
||
|
||
bool ProjectSettings::_property_get_revert(const StringName &p_name, Variant &r_property) const {
|
||
if (!props.has(p_name)) {
|
||
return false;
|
||
}
|
||
|
||
// Duplicate so that if value is array or dictionary, changing the setting will not change the stored initial value.
|
||
r_property = props[p_name].initial.duplicate();
|
||
|
||
return true;
|
||
}
|
||
|
||
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 Variant &p_default_value) const {
|
||
if (has_setting(p_setting)) {
|
||
return get(p_setting);
|
||
} else {
|
||
return p_default_value;
|
||
}
|
||
}
|
||
|
||
void ProjectSettings::refresh_global_class_list() {
|
||
// This is called after mounting a new PCK file to pick up class changes.
|
||
is_global_class_list_loaded = false; // Make sure we read from the freshly mounted PCK.
|
||
Array script_classes = get_global_class_list();
|
||
for (int i = 0; i < script_classes.size(); i++) {
|
||
Dictionary c = script_classes[i];
|
||
if (!c.has("class") || !c.has("language") || !c.has("path") || !c.has("base")) {
|
||
continue;
|
||
}
|
||
ScriptServer::add_global_class(c["class"], c["base"], c["language"], c["path"]);
|
||
}
|
||
}
|
||
|
||
TypedArray<Dictionary> ProjectSettings::get_global_class_list() {
|
||
if (is_global_class_list_loaded) {
|
||
return global_class_list;
|
||
}
|
||
|
||
Ref<ConfigFile> cf;
|
||
cf.instantiate();
|
||
if (cf->load(get_global_class_list_path()) == OK) {
|
||
global_class_list = cf->get_value("", "list", Array());
|
||
} else {
|
||
#ifndef TOOLS_ENABLED
|
||
// Script classes can't be recreated in exported project, so print an error.
|
||
ERR_PRINT("Could not load global script cache.");
|
||
#endif
|
||
}
|
||
|
||
// File read succeeded or failed. If it failed, assume everything is still okay.
|
||
// We will later receive updated class data in store_global_class_list().
|
||
is_global_class_list_loaded = true;
|
||
|
||
return global_class_list;
|
||
}
|
||
|
||
String ProjectSettings::get_global_class_list_path() const {
|
||
return get_project_data_path().path_join("global_script_class_cache.cfg");
|
||
}
|
||
|
||
void ProjectSettings::store_global_class_list(const Array &p_classes) {
|
||
Ref<ConfigFile> cf;
|
||
cf.instantiate();
|
||
cf->set_value("", "list", p_classes);
|
||
cf->save(get_global_class_list_path());
|
||
|
||
global_class_list = p_classes;
|
||
}
|
||
|
||
bool ProjectSettings::has_custom_feature(const String &p_feature) const {
|
||
return custom_features.has(p_feature);
|
||
}
|
||
|
||
const HashMap<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];
|
||
}
|
||
|
||
const HashMap<StringName, String> &ProjectSettings::get_global_groups_list() const {
|
||
return global_groups;
|
||
}
|
||
|
||
void ProjectSettings::add_global_group(const StringName &p_name, const String &p_description) {
|
||
ERR_FAIL_COND_MSG(p_name == StringName(), "Trying to add global group with no name.");
|
||
global_groups[p_name] = p_description;
|
||
}
|
||
|
||
void ProjectSettings::remove_global_group(const StringName &p_name) {
|
||
ERR_FAIL_COND_MSG(!global_groups.has(p_name), "Trying to remove non-existent global group.");
|
||
global_groups.erase(p_name);
|
||
}
|
||
|
||
bool ProjectSettings::has_global_group(const StringName &p_name) const {
|
||
return global_groups.has(p_name);
|
||
}
|
||
|
||
void ProjectSettings::remove_scene_groups_cache(const StringName &p_path) {
|
||
scene_groups_cache.erase(p_path);
|
||
}
|
||
|
||
void ProjectSettings::add_scene_groups_cache(const StringName &p_path, const HashSet<StringName> &p_cache) {
|
||
scene_groups_cache[p_path] = p_cache;
|
||
}
|
||
|
||
void ProjectSettings::save_scene_groups_cache() {
|
||
Ref<ConfigFile> cf;
|
||
cf.instantiate();
|
||
for (const KeyValue<StringName, HashSet<StringName>> &E : scene_groups_cache) {
|
||
if (E.value.is_empty()) {
|
||
continue;
|
||
}
|
||
Array list;
|
||
for (const StringName &group : E.value) {
|
||
list.push_back(group);
|
||
}
|
||
cf->set_value(E.key, "groups", list);
|
||
}
|
||
cf->save(get_scene_groups_cache_path());
|
||
}
|
||
|
||
String ProjectSettings::get_scene_groups_cache_path() const {
|
||
return get_project_data_path().path_join("scene_groups_cache.cfg");
|
||
}
|
||
|
||
void ProjectSettings::load_scene_groups_cache() {
|
||
Ref<ConfigFile> cf;
|
||
cf.instantiate();
|
||
if (cf->load(get_scene_groups_cache_path()) == OK) {
|
||
List<String> scene_paths;
|
||
cf->get_sections(&scene_paths);
|
||
for (const String &E : scene_paths) {
|
||
Array scene_groups = cf->get_value(E, "groups", Array());
|
||
HashSet<StringName> cache;
|
||
for (int i = 0; i < scene_groups.size(); ++i) {
|
||
cache.insert(scene_groups[i]);
|
||
}
|
||
add_scene_groups_cache(E, cache);
|
||
}
|
||
}
|
||
}
|
||
|
||
const HashMap<StringName, HashSet<StringName>> &ProjectSettings::get_scene_groups_cache() const {
|
||
return scene_groups_cache;
|
||
}
|
||
|
||
#ifdef TOOLS_ENABLED
|
||
void ProjectSettings::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {
|
||
const String pf = p_function;
|
||
if (p_idx == 0) {
|
||
if (pf == "has_setting" || pf == "set_setting" || pf == "get_setting" || pf == "get_setting_with_override" ||
|
||
pf == "set_order" || pf == "get_order" || pf == "set_initial_value" || pf == "set_as_basic" ||
|
||
pf == "set_as_internal" || pf == "set_restart_if_changed" || pf == "clear") {
|
||
for (const KeyValue<StringName, VariantContainer> &E : props) {
|
||
if (E.value.hide_from_editor) {
|
||
continue;
|
||
}
|
||
|
||
r_options->push_back(String(E.key).quote());
|
||
}
|
||
}
|
||
}
|
||
Object::get_argument_options(p_function, p_idx, r_options);
|
||
}
|
||
#endif
|
||
|
||
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", "default_value"), &ProjectSettings::get_setting, DEFVAL(Variant()));
|
||
ClassDB::bind_method(D_METHOD("get_setting_with_override", "name"), &ProjectSettings::get_setting_with_override);
|
||
ClassDB::bind_method(D_METHOD("get_global_class_list"), &ProjectSettings::get_global_class_list);
|
||
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("set_as_basic", "name", "basic"), &ProjectSettings::set_as_basic);
|
||
ClassDB::bind_method(D_METHOD("set_as_internal", "name", "internal"), &ProjectSettings::set_as_internal);
|
||
ClassDB::bind_method(D_METHOD("add_property_info", "hint"), &ProjectSettings::_add_property_info_bind);
|
||
ClassDB::bind_method(D_METHOD("set_restart_if_changed", "name", "restart"), &ProjectSettings::set_restart_if_changed);
|
||
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("save_custom", "file"), &ProjectSettings::_save_custom_bnd);
|
||
|
||
ADD_SIGNAL(MethodInfo("settings_changed"));
|
||
}
|
||
|
||
void ProjectSettings::_add_builtin_input_map() {
|
||
if (InputMap::get_singleton()) {
|
||
HashMap<String, List<Ref<InputEvent>>> builtins = InputMap::get_singleton()->get_builtins();
|
||
|
||
for (KeyValue<String, List<Ref<InputEvent>>> &E : builtins) {
|
||
Array events;
|
||
|
||
// Convert list of input events into array
|
||
for (List<Ref<InputEvent>>::Element *I = E.value.front(); I; I = I->next()) {
|
||
events.push_back(I->get());
|
||
}
|
||
|
||
Dictionary action;
|
||
action["deadzone"] = Variant(0.5f);
|
||
action["events"] = events;
|
||
|
||
String action_name = "input/" + E.key;
|
||
GLOBAL_DEF(action_name, action);
|
||
input_presets.push_back(action_name);
|
||
}
|
||
}
|
||
}
|
||
|
||
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.
|
||
|
||
CRASH_COND_MSG(singleton != nullptr, "Instantiating a new ProjectSettings singleton is not supported.");
|
||
singleton = this;
|
||
|
||
#ifdef TOOLS_ENABLED
|
||
// Available only at runtime in editor builds. Needs to be processed before anything else to work properly.
|
||
if (!Engine::get_singleton()->is_editor_hint()) {
|
||
String editor_features = OS::get_singleton()->get_environment("GODOT_EDITOR_CUSTOM_FEATURES");
|
||
if (!editor_features.is_empty()) {
|
||
PackedStringArray feature_list = editor_features.split(",");
|
||
for (const String &s : feature_list) {
|
||
custom_features.insert(s);
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
GLOBAL_DEF_BASIC("application/config/name", "");
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::DICTIONARY, "application/config/name_localized", PROPERTY_HINT_LOCALIZABLE_STRING), Dictionary());
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::STRING, "application/config/description", PROPERTY_HINT_MULTILINE_TEXT), "");
|
||
GLOBAL_DEF_BASIC("application/config/version", "");
|
||
GLOBAL_DEF_INTERNAL(PropertyInfo(Variant::STRING, "application/config/tags"), PackedStringArray());
|
||
GLOBAL_DEF_BASIC(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/run/print_header", true);
|
||
GLOBAL_DEF_RST("application/config/use_hidden_project_data_directory", true);
|
||
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("application/run/main_loop_type", "SceneTree");
|
||
GLOBAL_DEF("application/config/auto_accept_quit", true);
|
||
GLOBAL_DEF("application/config/quit_on_go_back", true);
|
||
|
||
// The default window size is tuned to:
|
||
// - Have a 16:9 aspect ratio,
|
||
// - Have both dimensions divisible by 8 to better play along with video recording,
|
||
// - Be displayable correctly in windowed mode on a 1366×768 display (tested on Windows 10 with default settings).
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "display/window/size/viewport_width", PROPERTY_HINT_RANGE, "1,7680,1,or_greater"), 1152); // 8K resolution
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "display/window/size/viewport_height", PROPERTY_HINT_RANGE, "1,4320,1,or_greater"), 648); // 8K resolution
|
||
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "display/window/size/mode", PROPERTY_HINT_ENUM, "Windowed,Minimized,Maximized,Fullscreen,Exclusive Fullscreen"), 0);
|
||
|
||
// Keep the enum values in sync with the `DisplayServer::SCREEN_` enum.
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "display/window/size/initial_position_type", PROPERTY_HINT_ENUM, "Absolute,Center of Primary Screen,Center of Other Screen,Center of Screen With Mouse Pointer,Center of Screen With Keyboard Focus"), 1);
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::VECTOR2I, "display/window/size/initial_position"), Vector2i());
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "display/window/size/initial_screen", PROPERTY_HINT_RANGE, "0,64,1,or_greater"), 0);
|
||
|
||
GLOBAL_DEF_BASIC("display/window/size/resizable", true);
|
||
GLOBAL_DEF_BASIC("display/window/size/borderless", false);
|
||
GLOBAL_DEF("display/window/size/always_on_top", false);
|
||
GLOBAL_DEF("display/window/size/transparent", false);
|
||
GLOBAL_DEF("display/window/size/extend_to_title", false);
|
||
GLOBAL_DEF("display/window/size/no_focus", false);
|
||
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "display/window/size/window_width_override", PROPERTY_HINT_RANGE, "0,7680,1,or_greater"), 0); // 8K resolution
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "display/window/size/window_height_override", PROPERTY_HINT_RANGE, "0,4320,1,or_greater"), 0); // 8K resolution
|
||
|
||
GLOBAL_DEF("display/window/energy_saving/keep_screen_on", true);
|
||
GLOBAL_DEF("display/window/energy_saving/keep_screen_on.editor", false);
|
||
|
||
GLOBAL_DEF("animation/warnings/check_invalid_track_paths", true);
|
||
GLOBAL_DEF("animation/warnings/check_angle_interpolation_type_conflicting", true);
|
||
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::STRING, "audio/buses/default_bus_layout", PROPERTY_HINT_FILE, "*.tres"), "res://default_bus_layout.tres");
|
||
GLOBAL_DEF_RST("audio/general/text_to_speech", false);
|
||
GLOBAL_DEF_RST(PropertyInfo(Variant::FLOAT, "audio/general/2d_panning_strength", PROPERTY_HINT_RANGE, "0,2,0.01"), 0.5f);
|
||
GLOBAL_DEF_RST(PropertyInfo(Variant::FLOAT, "audio/general/3d_panning_strength", PROPERTY_HINT_RANGE, "0,2,0.01"), 0.5f);
|
||
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "audio/general/ios/session_category", PROPERTY_HINT_ENUM, "Ambient,Multi Route,Play and Record,Playback,Record,Solo Ambient"), 0);
|
||
GLOBAL_DEF("audio/general/ios/mix_with_others", false);
|
||
|
||
PackedStringArray extensions;
|
||
extensions.push_back("gd");
|
||
if (Engine::get_singleton()->has_singleton("GodotSharp")) {
|
||
extensions.push_back("cs");
|
||
}
|
||
extensions.push_back("gdshader");
|
||
|
||
GLOBAL_DEF(PropertyInfo(Variant::PACKED_STRING_ARRAY, "editor/script/search_in_file_extensions"), extensions);
|
||
|
||
_add_builtin_input_map();
|
||
|
||
// Keep the enum values in sync with the `DisplayServer::ScreenOrientation` enum.
|
||
custom_prop_info["display/window/handheld/orientation"] = PropertyInfo(Variant::INT, "display/window/handheld/orientation", PROPERTY_HINT_ENUM, "Landscape,Portrait,Reverse Landscape,Reverse Portrait,Sensor Landscape,Sensor Portrait,Sensor");
|
||
GLOBAL_DEF("display/window/subwindows/embed_subwindows", true);
|
||
// Keep the enum values in sync with the `DisplayServer::VSyncMode` enum.
|
||
custom_prop_info["display/window/vsync/vsync_mode"] = PropertyInfo(Variant::INT, "display/window/vsync/vsync_mode", PROPERTY_HINT_ENUM, "Disabled,Enabled,Adaptive,Mailbox");
|
||
custom_prop_info["rendering/driver/threads/thread_model"] = PropertyInfo(Variant::INT, "rendering/driver/threads/thread_model", PROPERTY_HINT_ENUM, "Single-Unsafe,Single-Safe,Multi-Threaded");
|
||
GLOBAL_DEF("physics/2d/run_on_separate_thread", false);
|
||
GLOBAL_DEF("physics/3d/run_on_separate_thread", false);
|
||
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::STRING, "display/window/stretch/mode", PROPERTY_HINT_ENUM, "disabled,canvas_items,viewport"), "disabled");
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::STRING, "display/window/stretch/aspect", PROPERTY_HINT_ENUM, "ignore,keep,keep_width,keep_height,expand"), "keep");
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::FLOAT, "display/window/stretch/scale", PROPERTY_HINT_RANGE, "0.5,8.0,0.01"), 1.0);
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::STRING, "display/window/stretch/scale_mode", PROPERTY_HINT_ENUM, "fractional,integer"), "fractional");
|
||
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "debug/settings/profiler/max_functions", PROPERTY_HINT_RANGE, "128,65535,1"), 16384);
|
||
|
||
GLOBAL_DEF(PropertyInfo(Variant::BOOL, "compression/formats/zstd/long_distance_matching"), Compression::zstd_long_distance_matching);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "compression/formats/zstd/compression_level", PROPERTY_HINT_RANGE, "1,22,1"), Compression::zstd_level);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "compression/formats/zstd/window_log_size", PROPERTY_HINT_RANGE, "10,30,1"), Compression::zstd_window_log_size);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "compression/formats/zlib/compression_level", PROPERTY_HINT_RANGE, "-1,9,1"), Compression::zlib_level);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "compression/formats/gzip/compression_level", PROPERTY_HINT_RANGE, "-1,9,1"), Compression::gzip_level);
|
||
|
||
GLOBAL_DEF("debug/settings/crash_handler/message",
|
||
String("Please include this when reporting the bug to the project developer."));
|
||
GLOBAL_DEF("debug/settings/crash_handler/message.editor",
|
||
String("Please include this when reporting the bug on: https://github.com/godotengine/godot/issues"));
|
||
GLOBAL_DEF_RST(PropertyInfo(Variant::INT, "rendering/occlusion_culling/bvh_build_quality", PROPERTY_HINT_ENUM, "Low,Medium,High"), 2);
|
||
GLOBAL_DEF_RST("rendering/occlusion_culling/jitter_projection", true);
|
||
|
||
GLOBAL_DEF_RST("internationalization/rendering/force_right_to_left_layout_direction", false);
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "internationalization/rendering/root_node_layout_direction", PROPERTY_HINT_ENUM, "Based on Application Locale,Left-to-Right,Right-to-Left,Based on System Locale"), 0);
|
||
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "gui/timers/incremental_search_max_interval_msec", PROPERTY_HINT_RANGE, "0,10000,1,or_greater"), 2000);
|
||
|
||
GLOBAL_DEF_BASIC("gui/common/snap_controls_to_pixels", true);
|
||
GLOBAL_DEF_BASIC("gui/fonts/dynamic_fonts/use_oversampling", true);
|
||
|
||
GLOBAL_DEF_RST(PropertyInfo(Variant::INT, "rendering/rendering_device/vsync/frame_queue_size", PROPERTY_HINT_RANGE, "2,3,1"), 2);
|
||
GLOBAL_DEF_RST(PropertyInfo(Variant::INT, "rendering/rendering_device/vsync/swapchain_image_count", PROPERTY_HINT_RANGE, "2,4,1"), 3);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "rendering/rendering_device/staging_buffer/block_size_kb", PROPERTY_HINT_RANGE, "4,2048,1,or_greater"), 256);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "rendering/rendering_device/staging_buffer/max_size_mb", PROPERTY_HINT_RANGE, "1,1024,1,or_greater"), 128);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "rendering/rendering_device/staging_buffer/texture_upload_region_size_px", PROPERTY_HINT_RANGE, "1,256,1,or_greater"), 64);
|
||
GLOBAL_DEF(PropertyInfo(Variant::FLOAT, "rendering/rendering_device/pipeline_cache/save_chunk_size_mb", PROPERTY_HINT_RANGE, "0.000001,64.0,0.001,or_greater"), 3.0);
|
||
GLOBAL_DEF(PropertyInfo(Variant::INT, "rendering/rendering_device/vulkan/max_descriptors_per_pool", PROPERTY_HINT_RANGE, "1,256,1,or_greater"), 64);
|
||
|
||
GLOBAL_DEF_RST("rendering/rendering_device/d3d12/max_resource_descriptors_per_frame", 16384);
|
||
custom_prop_info["rendering/rendering_device/d3d12/max_resource_descriptors_per_frame"] = PropertyInfo(Variant::INT, "rendering/rendering_device/d3d12/max_resource_descriptors_per_frame", PROPERTY_HINT_RANGE, "512,262144");
|
||
GLOBAL_DEF_RST("rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame", 1024);
|
||
custom_prop_info["rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame"] = PropertyInfo(Variant::INT, "rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame", PROPERTY_HINT_RANGE, "256,2048");
|
||
GLOBAL_DEF_RST("rendering/rendering_device/d3d12/max_misc_descriptors_per_frame", 512);
|
||
custom_prop_info["rendering/rendering_device/d3d12/max_misc_descriptors_per_frame"] = PropertyInfo(Variant::INT, "rendering/rendering_device/d3d12/max_misc_descriptors_per_frame", PROPERTY_HINT_RANGE, "32,4096");
|
||
|
||
GLOBAL_DEF_RST(PropertyInfo(Variant::INT, "rendering/rendering_device/d3d12/agility_sdk_version"), 610);
|
||
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "rendering/textures/canvas_textures/default_texture_filter", PROPERTY_HINT_ENUM, "Nearest,Linear,Linear Mipmap,Nearest Mipmap"), 1);
|
||
GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "rendering/textures/canvas_textures/default_texture_repeat", PROPERTY_HINT_ENUM, "Disable,Enable,Mirror"), 0);
|
||
|
||
GLOBAL_DEF("collada/use_ambient", false);
|
||
|
||
// These properties will not show up in the dialog. If you want to exclude whole groups, use add_hidden_prefix().
|
||
GLOBAL_DEF_INTERNAL("application/config/features", PackedStringArray());
|
||
GLOBAL_DEF_INTERNAL("internationalization/locale/translation_remaps", PackedStringArray());
|
||
GLOBAL_DEF_INTERNAL("internationalization/locale/translations", PackedStringArray());
|
||
GLOBAL_DEF_INTERNAL("internationalization/locale/translations_pot_files", PackedStringArray());
|
||
GLOBAL_DEF_INTERNAL("internationalization/locale/translation_add_builtin_strings_to_pot", false);
|
||
|
||
ProjectSettings::get_singleton()->add_hidden_prefix("input/");
|
||
}
|
||
|
||
ProjectSettings::~ProjectSettings() {
|
||
singleton = nullptr;
|
||
}
|