godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #61141 from timothyqiu/property-extract-3.x

Browse Source
This commit is contained in:
Rémi Verschelde 2022-05-19 09:24:34 +02:00 committed by GitHub
commit fae9f38f17
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 211 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
core/ustring.h
View File

@ -438,6 +438,16 @@ String DTR(const String &);
#define TTRGET(m_value) (m_value) #define TTRGET(m_value) (m_value)
#endif #endif
// Use this to mark property names for editor translation.
// Often for dynamic properties defined in _get_property_list().
// Property names defined directly inside EDITOR_DEF, GLOBAL_DEF, and ADD_PROPERTY macros don't need this.
#define PNAME(m_value) (m_value)
// Similar to PNAME, but to mark groups, i.e. properties with PROPERTY_USAGE_GROUP.
// Groups defined directly inside ADD_GROUP macros don't need this.
// The arguments are the same as ADD_GROUP. m_prefix is only used for extraction.
#define GNAME(m_value, m_prefix) (m_value)
// Runtime translate for the public node API. // Runtime translate for the public node API.
String RTR(const String &); String RTR(const String &);

38
editor/animation_track_editor.cpp
View File

@ -516,16 +516,16 @@ public:
if (use_fps && animation->get_step() > 0) { if (use_fps && animation->get_step() > 0) {
float max_frame = animation->get_length() / animation->get_step(); float max_frame = animation->get_length() / animation->get_step();
p_list->push_back(PropertyInfo(Variant::REAL, "frame", PROPERTY_HINT_RANGE, "0," + rtos(max_frame) + ",1")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("frame"), PROPERTY_HINT_RANGE, "0," + rtos(max_frame) + ",1"));
} else { } else {
p_list->push_back(PropertyInfo(Variant::REAL, "time", PROPERTY_HINT_RANGE, "0," + rtos(animation->get_length()) + ",0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("time"), PROPERTY_HINT_RANGE, "0," + rtos(animation->get_length()) + ",0.01"));
} }
switch (animation->track_get_type(track)) { switch (animation->track_get_type(track)) {
case Animation::TYPE_TRANSFORM: { case Animation::TYPE_TRANSFORM: {
p_list->push_back(PropertyInfo(Variant::VECTOR3, "location")); p_list->push_back(PropertyInfo(Variant::VECTOR3, PNAME("location")));
p_list->push_back(PropertyInfo(Variant::QUAT, "rotation")); p_list->push_back(PropertyInfo(Variant::QUAT, PNAME("rotation")));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "scale")); p_list->push_back(PropertyInfo(Variant::VECTOR3, PNAME("scale")));
} break; } break;
case Animation::TYPE_VALUE: { case Animation::TYPE_VALUE: {
@ -533,7 +533,7 @@ public:
if (hint.type != Variant::NIL) { if (hint.type != Variant::NIL) {
PropertyInfo pi = hint; PropertyInfo pi = hint;
pi.name = "value"; pi.name = PNAME("value");
p_list->push_back(pi); p_list->push_back(pi);
} else { } else {
PropertyHint hint = PROPERTY_HINT_NONE; PropertyHint hint = PROPERTY_HINT_NONE;
@ -549,15 +549,15 @@ public:
} }
if (v.get_type() != Variant::NIL) { if (v.get_type() != Variant::NIL) {
p_list->push_back(PropertyInfo(v.get_type(), "value", hint, hint_string)); p_list->push_back(PropertyInfo(v.get_type(), PNAME("value"), hint, hint_string));
} }
} }
} break; } break;
case Animation::TYPE_METHOD: { case Animation::TYPE_METHOD: {
p_list->push_back(PropertyInfo(Variant::STRING, "name")); p_list->push_back(PropertyInfo(Variant::STRING, PNAME("name")));
static_assert(VARIANT_ARG_MAX == 8, "PROPERTY_HINT_RANGE needs to be updated if VARIANT_ARG_MAX != 8"); static_assert(VARIANT_ARG_MAX == 8, "PROPERTY_HINT_RANGE needs to be updated if VARIANT_ARG_MAX != 8");
p_list->push_back(PropertyInfo(Variant::INT, "arg_count", PROPERTY_HINT_RANGE, "0,8,1")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("arg_count"), PROPERTY_HINT_RANGE, "0,8,1"));
Dictionary d = animation->track_get_key_value(track, key); Dictionary d = animation->track_get_key_value(track, key);
ERR_FAIL_COND(!d.has("args")); ERR_FAIL_COND(!d.has("args"));
@ -571,23 +571,23 @@ public:
} }
for (int i = 0; i < args.size(); i++) { for (int i = 0; i < args.size(); i++) {
p_list->push_back(PropertyInfo(Variant::INT, "args/" + itos(i) + "/type", PROPERTY_HINT_ENUM, vtypes)); p_list->push_back(PropertyInfo(Variant::INT, vformat("%s/%d/%s", PNAME("args"), i, PNAME("type")), PROPERTY_HINT_ENUM, vtypes));
if (args[i].get_type() != Variant::NIL) { if (args[i].get_type() != Variant::NIL) {
p_list->push_back(PropertyInfo(args[i].get_type(), "args/" + itos(i) + "/value")); p_list->push_back(PropertyInfo(args[i].get_type(), vformat("%s/%d/%s", PNAME("args"), i, PNAME("value"))));
} }
} }
} break; } break;
case Animation::TYPE_BEZIER: { case Animation::TYPE_BEZIER: {
p_list->push_back(PropertyInfo(Variant::REAL, "value")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("value")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "in_handle")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("in_handle")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "out_handle")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("out_handle")));
} break; } break;
case Animation::TYPE_AUDIO: { case Animation::TYPE_AUDIO: {
p_list->push_back(PropertyInfo(Variant::OBJECT, "stream", PROPERTY_HINT_RESOURCE_TYPE, "AudioStream")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("stream"), PROPERTY_HINT_RESOURCE_TYPE, "AudioStream"));
p_list->push_back(PropertyInfo(Variant::REAL, "start_offset", PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("start_offset"), PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater"));
p_list->push_back(PropertyInfo(Variant::REAL, "end_offset", PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("end_offset"), PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater"));
} break; } break;
case Animation::TYPE_ANIMATION: { case Animation::TYPE_ANIMATION: {
@ -613,13 +613,13 @@ public:
} }
animations += "[stop]"; animations += "[stop]";
p_list->push_back(PropertyInfo(Variant::STRING, "animation", PROPERTY_HINT_ENUM, animations)); p_list->push_back(PropertyInfo(Variant::STRING, PNAME("animation"), PROPERTY_HINT_ENUM, animations));
} break; } break;
} }
if (animation->track_get_type(track) == Animation::TYPE_VALUE) { if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
p_list->push_back(PropertyInfo(Variant::REAL, "easing", PROPERTY_HINT_EXP_EASING)); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("easing"), PROPERTY_HINT_EXP_EASING));
} }
} }

14
editor/plugins/item_list_editor_plugin.cpp
View File

@ -102,26 +102,26 @@ void ItemListPlugin::_get_property_list(List<PropertyInfo> *p_list) const {
for (int i = 0; i < get_item_count(); i++) { for (int i = 0; i < get_item_count(); i++) {
String base = itos(i) + "/"; String base = itos(i) + "/";
p_list->push_back(PropertyInfo(Variant::STRING, base + "text")); p_list->push_back(PropertyInfo(Variant::STRING, base + PNAME("text")));
p_list->push_back(PropertyInfo(Variant::OBJECT, base + "icon", PROPERTY_HINT_RESOURCE_TYPE, "Texture")); p_list->push_back(PropertyInfo(Variant::OBJECT, base + PNAME("icon"), PROPERTY_HINT_RESOURCE_TYPE, "Texture"));
int flags = get_flags(); int flags = get_flags();
if (flags & FLAG_CHECKABLE) { if (flags & FLAG_CHECKABLE) {
p_list->push_back(PropertyInfo(Variant::INT, base + "checkable", PROPERTY_HINT_ENUM, "No,As checkbox,As radio button")); p_list->push_back(PropertyInfo(Variant::INT, base + PNAME("checkable"), PROPERTY_HINT_ENUM, "No,As checkbox,As radio button"));
p_list->push_back(PropertyInfo(Variant::BOOL, base + "checked")); p_list->push_back(PropertyInfo(Variant::BOOL, base + PNAME("checked")));
} }
if (flags & FLAG_ID) { if (flags & FLAG_ID) {
p_list->push_back(PropertyInfo(Variant::INT, base + "id", PROPERTY_HINT_RANGE, "-1,4096")); p_list->push_back(PropertyInfo(Variant::INT, base + PNAME("id"), PROPERTY_HINT_RANGE, "-1,4096"));
} }
if (flags & FLAG_ENABLE) { if (flags & FLAG_ENABLE) {
p_list->push_back(PropertyInfo(Variant::BOOL, base + "enabled")); p_list->push_back(PropertyInfo(Variant::BOOL, base + PNAME("enabled")));
} }
if (flags & FLAG_SEPARATOR) { if (flags & FLAG_SEPARATOR) {
p_list->push_back(PropertyInfo(Variant::BOOL, base + "separator")); p_list->push_back(PropertyInfo(Variant::BOOL, base + PNAME("separator")));
} }
} }
} }

56
editor/plugins/tile_set_editor_plugin.cpp
View File

@ -3538,50 +3538,50 @@ bool TilesetEditorContext::_get(const StringName &p_name, Variant &r_ret) const
void TilesetEditorContext::_get_property_list(List<PropertyInfo> *p_list) const { void TilesetEditorContext::_get_property_list(List<PropertyInfo> *p_list) const {
if (snap_options_visible) { if (snap_options_visible) {
p_list->push_back(PropertyInfo(Variant::NIL, "Snap Options", PROPERTY_HINT_NONE, "options_", PROPERTY_USAGE_GROUP)); p_list->push_back(PropertyInfo(Variant::NIL, GNAME("Snap Options", "options_"), PROPERTY_HINT_NONE, "options_", PROPERTY_USAGE_GROUP));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "options_offset")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("options_offset")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "options_step")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("options_step")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "options_separation")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("options_separation")));
} }
if (tileset_editor->get_current_tile() >= 0 && !tileset.is_null()) { if (tileset_editor->get_current_tile() >= 0 && !tileset.is_null()) {
int id = tileset_editor->get_current_tile(); int id = tileset_editor->get_current_tile();
p_list->push_back(PropertyInfo(Variant::NIL, "Selected Tile", PROPERTY_HINT_NONE, "tile_", PROPERTY_USAGE_GROUP)); p_list->push_back(PropertyInfo(Variant::NIL, GNAME("Selected Tile", "tile_"), PROPERTY_HINT_NONE, "tile_", PROPERTY_USAGE_GROUP));
p_list->push_back(PropertyInfo(Variant::STRING, "tile_name")); p_list->push_back(PropertyInfo(Variant::STRING, PNAME("tile_name")));
p_list->push_back(PropertyInfo(Variant::OBJECT, "tile_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tile_texture"), PROPERTY_HINT_RESOURCE_TYPE, "Texture"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "tile_normal_map", PROPERTY_HINT_RESOURCE_TYPE, "Texture")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tile_normal_map"), PROPERTY_HINT_RESOURCE_TYPE, "Texture"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_tex_offset")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_tex_offset")));
p_list->push_back(PropertyInfo(Variant::OBJECT, "tile_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tile_material"), PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial"));
p_list->push_back(PropertyInfo(Variant::COLOR, "tile_modulate")); p_list->push_back(PropertyInfo(Variant::COLOR, PNAME("tile_modulate")));
p_list->push_back(PropertyInfo(Variant::INT, "tile_tile_mode", PROPERTY_HINT_ENUM, "SINGLE_TILE,AUTO_TILE,ATLAS_TILE")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_tile_mode"), PROPERTY_HINT_ENUM, "SINGLE_TILE,AUTO_TILE,ATLAS_TILE"));
if (tileset->tile_get_tile_mode(id) == TileSet::AUTO_TILE) { if (tileset->tile_get_tile_mode(id) == TileSet::AUTO_TILE) {
p_list->push_back(PropertyInfo(Variant::INT, "tile_autotile_bitmask_mode", PROPERTY_HINT_ENUM, "2x2,3x3 (minimal),3x3")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_autotile_bitmask_mode"), PROPERTY_HINT_ENUM, "2x2,3x3 (minimal),3x3"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_subtile_size")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_subtile_size")));
p_list->push_back(PropertyInfo(Variant::INT, "tile_subtile_spacing", PROPERTY_HINT_RANGE, "0, 1024, 1")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_subtile_spacing"), PROPERTY_HINT_RANGE, "0, 1024, 1"));
} else if (tileset->tile_get_tile_mode(id) == TileSet::ATLAS_TILE) { } else if (tileset->tile_get_tile_mode(id) == TileSet::ATLAS_TILE) {
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_subtile_size")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_subtile_size")));
p_list->push_back(PropertyInfo(Variant::INT, "tile_subtile_spacing", PROPERTY_HINT_RANGE, "0, 1024, 1")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_subtile_spacing"), PROPERTY_HINT_RANGE, "0, 1024, 1"));
} }
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_occluder_offset")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_occluder_offset")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_navigation_offset")); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_navigation_offset")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_shape_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR)); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_shape_offset"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_shape_transform", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR)); p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_shape_transform"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::INT, "tile_z_index", PROPERTY_HINT_RANGE, itos(VS::CANVAS_ITEM_Z_MIN) + "," + itos(VS::CANVAS_ITEM_Z_MAX) + ",1")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_z_index"), PROPERTY_HINT_RANGE, itos(VS::CANVAS_ITEM_Z_MIN) + "," + itos(VS::CANVAS_ITEM_Z_MAX) + ",1"));
} }
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_COLLISION && tileset_editor->edited_collision_shape.is_valid()) { if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_COLLISION && tileset_editor->edited_collision_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "selected_collision", PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_collision_shape->get_class())); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("selected_collision"), PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_collision_shape->get_class()));
if (tileset_editor->edited_collision_shape.is_valid()) { if (tileset_editor->edited_collision_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::BOOL, "selected_collision_one_way", PROPERTY_HINT_NONE)); p_list->push_back(PropertyInfo(Variant::BOOL, PNAME("selected_collision_one_way"), PROPERTY_HINT_NONE));
p_list->push_back(PropertyInfo(Variant::REAL, "selected_collision_one_way_margin", PROPERTY_HINT_NONE)); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("selected_collision_one_way_margin"), PROPERTY_HINT_NONE));
} }
} }
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_NAVIGATION && tileset_editor->edited_navigation_shape.is_valid()) { if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_NAVIGATION && tileset_editor->edited_navigation_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "selected_navigation", PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_navigation_shape->get_class())); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("selected_navigation"), PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_navigation_shape->get_class()));
} }
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_OCCLUSION && tileset_editor->edited_occlusion_shape.is_valid()) { if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_OCCLUSION && tileset_editor->edited_occlusion_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "selected_occlusion", PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_occlusion_shape->get_class())); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("selected_occlusion"), PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_occlusion_shape->get_class()));
} }
if (!tileset.is_null()) { if (!tileset.is_null()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "tileset_script", PROPERTY_HINT_RESOURCE_TYPE, "Script")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tileset_script"), PROPERTY_HINT_RESOURCE_TYPE, "Script"));
} }
} }

16
editor/translations/extract.py
View File

@ -101,16 +101,18 @@ message_patterns = {
re.compile(r'TTRC\("(?P<message>([^"\\]|\\.)*)"\)'): ExtractType.TEXT, re.compile(r'TTRC\("(?P<message>([^"\\]|\\.)*)"\)'): ExtractType.TEXT,
re.compile(r'_initial_set\("(?P<message>[^"]+?)",'): ExtractType.PROPERTY_PATH, re.compile(r'_initial_set\("(?P<message>[^"]+?)",'): ExtractType.PROPERTY_PATH,
re.compile(r'GLOBAL_DEF(_RST)?(_NOVAL)?\("(?P<message>[^"]+?)",'): ExtractType.PROPERTY_PATH, re.compile(r'GLOBAL_DEF(_RST)?(_NOVAL)?\("(?P<message>[^"]+?)",'): ExtractType.PROPERTY_PATH,
re.compile(r'GLOBAL_DEF\("(?P<message>layer_names/\w+)/layer_"'): ExtractType.PROPERTY_PATH,
re.compile(r'EDITOR_DEF(_RST)?\("(?P<message>[^"]+?)",'): ExtractType.PROPERTY_PATH, re.compile(r'EDITOR_DEF(_RST)?\("(?P<message>[^"]+?)",'): ExtractType.PROPERTY_PATH,
re.compile( re.compile(
r'(ADD_PROPERTYI?|ImportOption|ExportOption)\(PropertyInfo\(Variant::[_A-Z0-9]+, "(?P<message>[^"]+?)"[,)]' r"(ADD_PROPERTYI?|ImportOption|ExportOption)\(PropertyInfo\("
+ r"Variant::[_A-Z0-9]+" # Name
+ r', "(?P<message>[^"]+)"' # Type
+ r'(, [_A-Z0-9]+(, "([^"\\]|\\.)*"(, (?P<usage>[_A-Z0-9]+))?)?|\))' # [, hint[, hint string[, usage]]].
): ExtractType.PROPERTY_PATH, ): ExtractType.PROPERTY_PATH,
re.compile( re.compile(
r"(?!#define )LIMPL_PROPERTY(_RANGE)?\(Variant::[_A-Z0-9]+, (?P<message>[^,]+?)," r"(?!#define )LIMPL_PROPERTY(_RANGE)?\(Variant::[_A-Z0-9]+, (?P<message>[^,]+?),"
): ExtractType.PROPERTY_PATH, ): ExtractType.PROPERTY_PATH,
re.compile(r'ADD_GROUP\("(?P<message>[^"]+?)", "(?P<prefix>[^"]*?)"\)'): ExtractType.GROUP, re.compile(r'(ADD_GROUP|GNAME)\("(?P<message>[^"]+)", "(?P<prefix>[^"]*)"\)'): ExtractType.GROUP,
re.compile(r'#define (WSC|WSS|WRTC)_\w+ "(?P<message>[^"]+?)"'): ExtractType.PROPERTY_PATH, re.compile(r'PNAME\("(?P<message>[^"]+)"\)'): ExtractType.PROPERTY_PATH,
} }
theme_property_patterns = { theme_property_patterns = {
re.compile(r'set_(constant|font|stylebox|color|icon)\("(?P<message>[^"]+)", '): ExtractType.PROPERTY_PATH, re.compile(r'set_(constant|font|stylebox|color|icon)\("(?P<message>[^"]+)", '): ExtractType.PROPERTY_PATH,
@ -221,11 +223,17 @@ def process_file(f, fname):
if extract_type == ExtractType.TEXT: if extract_type == ExtractType.TEXT:
_add_message(msg, msgctx, location, translator_comment) _add_message(msg, msgctx, location, translator_comment)
elif extract_type == ExtractType.PROPERTY_PATH: elif extract_type == ExtractType.PROPERTY_PATH:
if captures.get("usage") == "PROPERTY_USAGE_NOEDITOR":
continue
if current_group: if current_group:
if msg.startswith(current_group): if msg.startswith(current_group):
msg = msg[len(current_group) :] msg = msg[len(current_group) :]
elif current_group.startswith(msg):
pass # Keep this as-is. See EditorInspector::update_tree().
else: else:
current_group = "" current_group = ""
if "." in msg: # Strip feature tag. if "." in msg: # Strip feature tag.
msg = msg.split(".", 1)[0] msg = msg.split(".", 1)[0]
for part in msg.split("/"): for part in msg.split("/"):

2
modules/webrtc/webrtc_data_channel.h
View File

@ -33,7 +33,7 @@
#include "core/io/packet_peer.h" #include "core/io/packet_peer.h"
#define WRTC_IN_BUF "network/limits/webrtc/max_channel_in_buffer_kb" #define WRTC_IN_BUF PNAME("network/limits/webrtc/max_channel_in_buffer_kb")
class WebRTCDataChannel : public PacketPeer { class WebRTCDataChannel : public PacketPeer {
GDCLASS(WebRTCDataChannel, PacketPeer); GDCLASS(WebRTCDataChannel, PacketPeer);

16
modules/websocket/websocket_macros.h
View File

@ -31,15 +31,15 @@
#ifndef WEBSOCKETMACTOS_H #ifndef WEBSOCKETMACTOS_H
#define WEBSOCKETMACTOS_H #define WEBSOCKETMACTOS_H
#define WSC_IN_BUF "network/limits/websocket_client/max_in_buffer_kb" #define WSC_IN_BUF PNAME("network/limits/websocket_client/max_in_buffer_kb")
#define WSC_IN_PKT "network/limits/websocket_client/max_in_packets" #define WSC_IN_PKT PNAME("network/limits/websocket_client/max_in_packets")
#define WSC_OUT_BUF "network/limits/websocket_client/max_out_buffer_kb" #define WSC_OUT_BUF PNAME("network/limits/websocket_client/max_out_buffer_kb")
#define WSC_OUT_PKT "network/limits/websocket_client/max_out_packets" #define WSC_OUT_PKT PNAME("network/limits/websocket_client/max_out_packets")
#define WSS_IN_BUF "network/limits/websocket_server/max_in_buffer_kb" #define WSS_IN_BUF PNAME("network/limits/websocket_server/max_in_buffer_kb")
#define WSS_IN_PKT "network/limits/websocket_server/max_in_packets" #define WSS_IN_PKT PNAME("network/limits/websocket_server/max_in_packets")
#define WSS_OUT_BUF "network/limits/websocket_server/max_out_buffer_kb" #define WSS_OUT_BUF PNAME("network/limits/websocket_server/max_out_buffer_kb")
#define WSS_OUT_PKT "network/limits/websocket_server/max_out_packets" #define WSS_OUT_PKT PNAME("network/limits/websocket_server/max_out_packets")
/* clang-format off */ /* clang-format off */
#define GDCICLASS(CNAME) \ #define GDCICLASS(CNAME) \

12
platform/android/export/export_plugin.cpp
View File

@ -187,9 +187,9 @@ static const char *SPLASH_CONFIG_PATH = "res://android/build/res/drawable/splash
static const char *GDNATIVE_LIBS_PATH = "res://android/build/libs/gdnativelibs.json"; static const char *GDNATIVE_LIBS_PATH = "res://android/build/libs/gdnativelibs.json";
static const int icon_densities_count = 6; static const int icon_densities_count = 6;
static const char *launcher_icon_option = "launcher_icons/main_192x192"; static const char *launcher_icon_option = PNAME("launcher_icons/main_192x192");
static const char *launcher_adaptive_icon_foreground_option = "launcher_icons/adaptive_foreground_432x432"; static const char *launcher_adaptive_icon_foreground_option = PNAME("launcher_icons/adaptive_foreground_432x432");
static const char *launcher_adaptive_icon_background_option = "launcher_icons/adaptive_background_432x432"; static const char *launcher_adaptive_icon_background_option = PNAME("launcher_icons/adaptive_background_432x432");
static const LauncherIcon launcher_icons[icon_densities_count] = { static const LauncherIcon launcher_icons[icon_densities_count] = {
{ "res/mipmap-xxxhdpi-v4/icon.png", 192 }, { "res/mipmap-xxxhdpi-v4/icon.png", 192 },
@ -1701,7 +1701,7 @@ void EditorExportPlatformAndroid::get_export_options(List<ExportOption> *r_optio
Vector<PluginConfigAndroid> plugins_configs = get_plugins(); Vector<PluginConfigAndroid> plugins_configs = get_plugins();
for (int i = 0; i < plugins_configs.size(); i++) { for (int i = 0; i < plugins_configs.size(); i++) {
print_verbose("Found Android plugin " + plugins_configs[i].name); print_verbose("Found Android plugin " + plugins_configs[i].name);
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "plugins/" + plugins_configs[i].name), false)); r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, vformat("%s/%s", PNAME("plugins"), plugins_configs[i].name)), false));
} }
plugins_changed.clear(); plugins_changed.clear();
@ -1709,7 +1709,7 @@ void EditorExportPlatformAndroid::get_export_options(List<ExportOption> *r_optio
for (int i = 0; i < abis.size(); ++i) { for (int i = 0; i < abis.size(); ++i) {
String abi = abis[i]; String abi = abis[i];
bool is_default = (abi == "armeabi-v7a" || abi == "arm64-v8a"); bool is_default = (abi == "armeabi-v7a" || abi == "arm64-v8a");
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "architectures/" + abi), is_default)); r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, vformat("%s/%s", PNAME("architectures"), abi)), is_default));
} }
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "keystore/debug", PROPERTY_HINT_GLOBAL_FILE, "*.keystore,*.jks"), "")); r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "keystore/debug", PROPERTY_HINT_GLOBAL_FILE, "*.keystore,*.jks"), ""));
@ -1762,7 +1762,7 @@ void EditorExportPlatformAndroid::get_export_options(List<ExportOption> *r_optio
const char **perms = android_perms; const char **perms = android_perms;
while (*perms) { while (*perms) {
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "permissions/" + String(*perms).to_lower()), false)); r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, vformat("%s/%s", PNAME("permissions"), String(*perms).to_lower())), false));
perms++; perms++;
} }
} }

26
platform/iphone/export/export.cpp
View File

@ -325,18 +325,18 @@ struct LoadingScreenInfo {
}; };
static const LoadingScreenInfo loading_screen_infos[] = { static const LoadingScreenInfo loading_screen_infos[] = {
{ "landscape_launch_screens/iphone_2436x1125", "Default-Landscape-X.png", 2436, 1125, false }, { PNAME("landscape_launch_screens/iphone_2436x1125"), "Default-Landscape-X.png", 2436, 1125, false },
{ "landscape_launch_screens/iphone_2208x1242", "Default-Landscape-736h@3x.png", 2208, 1242, false }, { PNAME("landscape_launch_screens/iphone_2208x1242"), "Default-Landscape-736h@3x.png", 2208, 1242, false },
{ "landscape_launch_screens/ipad_1024x768", "Default-Landscape.png", 1024, 768, false }, { PNAME("landscape_launch_screens/ipad_1024x768"), "Default-Landscape.png", 1024, 768, false },
{ "landscape_launch_screens/ipad_2048x1536", "Default-Landscape@2x.png", 2048, 1536, false }, { PNAME("landscape_launch_screens/ipad_2048x1536"), "Default-Landscape@2x.png", 2048, 1536, false },
{ "portrait_launch_screens/iphone_640x960", "Default-480h@2x.png", 640, 960, true }, { PNAME("portrait_launch_screens/iphone_640x960"), "Default-480h@2x.png", 640, 960, true },
{ "portrait_launch_screens/iphone_640x1136", "Default-568h@2x.png", 640, 1136, true }, { PNAME("portrait_launch_screens/iphone_640x1136"), "Default-568h@2x.png", 640, 1136, true },
{ "portrait_launch_screens/iphone_750x1334", "Default-667h@2x.png", 750, 1334, true }, { PNAME("portrait_launch_screens/iphone_750x1334"), "Default-667h@2x.png", 750, 1334, true },
{ "portrait_launch_screens/iphone_1125x2436", "Default-Portrait-X.png", 1125, 2436, true }, { PNAME("portrait_launch_screens/iphone_1125x2436"), "Default-Portrait-X.png", 1125, 2436, true },
{ "portrait_launch_screens/ipad_768x1024", "Default-Portrait.png", 768, 1024, true }, { PNAME("portrait_launch_screens/ipad_768x1024"), "Default-Portrait.png", 768, 1024, true },
{ "portrait_launch_screens/ipad_1536x2048", "Default-Portrait@2x.png", 1536, 2048, true }, { PNAME("portrait_launch_screens/ipad_1536x2048"), "Default-Portrait@2x.png", 1536, 2048, true },
{ "portrait_launch_screens/iphone_1242x2208", "Default-Portrait-736h@3x.png", 1242, 2208, true } { PNAME("portrait_launch_screens/iphone_1242x2208"), "Default-Portrait-736h@3x.png", 1242, 2208, true }
}; };
void EditorExportPlatformIOS::get_export_options(List<ExportOption> *r_options) { void EditorExportPlatformIOS::get_export_options(List<ExportOption> *r_options) {
@ -345,7 +345,7 @@ void EditorExportPlatformIOS::get_export_options(List<ExportOption> *r_options)
Vector<ExportArchitecture> architectures = _get_supported_architectures(); Vector<ExportArchitecture> architectures = _get_supported_architectures();
for (int i = 0; i < architectures.size(); ++i) { for (int i = 0; i < architectures.size(); ++i) {
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "architectures/" + architectures[i].name), architectures[i].is_default)); r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, vformat("%s/%s", PNAME("architectures"), architectures[i].name)), architectures[i].is_default));
} }
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "application/app_store_team_id"), "")); r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "application/app_store_team_id"), ""));
@ -369,7 +369,7 @@ void EditorExportPlatformIOS::get_export_options(List<ExportOption> *r_options)
Vector<PluginConfigIOS> found_plugins = get_plugins(); Vector<PluginConfigIOS> found_plugins = get_plugins();
for (int i = 0; i < found_plugins.size(); i++) { for (int i = 0; i < found_plugins.size(); i++) {
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "plugins/" + found_plugins[i].name), false)); r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, vformat("%s/%s", PNAME("plugins"), found_plugins[i].name)), false));
} }
Set<String> plist_keys; Set<String> plist_keys;

2
scene/2d/listener_2d.cpp
View File

@ -57,7 +57,7 @@ bool Listener2D::_get(const StringName &p_name, Variant &r_ret) const {
} }
void Listener2D::_get_property_list(List<PropertyInfo> *p_list) const { void Listener2D::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::BOOL, "current")); p_list->push_back(PropertyInfo(Variant::BOOL, PNAME("current")));
} }
void Listener2D::_notification(int p_what) { void Listener2D::_notification(int p_what) {

2
scene/3d/listener.cpp
View File

@ -67,7 +67,7 @@ bool Listener::_get(const StringName &p_name, Variant &r_ret) const {
} }
void Listener::_get_property_list(List<PropertyInfo> *p_list) const { void Listener::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::BOOL, "current")); p_list->push_back(PropertyInfo(Variant::BOOL, PNAME("current")));
} }
void Listener::_update_listener() { void Listener::_update_listener() {

2
scene/3d/mesh_instance.cpp
View File

@ -103,7 +103,7 @@ void MeshInstance::_get_property_list(List<PropertyInfo> *p_list) const {
if (mesh.is_valid()) { if (mesh.is_valid()) {
for (int i = 0; i < mesh->get_surface_count(); i++) { for (int i = 0; i < mesh->get_surface_count(); i++) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "material/" + itos(i), PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial")); p_list->push_back(PropertyInfo(Variant::OBJECT, vformat("%s/%d", PNAME("material"), i), PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial"));
} }
} }
} }

97
scene/3d/physics_body.cpp
View File

@ -1686,9 +1686,9 @@ bool PhysicalBone::PinJointData::_get(const StringName &p_name, Variant &r_ret)
void PhysicalBone::PinJointData::_get_property_list(List<PropertyInfo> *p_list) const { void PhysicalBone::PinJointData::_get_property_list(List<PropertyInfo> *p_list) const {
JointData::_get_property_list(p_list); JointData::_get_property_list(p_list);
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/bias", PROPERTY_HINT_RANGE, "0.01,0.99,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/bias"), PROPERTY_HINT_RANGE, "0.01,0.99,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/damping", PROPERTY_HINT_RANGE, "0.01,8.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/damping"), PROPERTY_HINT_RANGE, "0.01,8.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/impulse_clamp", PROPERTY_HINT_RANGE, "0.0,64.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/impulse_clamp"), PROPERTY_HINT_RANGE, "0.0,64.0,0.01"));
} }
bool PhysicalBone::ConeJointData::_set(const StringName &p_name, const Variant &p_value, RID j) { bool PhysicalBone::ConeJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
@ -1758,11 +1758,11 @@ bool PhysicalBone::ConeJointData::_get(const StringName &p_name, Variant &r_ret)
void PhysicalBone::ConeJointData::_get_property_list(List<PropertyInfo> *p_list) const { void PhysicalBone::ConeJointData::_get_property_list(List<PropertyInfo> *p_list) const {
JointData::_get_property_list(p_list); JointData::_get_property_list(p_list);
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/swing_span", PROPERTY_HINT_RANGE, "-180,180,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/swing_span"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/twist_span", PROPERTY_HINT_RANGE, "-40000,40000,0.1,or_lesser,or_greater")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/twist_span"), PROPERTY_HINT_RANGE, "-40000,40000,0.1,or_lesser,or_greater"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/bias", PROPERTY_HINT_RANGE, "0.01,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/bias"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/softness"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/relaxation", PROPERTY_HINT_RANGE, "0.01,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/relaxation"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
} }
bool PhysicalBone::HingeJointData::_set(const StringName &p_name, const Variant &p_value, RID j) { bool PhysicalBone::HingeJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
@ -1840,12 +1840,12 @@ bool PhysicalBone::HingeJointData::_get(const StringName &p_name, Variant &r_ret
void PhysicalBone::HingeJointData::_get_property_list(List<PropertyInfo> *p_list) const { void PhysicalBone::HingeJointData::_get_property_list(List<PropertyInfo> *p_list) const {
JointData::_get_property_list(p_list); JointData::_get_property_list(p_list);
p_list->push_back(PropertyInfo(Variant::BOOL, "joint_constraints/angular_limit_enabled")); p_list->push_back(PropertyInfo(Variant::BOOL, PNAME("joint_constraints/angular_limit_enabled")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_upper", PROPERTY_HINT_RANGE, "-180,180,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_upper"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_lower", PROPERTY_HINT_RANGE, "-180,180,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_lower"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_bias", PROPERTY_HINT_RANGE, "0.01,0.99,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_bias"), PROPERTY_HINT_RANGE, "0.01,0.99,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_softness", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_relaxation", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_relaxation"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
} }
bool PhysicalBone::SliderJointData::_set(const StringName &p_name, const Variant &p_value, RID j) { bool PhysicalBone::SliderJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
@ -1955,17 +1955,17 @@ bool PhysicalBone::SliderJointData::_get(const StringName &p_name, Variant &r_re
void PhysicalBone::SliderJointData::_get_property_list(List<PropertyInfo> *p_list) const { void PhysicalBone::SliderJointData::_get_property_list(List<PropertyInfo> *p_list) const {
JointData::_get_property_list(p_list); JointData::_get_property_list(p_list);
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/linear_limit_upper")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/linear_limit_upper")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/linear_limit_lower")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/linear_limit_lower")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/linear_limit_softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/linear_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/linear_limit_restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/linear_limit_restitution"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/linear_limit_damping", PROPERTY_HINT_RANGE, "0,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/linear_limit_damping"), PROPERTY_HINT_RANGE, "0,16.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_upper", PROPERTY_HINT_RANGE, "-180,180,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_upper"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_lower", PROPERTY_HINT_RANGE, "-180,180,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_lower"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_softness", PROPERTY_HINT_RANGE, "0.01,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_restitution", PROPERTY_HINT_RANGE, "0.01,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_restitution"), PROPERTY_HINT_RANGE, "0.01,16.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/angular_limit_damping", PROPERTY_HINT_RANGE, "0,16.0,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, PNAME("joint_constraints/angular_limit_damping"), PROPERTY_HINT_RANGE, "0,16.0,0.01"));
} }
bool PhysicalBone::SixDOFJointData::_set(const StringName &p_name, const Variant &p_value, RID j) { bool PhysicalBone::SixDOFJointData::_set(const StringName &p_name, const Variant &p_value, RID j) {
@ -2205,29 +2205,30 @@ bool PhysicalBone::SixDOFJointData::_get(const StringName &p_name, Variant &r_re
} }
void PhysicalBone::SixDOFJointData::_get_property_list(List<PropertyInfo> *p_list) const { void PhysicalBone::SixDOFJointData::_get_property_list(List<PropertyInfo> *p_list) const {
const StringName axis_names[] = { "x", "y", "z" }; const StringName axis_names[] = { PNAME("x"), PNAME("y"), PNAME("z") };
for (int i = 0; i < 3; ++i) { for (int i = 0; i < 3; ++i) {
p_list->push_back(PropertyInfo(Variant::BOOL, "joint_constraints/" + axis_names[i] + "/linear_limit_enabled")); const String prefix = vformat("%s/%s/", PNAME("joint_constraints"), axis_names[i]);
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_limit_upper")); p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("linear_limit_enabled")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_limit_lower")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_limit_upper")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_limit_softness", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_limit_lower")));
p_list->push_back(PropertyInfo(Variant::BOOL, "joint_constraints/" + axis_names[i] + "/linear_spring_enabled")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_spring_stiffness")); p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("linear_spring_enabled")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_spring_damping")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_spring_stiffness")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_equilibrium_point")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_spring_damping")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_equilibrium_point")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/linear_damping", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_restitution"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
p_list->push_back(PropertyInfo(Variant::BOOL, "joint_constraints/" + axis_names[i] + "/angular_limit_enabled")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("linear_damping"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_limit_upper", PROPERTY_HINT_RANGE, "-180,180,0.01")); p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("angular_limit_enabled")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_limit_lower", PROPERTY_HINT_RANGE, "-180,180,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_limit_upper"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_limit_softness", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_limit_lower"), PROPERTY_HINT_RANGE, "-180,180,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_restitution", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_limit_softness"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_damping", PROPERTY_HINT_RANGE, "0.01,16,0.01")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_restitution"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/erp")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_damping"), PROPERTY_HINT_RANGE, "0.01,16,0.01"));
p_list->push_back(PropertyInfo(Variant::BOOL, "joint_constraints/" + axis_names[i] + "/angular_spring_enabled")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("erp")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_spring_stiffness")); p_list->push_back(PropertyInfo(Variant::BOOL, prefix + PNAME("angular_spring_enabled")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_spring_damping")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_spring_stiffness")));
p_list->push_back(PropertyInfo(Variant::REAL, "joint_constraints/" + axis_names[i] + "/angular_equilibrium_point")); p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_spring_damping")));
p_list->push_back(PropertyInfo(Variant::REAL, prefix + PNAME("angular_equilibrium_point")));
} }
} }
@ -2276,9 +2277,9 @@ void PhysicalBone::_get_property_list(List<PropertyInfo> *p_list) const {
names += parent->get_bone_name(i); names += parent->get_bone_name(i);
} }
p_list->push_back(PropertyInfo(Variant::STRING, "bone_name", PROPERTY_HINT_ENUM, names)); p_list->push_back(PropertyInfo(Variant::STRING, PNAME("bone_name"), PROPERTY_HINT_ENUM, names));
} else { } else {
p_list->push_back(PropertyInfo(Variant::STRING, "bone_name")); p_list->push_back(PropertyInfo(Variant::STRING, PNAME("bone_name")));
} }
if (joint_data) { if (joint_data) {

14
scene/3d/skeleton.cpp
View File

@ -158,13 +158,13 @@ bool Skeleton::_get(const StringName &p_path, Variant &r_ret) const {
} }
void Skeleton::_get_property_list(List<PropertyInfo> *p_list) const { void Skeleton::_get_property_list(List<PropertyInfo> *p_list) const {
for (int i = 0; i < bones.size(); i++) { for (int i = 0; i < bones.size(); i++) {
String prep = "bones/" + itos(i) + "/"; const String prep = vformat("%s/%d/", PNAME("bones"), i);
p_list->push_back(PropertyInfo(Variant::STRING, prep + "name")); p_list->push_back(PropertyInfo(Variant::STRING, prep + PNAME("name")));
p_list->push_back(PropertyInfo(Variant::INT, prep + "parent", PROPERTY_HINT_RANGE, "-1," + itos(bones.size() - 1) + ",1")); p_list->push_back(PropertyInfo(Variant::INT, prep + PNAME("parent"), PROPERTY_HINT_RANGE, "-1," + itos(bones.size() - 1) + ",1"));
p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + "rest")); p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + PNAME("rest")));
p_list->push_back(PropertyInfo(Variant::BOOL, prep + "enabled")); p_list->push_back(PropertyInfo(Variant::BOOL, prep + PNAME("enabled")));
p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + "pose", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR)); p_list->push_back(PropertyInfo(Variant::TRANSFORM, prep + PNAME("pose"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::ARRAY, prep + "bound_children")); p_list->push_back(PropertyInfo(Variant::ARRAY, prep + PNAME("bound_children")));
} }
} }

9
scene/3d/soft_body.cpp
View File

@ -174,12 +174,13 @@ bool SoftBody::_get(const StringName &p_name, Variant &r_ret) const {
void SoftBody::_get_property_list(List<PropertyInfo> *p_list) const { void SoftBody::_get_property_list(List<PropertyInfo> *p_list) const {
const int pinned_points_indices_size = pinned_points.size(); const int pinned_points_indices_size = pinned_points.size();
p_list->push_back(PropertyInfo(Variant::POOL_INT_ARRAY, "pinned_points")); p_list->push_back(PropertyInfo(Variant::POOL_INT_ARRAY, PNAME("pinned_points")));
for (int i = 0; i < pinned_points_indices_size; ++i) { for (int i = 0; i < pinned_points_indices_size; ++i) {
p_list->push_back(PropertyInfo(Variant::INT, "attachments/" + itos(i) + "/point_index")); const String prefix = vformat("%s/%d", PNAME("attachments"), i);
p_list->push_back(PropertyInfo(Variant::NODE_PATH, "attachments/" + itos(i) + "/spatial_attachment_path")); p_list->push_back(PropertyInfo(Variant::INT, prefix + PNAME("point_index")));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "attachments/" + itos(i) + "/offset")); p_list->push_back(PropertyInfo(Variant::NODE_PATH, prefix + PNAME("spatial_attachment_path")));
p_list->push_back(PropertyInfo(Variant::VECTOR3, prefix + PNAME("offset")));
} }
} }

16
scene/animation/animation_blend_tree.cpp
View File

@ -352,7 +352,7 @@ AnimationNodeOneShot::AnimationNodeOneShot() {
mix = MIX_MODE_BLEND; mix = MIX_MODE_BLEND;
sync = false; sync = false;
active = "active"; active = PNAME("active");
prev_active = "prev_active"; prev_active = "prev_active";
time = "time"; time = "time";
remaining = "remaining"; remaining = "remaining";
@ -399,7 +399,7 @@ void AnimationNodeAdd2::_bind_methods() {
} }
AnimationNodeAdd2::AnimationNodeAdd2() { AnimationNodeAdd2::AnimationNodeAdd2() {
add_amount = "add_amount"; add_amount = PNAME("add_amount");
add_input("in"); add_input("in");
add_input("add"); add_input("add");
sync = false; sync = false;
@ -446,7 +446,7 @@ void AnimationNodeAdd3::_bind_methods() {
} }
AnimationNodeAdd3::AnimationNodeAdd3() { AnimationNodeAdd3::AnimationNodeAdd3() {
add_amount = "add_amount"; add_amount = PNAME("add_amount");
add_input("-add"); add_input("-add");
add_input("in"); add_input("in");
add_input("+add"); add_input("+add");
@ -492,7 +492,7 @@ void AnimationNodeBlend2::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
} }
AnimationNodeBlend2::AnimationNodeBlend2() { AnimationNodeBlend2::AnimationNodeBlend2() {
blend_amount = "blend_amount"; blend_amount = PNAME("blend_amount");
add_input("in"); add_input("in");
add_input("blend"); add_input("blend");
sync = false; sync = false;
@ -535,7 +535,7 @@ void AnimationNodeBlend3::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
} }
AnimationNodeBlend3::AnimationNodeBlend3() { AnimationNodeBlend3::AnimationNodeBlend3() {
blend_amount = "blend_amount"; blend_amount = PNAME("blend_amount");
add_input("-blend"); add_input("-blend");
add_input("in"); add_input("in");
add_input("+blend"); add_input("+blend");
@ -567,7 +567,7 @@ float AnimationNodeTimeScale::process(float p_time, bool p_seek) {
void AnimationNodeTimeScale::_bind_methods() { void AnimationNodeTimeScale::_bind_methods() {
} }
AnimationNodeTimeScale::AnimationNodeTimeScale() { AnimationNodeTimeScale::AnimationNodeTimeScale() {
scale = "scale"; scale = PNAME("scale");
add_input("in"); add_input("in");
} }
@ -603,7 +603,7 @@ void AnimationNodeTimeSeek::_bind_methods() {
AnimationNodeTimeSeek::AnimationNodeTimeSeek() { AnimationNodeTimeSeek::AnimationNodeTimeSeek() {
add_input("in"); add_input("in");
seek_pos = "seek_position"; seek_pos = PNAME("seek_position");
} }
///////////////////////////////////////////////// /////////////////////////////////////////////////
@ -796,7 +796,7 @@ AnimationNodeTransition::AnimationNodeTransition() {
prev_xfading = "prev_xfading"; prev_xfading = "prev_xfading";
prev = "prev"; prev = "prev";
time = "time"; time = "time";
current = "current"; current = PNAME("current");
prev_current = "prev_current"; prev_current = "prev_current";
xfade = 0.0; xfade = 0.0;

8
scene/register_scene_types.cpp
View File

@ -785,13 +785,13 @@ void register_scene_types() {
OS::get_singleton()->yield(); //may take time to init OS::get_singleton()->yield(); //may take time to init
for (int i = 0; i < 20; i++) { for (int i = 0; i < 20; i++) {
GLOBAL_DEF("layer_names/2d_render/layer_" + itos(i + 1), ""); GLOBAL_DEF(vformat("%s/layer_%d", PNAME("layer_names/2d_render"), i + 1), "");
GLOBAL_DEF("layer_names/3d_render/layer_" + itos(i + 1), ""); GLOBAL_DEF(vformat("%s/layer_%d", PNAME("layer_names/3d_render"), i + 1), "");
} }
for (int i = 0; i < 32; i++) { for (int i = 0; i < 32; i++) {
GLOBAL_DEF("layer_names/2d_physics/layer_" + itos(i + 1), ""); GLOBAL_DEF(vformat("%s/layer_%d", PNAME("layer_names/2d_physics"), i + 1), "");
GLOBAL_DEF("layer_names/3d_physics/layer_" + itos(i + 1), ""); GLOBAL_DEF(vformat("%s/layer_%d", PNAME("layer_names/3d_physics"), i + 1), "");
} }
} }

16
scene/resources/mesh_library.cpp
View File

@ -100,14 +100,14 @@ bool MeshLibrary::_get(const StringName &p_name, Variant &r_ret) const {
void MeshLibrary::_get_property_list(List<PropertyInfo> *p_list) const { void MeshLibrary::_get_property_list(List<PropertyInfo> *p_list) const {
for (Map<int, Item>::Element *E = item_map.front(); E; E = E->next()) { for (Map<int, Item>::Element *E = item_map.front(); E; E = E->next()) {
String name = "item/" + itos(E->key()) + "/"; String name = vformat("%s/%d/", PNAME("item"), E->key());
p_list->push_back(PropertyInfo(Variant::STRING, name + "name")); p_list->push_back(PropertyInfo(Variant::STRING, name + PNAME("name")));
p_list->push_back(PropertyInfo(Variant::OBJECT, name + "mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh")); p_list->push_back(PropertyInfo(Variant::OBJECT, name + PNAME("mesh"), PROPERTY_HINT_RESOURCE_TYPE, "Mesh"));
p_list->push_back(PropertyInfo(Variant::TRANSFORM, name + "mesh_transform")); p_list->push_back(PropertyInfo(Variant::TRANSFORM, name + PNAME("mesh_transform")));
p_list->push_back(PropertyInfo(Variant::ARRAY, name + "shapes")); p_list->push_back(PropertyInfo(Variant::ARRAY, name + PNAME("shapes")));
p_list->push_back(PropertyInfo(Variant::OBJECT, name + "navmesh", PROPERTY_HINT_RESOURCE_TYPE, "NavigationMesh")); p_list->push_back(PropertyInfo(Variant::OBJECT, name + PNAME("navmesh"), PROPERTY_HINT_RESOURCE_TYPE, "NavigationMesh"));
p_list->push_back(PropertyInfo(Variant::TRANSFORM, name + "navmesh_transform")); p_list->push_back(PropertyInfo(Variant::TRANSFORM, name + PNAME("navmesh_transform")));
p_list->push_back(PropertyInfo(Variant::OBJECT, name + "preview", PROPERTY_HINT_RESOURCE_TYPE, "Texture", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_HELPER)); p_list->push_back(PropertyInfo(Variant::OBJECT, name + PNAME("preview"), PROPERTY_HINT_RESOURCE_TYPE, "Texture", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_HELPER));
} }
} }

9
scene/resources/skin.cpp
View File

@ -125,11 +125,12 @@ bool Skin::_get(const StringName &p_name, Variant &r_ret) const {
return false; return false;
} }
void Skin::_get_property_list(List<PropertyInfo> *p_list) const { void Skin::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::INT, "bind_count", PROPERTY_HINT_RANGE, "0,16384,1,or_greater")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("bind_count"), PROPERTY_HINT_RANGE, "0,16384,1,or_greater"));
for (int i = 0; i < get_bind_count(); i++) { for (int i = 0; i < get_bind_count(); i++) {
p_list->push_back(PropertyInfo(Variant::STRING, "bind/" + itos(i) + "/name")); const String prefix = vformat("%s/%d/", PNAME("bind"), i);
p_list->push_back(PropertyInfo(Variant::INT, "bind/" + itos(i) + "/bone", PROPERTY_HINT_RANGE, "0,16384,1,or_greater", get_bind_name(i) != StringName() ? PROPERTY_USAGE_NOEDITOR : PROPERTY_USAGE_DEFAULT)); p_list->push_back(PropertyInfo(Variant::STRING, prefix + PNAME("name")));
p_list->push_back(PropertyInfo(Variant::TRANSFORM, "bind/" + itos(i) + "/pose")); p_list->push_back(PropertyInfo(Variant::INT, prefix + PNAME("bone"), PROPERTY_HINT_RANGE, "0,16384,1,or_greater", get_bind_name(i) != StringName() ? PROPERTY_USAGE_NOEDITOR : PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::TRANSFORM, prefix + PNAME("pose")));
} }
} }

12
scene/resources/texture.cpp
View File

@ -1539,12 +1539,12 @@ bool CubeMap::_get(const StringName &p_name, Variant &r_ret) const {
} }
void CubeMap::_get_property_list(List<PropertyInfo> *p_list) const { void CubeMap::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::OBJECT, "side/left", PROPERTY_HINT_RESOURCE_TYPE, "Image")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("side/left"), PROPERTY_HINT_RESOURCE_TYPE, "Image"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "side/right", PROPERTY_HINT_RESOURCE_TYPE, "Image")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("side/right"), PROPERTY_HINT_RESOURCE_TYPE, "Image"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "side/bottom", PROPERTY_HINT_RESOURCE_TYPE, "Image")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("side/bottom"), PROPERTY_HINT_RESOURCE_TYPE, "Image"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "side/top", PROPERTY_HINT_RESOURCE_TYPE, "Image")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("side/top"), PROPERTY_HINT_RESOURCE_TYPE, "Image"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "side/front", PROPERTY_HINT_RESOURCE_TYPE, "Image")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("side/front"), PROPERTY_HINT_RESOURCE_TYPE, "Image"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "side/back", PROPERTY_HINT_RESOURCE_TYPE, "Image")); p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("side/back"), PROPERTY_HINT_RESOURCE_TYPE, "Image"));
} }
void CubeMap::_bind_methods() { void CubeMap::_bind_methods() {

20
scene/resources/visual_shader.cpp
View File

@ -896,13 +896,13 @@ String VisualShader::validate_uniform_name(const String &p_name, const Ref<Visua
} }
VisualShader::RenderModeEnums VisualShader::render_mode_enums[] = { VisualShader::RenderModeEnums VisualShader::render_mode_enums[] = {
{ Shader::MODE_SPATIAL, "blend" }, { Shader::MODE_SPATIAL, PNAME("blend") },
{ Shader::MODE_SPATIAL, "depth_draw" }, { Shader::MODE_SPATIAL, PNAME("depth_draw") },
{ Shader::MODE_SPATIAL, "cull" }, { Shader::MODE_SPATIAL, PNAME("cull") },
{ Shader::MODE_SPATIAL, "diffuse" }, { Shader::MODE_SPATIAL, PNAME("diffuse") },
{ Shader::MODE_SPATIAL, "specular" }, { Shader::MODE_SPATIAL, PNAME("specular") },
{ Shader::MODE_SPATIAL, "async" }, { Shader::MODE_SPATIAL, PNAME("async") },
{ Shader::MODE_CANVAS_ITEM, "blend" }, { Shader::MODE_CANVAS_ITEM, PNAME("blend") },
{ Shader::MODE_CANVAS_ITEM, nullptr } { Shader::MODE_CANVAS_ITEM, nullptr }
}; };
@ -1051,7 +1051,7 @@ bool VisualShader::_get(const StringName &p_name, Variant &r_ret) const {
} }
void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const { void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
//mode //mode
p_list->push_back(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Spatial,CanvasItem,Particles")); p_list->push_back(PropertyInfo(Variant::INT, PNAME("mode"), PROPERTY_HINT_ENUM, "Spatial,CanvasItem,Particles"));
//render modes //render modes
Map<String, String> blend_mode_enums; Map<String, String> blend_mode_enums;
@ -1082,11 +1082,11 @@ void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
} }
for (Map<String, String>::Element *E = blend_mode_enums.front(); E; E = E->next()) { for (Map<String, String>::Element *E = blend_mode_enums.front(); E; E = E->next()) {
p_list->push_back(PropertyInfo(Variant::INT, "modes/" + E->key(), PROPERTY_HINT_ENUM, E->get())); p_list->push_back(PropertyInfo(Variant::INT, vformat("%s/%s", PNAME("modes"), E->key()), PROPERTY_HINT_ENUM, E->get()));
} }
for (Set<String>::Element *E = toggles.front(); E; E = E->next()) { for (Set<String>::Element *E = toggles.front(); E; E = E->next()) {
p_list->push_back(PropertyInfo(Variant::BOOL, "flags/" + E->get())); p_list->push_back(PropertyInfo(Variant::BOOL, vformat("%s/%s", PNAME("flags"), E->get())));
} }
for (int i = 0; i < TYPE_MAX; i++) { for (int i = 0; i < TYPE_MAX; i++) {

2
servers/physics_2d_server.cpp
View File

@ -738,7 +738,7 @@ Physics2DServer::~Physics2DServer() {
Vector<Physics2DServerManager::ClassInfo> Physics2DServerManager::physics_2d_servers; Vector<Physics2DServerManager::ClassInfo> Physics2DServerManager::physics_2d_servers;
int Physics2DServerManager::default_server_id = -1; int Physics2DServerManager::default_server_id = -1;
int Physics2DServerManager::default_server_priority = -1; int Physics2DServerManager::default_server_priority = -1;
const String Physics2DServerManager::setting_property_name("physics/2d/physics_engine"); const String Physics2DServerManager::setting_property_name(PNAME("physics/2d/physics_engine"));
void Physics2DServerManager::on_servers_changed() { void Physics2DServerManager::on_servers_changed() {
String physics_servers("DEFAULT"); String physics_servers("DEFAULT");

2
servers/physics_server.cpp
View File

@ -811,7 +811,7 @@ PhysicsServer::~PhysicsServer() {
Vector<PhysicsServerManager::ClassInfo> PhysicsServerManager::physics_servers; Vector<PhysicsServerManager::ClassInfo> PhysicsServerManager::physics_servers;
int PhysicsServerManager::default_server_id = -1; int PhysicsServerManager::default_server_id = -1;
int PhysicsServerManager::default_server_priority = -1; int PhysicsServerManager::default_server_priority = -1;
const String PhysicsServerManager::setting_property_name("physics/3d/physics_engine"); const String PhysicsServerManager::setting_property_name(PNAME("physics/3d/physics_engine"));
void PhysicsServerManager::on_servers_changed() { void PhysicsServerManager::on_servers_changed() {
String physics_servers2("DEFAULT"); String physics_servers2("DEFAULT");