Merge pull request #885 from Spartan322/merge/d09d82d

Merge commit godotengine/godot@d09d82d

19 files changed, 149 insertions, 47 deletions

diff --git a/core/core_constants.cpp b/core/core_constants.cpp
index d38559fe70..14defa9e7e 100644
--- a/core/core_constants.cpp
+++ b/core/core_constants.cpp
@@ -680,6 +680,7 @@ void register_global_constants() {
 	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_HIDE_QUATERNION_EDIT);
 	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_PASSWORD);
 	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_TOOL_BUTTON);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_ONESHOT);
 	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_MAX);
 
 	BIND_CORE_BITFIELD_FLAG(PROPERTY_USAGE_NONE);
diff --git a/core/io/file_access.cpp b/core/io/file_access.cpp
index acfd680a1e..6aaafb16d8 100644
--- a/core/io/file_access.cpp
+++ b/core/io/file_access.cpp
@@ -270,6 +270,10 @@ uint64_t FileAccess::get_64() const {
 	return data;
 }
 
+float FileAccess::get_half() const {
+	return Math::half_to_float(get_16());
+}
+
 float FileAccess::get_float() const {
 	MarshallFloat m;
 	m.i = get_32();
@@ -529,6 +533,10 @@ void FileAccess::store_real(real_t p_real) {
 	}
 }
 
+void FileAccess::store_half(float p_dest) {
+	store_16(Math::make_half_float(p_dest));
+}
+
 void FileAccess::store_float(float p_dest) {
 	MarshallFloat m;
 	m.f = p_dest;
@@ -835,6 +843,7 @@ void FileAccess::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_16"), &FileAccess::get_16);
 	ClassDB::bind_method(D_METHOD("get_32"), &FileAccess::get_32);
 	ClassDB::bind_method(D_METHOD("get_64"), &FileAccess::get_64);
+	ClassDB::bind_method(D_METHOD("get_half"), &FileAccess::get_half);
 	ClassDB::bind_method(D_METHOD("get_float"), &FileAccess::get_float);
 	ClassDB::bind_method(D_METHOD("get_double"), &FileAccess::get_double);
 	ClassDB::bind_method(D_METHOD("get_real"), &FileAccess::get_real);
@@ -853,6 +862,7 @@ void FileAccess::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("store_16", "value"), &FileAccess::store_16);
 	ClassDB::bind_method(D_METHOD("store_32", "value"), &FileAccess::store_32);
 	ClassDB::bind_method(D_METHOD("store_64", "value"), &FileAccess::store_64);
+	ClassDB::bind_method(D_METHOD("store_half", "value"), &FileAccess::store_half);
 	ClassDB::bind_method(D_METHOD("store_float", "value"), &FileAccess::store_float);
 	ClassDB::bind_method(D_METHOD("store_double", "value"), &FileAccess::store_double);
 	ClassDB::bind_method(D_METHOD("store_real", "value"), &FileAccess::store_real);
diff --git a/core/io/file_access.h b/core/io/file_access.h
index 20b5f26d9f..3cca8ba4f0 100644
--- a/core/io/file_access.h
+++ b/core/io/file_access.h
@@ -150,6 +150,7 @@ public:
 	virtual uint32_t get_32() const; ///< get 32 bits uint
 	virtual uint64_t get_64() const; ///< get 64 bits uint
 
+	virtual float get_half() const;
 	virtual float get_float() const;
 	virtual double get_double() const;
 	virtual real_t get_real() const;
@@ -181,6 +182,7 @@ public:
 	virtual void store_32(uint32_t p_dest); ///< store 32 bits uint
 	virtual void store_64(uint64_t p_dest); ///< store 64 bits uint
 
+	virtual void store_half(float p_dest);
 	virtual void store_float(float p_dest);
 	virtual void store_double(double p_dest);
 	virtual void store_real(real_t p_real);
diff --git a/core/io/marshalls.h b/core/io/marshalls.h
index 3da24b905f..399a1baf56 100644
--- a/core/io/marshalls.h
+++ b/core/io/marshalls.h
@@ -86,6 +86,12 @@ static inline unsigned int encode_uint32(uint32_t p_uint, uint8_t *p_arr) {
 	return sizeof(uint32_t);
 }
 
+static inline unsigned int encode_half(float p_float, uint8_t *p_arr) {
+	encode_uint16(Math::make_half_float(p_float), p_arr);
+
+	return sizeof(uint16_t);
+}
+
 static inline unsigned int encode_float(float p_float, uint8_t *p_arr) {
 	MarshallFloat mf;
 	mf.f = p_float;
@@ -174,6 +180,10 @@ static inline uint32_t decode_uint32(const uint8_t *p_arr) {
 	return u;
 }
 
+static inline float decode_half(const uint8_t *p_arr) {
+	return Math::half_to_float(decode_uint16(p_arr));
+}
+
 static inline float decode_float(const uint8_t *p_arr) {
 	MarshallFloat mf;
 	mf.i = decode_uint32(p_arr);
diff --git a/core/io/stream_peer.cpp b/core/io/stream_peer.cpp
index 2b5a44a27c..c5f35e9650 100644
--- a/core/io/stream_peer.cpp
+++ b/core/io/stream_peer.cpp
@@ -180,6 +180,18 @@ void StreamPeer::put_64(int64_t p_val) {
 	put_data(buf, 8);
 }
 
+void StreamPeer::put_half(float p_val) {
+	uint8_t buf[2];
+
+	encode_half(p_val, buf);
+	uint16_t *p16 = (uint16_t *)buf;
+	if (big_endian) {
+		*p16 = BSWAP16(*p16);
+	}
+
+	put_data(buf, 2);
+}
+
 void StreamPeer::put_float(float p_val) {
 	uint8_t buf[4];
 
@@ -296,6 +308,18 @@ int64_t StreamPeer::get_64() {
 	return r;
 }
 
+float StreamPeer::get_half() {
+	uint8_t buf[2];
+	get_data(buf, 2);
+
+	uint16_t *p16 = (uint16_t *)buf;
+	if (big_endian) {
+		*p16 = BSWAP16(*p16);
+	}
+
+	return decode_half(buf);
+}
+
 float StreamPeer::get_float() {
 	uint8_t buf[4];
 	get_data(buf, 4);
@@ -387,6 +411,7 @@ void StreamPeer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("put_u32", "value"), &StreamPeer::put_u32);
 	ClassDB::bind_method(D_METHOD("put_64", "value"), &StreamPeer::put_64);
 	ClassDB::bind_method(D_METHOD("put_u64", "value"), &StreamPeer::put_u64);
+	ClassDB::bind_method(D_METHOD("put_half", "value"), &StreamPeer::put_half);
 	ClassDB::bind_method(D_METHOD("put_float", "value"), &StreamPeer::put_float);
 	ClassDB::bind_method(D_METHOD("put_double", "value"), &StreamPeer::put_double);
 	ClassDB::bind_method(D_METHOD("put_string", "value"), &StreamPeer::put_string);
@@ -401,6 +426,7 @@ void StreamPeer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_u32"), &StreamPeer::get_u32);
 	ClassDB::bind_method(D_METHOD("get_64"), &StreamPeer::get_64);
 	ClassDB::bind_method(D_METHOD("get_u64"), &StreamPeer::get_u64);
+	ClassDB::bind_method(D_METHOD("get_half"), &StreamPeer::get_half);
 	ClassDB::bind_method(D_METHOD("get_float"), &StreamPeer::get_float);
 	ClassDB::bind_method(D_METHOD("get_double"), &StreamPeer::get_double);
 	ClassDB::bind_method(D_METHOD("get_string", "bytes"), &StreamPeer::get_string, DEFVAL(-1));
diff --git a/core/io/stream_peer.h b/core/io/stream_peer.h
index 682a6affa0..15d9ac97b9 100644
--- a/core/io/stream_peer.h
+++ b/core/io/stream_peer.h
@@ -75,6 +75,7 @@ public:
 	void put_u32(uint32_t p_val);
 	void put_64(int64_t p_val);
 	void put_u64(uint64_t p_val);
+	void put_half(float p_val);
 	void put_float(float p_val);
 	void put_double(double p_val);
 	void put_string(const String &p_string);
@@ -89,6 +90,7 @@ public:
 	int32_t get_32();
 	uint64_t get_u64();
 	int64_t get_64();
+	float get_half();
 	float get_float();
 	double get_double();
 	String get_string(int p_bytes = -1);
diff --git a/core/math/bvh_logic.inc b/core/math/bvh_logic.inc
index dd3b135bb5..aaa91bc9d3 100644
--- a/core/math/bvh_logic.inc
+++ b/core/math/bvh_logic.inc
@@ -1,4 +1,3 @@
-
 // for slow incremental optimization, we will periodically remove each
 // item from the tree and reinsert, to give it a chance to find a better position
 void _logic_item_remove_and_reinsert(uint32_t p_ref_id) {
diff --git a/core/math/bvh_misc.inc b/core/math/bvh_misc.inc
index 9b35a1d36d..ef1261a759 100644
--- a/core/math/bvh_misc.inc
+++ b/core/math/bvh_misc.inc
@@ -1,4 +1,3 @@
-
 int _handle_get_tree_id(BVHHandle p_handle) const {
 	if (USE_PAIRS) {
 		return _extra[p_handle.id()].tree_id;
diff --git a/core/math/bvh_structs.inc b/core/math/bvh_structs.inc
index d40c631ce2..6326cd63ef 100644
--- a/core/math/bvh_structs.inc
+++ b/core/math/bvh_structs.inc
@@ -1,4 +1,3 @@
-
 public:
 struct ItemRef {
 	uint32_t tnode_id; // -1 is invalid
diff --git a/core/math/vector4.cpp b/core/math/vector4.cpp
index 603446baf9..d3559760f5 100644
--- a/core/math/vector4.cpp
+++ b/core/math/vector4.cpp
@@ -215,7 +215,7 @@ Vector4 Vector4::clampf(real_t p_min, real_t p_max) const {
 }
 
 Vector4::operator String() const {
-	return "(" + String::num_real(x, false) + ", " + String::num_real(y, false) + ", " + String::num_real(z, false) + ", " + String::num_real(w, false) + ")";
+	return "(" + String::num_real(x, true) + ", " + String::num_real(y, true) + ", " + String::num_real(z, true) + ", " + String::num_real(w, true) + ")";
 }
 
 static_assert(sizeof(Vector4) == 4 * sizeof(real_t));
diff --git a/core/object/object.h b/core/object/object.h
index 308fdc2ab9..666537394a 100644
--- a/core/object/object.h
+++ b/core/object/object.h
@@ -90,6 +90,7 @@ enum PropertyHint {
 	PROPERTY_HINT_LAYERS_AVOIDANCE,
 	PROPERTY_HINT_DICTIONARY_TYPE,
 	PROPERTY_HINT_TOOL_BUTTON,
+	PROPERTY_HINT_ONESHOT, ///< the property will be changed by self after setting, such as AudioStreamPlayer.playing, Particles.emitting.
 	PROPERTY_HINT_MAX,
 };
 
diff --git a/core/object/worker_thread_pool.h b/core/object/worker_thread_pool.h
index 2d98b0eeb7..0f712c1f59 100644
--- a/core/object/worker_thread_pool.h
+++ b/core/object/worker_thread_pool.h
@@ -260,7 +260,13 @@ public:
 	bool is_group_task_completed(GroupID p_group) const;
 	void wait_for_group_task_completion(GroupID p_group);
 
-	_FORCE_INLINE_ int get_thread_count() const { return threads.size(); }
+	_FORCE_INLINE_ int get_thread_count() const {
+#ifdef THREADS_ENABLED
+		return threads.size();
+#else
+		return 1;
+#endif
+	}
 
 	static WorkerThreadPool *get_singleton() { return singleton; }
 	static int get_thread_index();
diff --git a/core/string/translation.cpp b/core/string/translation.cpp
index 095f56da38..e7230be8c1 100644
--- a/core/string/translation.cpp
+++ b/core/string/translation.cpp
@@ -82,8 +82,10 @@ void Translation::set_locale(const String &p_locale) {
 	if (Thread::is_main_thread()) {
 		_notify_translation_changed_if_applies();
 	} else {
-		// Avoid calling non-thread-safe functions here.
-		callable_mp(this, &Translation::_notify_translation_changed_if_applies).call_deferred();
+		// This has to happen on the main thread (bypassing the ResourceLoader per-thread call queue)
+		// because it interacts with the generally non-thread-safe window management, leading to
+		// different issues across platforms otherwise.
+		MessageQueue::get_main_singleton()->push_callable(callable_mp(this, &Translation::_notify_translation_changed_if_applies));
 	}
 }
 
diff --git a/core/string/translation_server.compat.inc b/core/string/translation_server.compat.inc
new file mode 100644
index 0000000000..e3eec6d48d
--- /dev/null
+++ b/core/string/translation_server.compat.inc
@@ -0,0 +1,43 @@
+/**************************************************************************/
+/*  translation_server.compat.inc                                         */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             REDOT ENGINE                               */
+/*                        https://redotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2024-present Redot Engine contributors                   */
+/*                                          (see REDOT_AUTHORS.md)        */
+/* 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.                 */
+/**************************************************************************/
+
+#ifndef DISABLE_DEPRECATED
+
+String TranslationServer::_standardize_locale_bind_compat_98972(const String &p_locale) const {
+	return standardize_locale(p_locale, false);
+}
+
+void TranslationServer::_bind_compatibility_methods() {
+	ClassDB::bind_compatibility_method(D_METHOD("standardize_locale", "locale"), &TranslationServer::_standardize_locale_bind_compat_98972);
+}
+
+#endif // DISABLE_DEPRECATED
diff --git a/core/string/translation_server.cpp b/core/string/translation_server.cpp
index f67ffa3d6e..e598e80ea0 100644
--- a/core/string/translation_server.cpp
+++ b/core/string/translation_server.cpp
@@ -31,6 +31,7 @@
 /**************************************************************************/
 
 #include "translation_server.h"
+#include "translation_server.compat.inc"
 
 #include "core/config/project_settings.h"
 #include "core/io/resource_loader.h"
@@ -220,8 +221,8 @@ TranslationServer::Locale::Locale(const TranslationServer &p_server, const Strin
 	}
 }
 
-String TranslationServer::standardize_locale(const String &p_locale) const {
-	return Locale(*this, p_locale, false).operator String();
+String TranslationServer::standardize_locale(const String &p_locale, bool p_add_defaults) const {
+	return Locale(*this, p_locale, p_add_defaults).operator String();
 }
 
 int TranslationServer::compare_locales(const String &p_locale_a, const String &p_locale_b) const {
@@ -593,7 +594,7 @@ void TranslationServer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_tool_locale"), &TranslationServer::get_tool_locale);
 
 	ClassDB::bind_method(D_METHOD("compare_locales", "locale_a", "locale_b"), &TranslationServer::compare_locales);
-	ClassDB::bind_method(D_METHOD("standardize_locale", "locale"), &TranslationServer::standardize_locale);
+	ClassDB::bind_method(D_METHOD("standardize_locale", "locale", "add_defaults"), &TranslationServer::standardize_locale, DEFVAL(false));
 
 	ClassDB::bind_method(D_METHOD("get_all_languages"), &TranslationServer::get_all_languages);
 	ClassDB::bind_method(D_METHOD("get_language_name", "language"), &TranslationServer::get_language_name);
diff --git a/core/string/translation_server.h b/core/string/translation_server.h
index 01974a4025..fd31a8dbac 100644
--- a/core/string/translation_server.h
+++ b/core/string/translation_server.h
@@ -54,10 +54,14 @@ class TranslationServer : public Object {
 
 	static inline TranslationServer *singleton = nullptr;
 	bool _load_translations(const String &p_from);
-	String _standardize_locale(const String &p_locale, bool p_add_defaults) const;
 
 	static void _bind_methods();
 
+#ifndef DISABLE_DEPRECATED
+	String _standardize_locale_bind_compat_98972(const String &p_locale) const;
+	static void _bind_compatibility_methods();
+#endif
+
 	struct LocaleScriptInfo {
 		String name;
 		String script;
@@ -131,7 +135,7 @@ public:
 	void set_pseudolocalization_enabled(bool p_enabled);
 	void reload_pseudolocalization();
 
-	String standardize_locale(const String &p_locale) const;
+	String standardize_locale(const String &p_locale, bool p_add_defaults = false) const;
 
 	int compare_locales(const String &p_locale_a, const String &p_locale_b) const;
 
diff --git a/core/variant/variant.cpp b/core/variant/variant.cpp
index 90cb722fd4..80b0bf82d0 100644
--- a/core/variant/variant.cpp
+++ b/core/variant/variant.cpp
@@ -3562,9 +3562,6 @@ bool Variant::is_ref_counted() const {
 	return type == OBJECT && _get_obj().id.is_ref_counted();
 }
 
-void Variant::static_assign(const Variant &p_variant) {
-}
-
 bool Variant::is_type_shared(Variant::Type p_type) {
 	switch (p_type) {
 		case OBJECT:
diff --git a/core/variant/variant.h b/core/variant/variant.h
index 9fd0472550..de0d763246 100644
--- a/core/variant/variant.h
+++ b/core/variant/variant.h
@@ -794,7 +794,6 @@ public:
 	String stringify(int recursion_count = 0) const;
 	String to_json_string() const;
 
-	void static_assign(const Variant &p_variant);
 	static void get_constants_for_type(Variant::Type p_type, List<StringName> *p_constants);
 	static int get_constants_count_for_type(Variant::Type p_type);
 	static bool has_constant(Variant::Type p_type, const StringName &p_value);
@@ -803,6 +802,8 @@ public:
 	static void get_enums_for_type(Variant::Type p_type, List<StringName> *p_enums);
 	static void get_enumerations_for_enum(Variant::Type p_type, const StringName &p_enum_name, List<StringName> *p_enumerations);
 	static int get_enum_value(Variant::Type p_type, const StringName &p_enum_name, const StringName &p_enumeration, bool *r_valid = nullptr);
+	static bool has_enum(Variant::Type p_type, const StringName &p_enum_name);
+	static StringName get_enum_for_enumeration(Variant::Type p_type, const StringName &p_enumeration);
 
 	typedef String (*ObjectDeConstruct)(const Variant &p_object, void *ud);
 	typedef void (*ObjectConstruct)(const String &p_text, void *ud, Variant &r_value);
diff --git a/core/variant/variant_call.cpp b/core/variant/variant_call.cpp
index 95c8550779..89ab7e20d6 100644
--- a/core/variant/variant_call.cpp
+++ b/core/variant/variant_call.cpp
@@ -1093,6 +1093,11 @@ struct _VariantCall {
 	static ConstantData *constant_data;
 
 	static void add_constant(int p_type, const StringName &p_constant_name, int64_t p_constant_value) {
+#ifdef DEBUG_ENABLED
+		ERR_FAIL_COND(constant_data[p_type].value.has(p_constant_name));
+		ERR_FAIL_COND(enum_data[p_type].value.has(p_constant_name));
+		ERR_FAIL_COND(enum_data[p_type].value_to_enum.has(p_constant_name));
+#endif
 		constant_data[p_type].value[p_constant_name] = p_constant_value;
 #ifdef DEBUG_ENABLED
 		constant_data[p_type].value_ordered.push_back(p_constant_name);
@@ -1108,12 +1113,19 @@ struct _VariantCall {
 
 	struct EnumData {
 		HashMap<StringName, HashMap<StringName, int>> value;
+		HashMap<StringName, StringName> value_to_enum;
 	};
 
 	static EnumData *enum_data;
 
 	static void add_enum_constant(int p_type, const StringName &p_enum_type_name, const StringName &p_enumeration_name, int p_enum_value) {
+#ifdef DEBUG_ENABLED
+		ERR_FAIL_COND(constant_data[p_type].value.has(p_enumeration_name));
+		ERR_FAIL_COND(enum_data[p_type].value.has(p_enumeration_name));
+		ERR_FAIL_COND(enum_data[p_type].value_to_enum.has(p_enumeration_name));
+#endif
 		enum_data[p_type].value[p_enum_type_name][p_enumeration_name] = p_enum_value;
+		enum_data[p_type].value_to_enum[p_enumeration_name] = p_enum_type_name;
 	}
 };
 
@@ -1563,6 +1575,23 @@ int Variant::get_enum_value(Variant::Type p_type, const StringName &p_enum_name,
 	return V->value;
 }
 
+bool Variant::has_enum(Variant::Type p_type, const StringName &p_enum_name) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
+
+	_VariantCall::EnumData &enum_data = _VariantCall::enum_data[p_type];
+
+	return enum_data.value.has(p_enum_name);
+}
+
+StringName Variant::get_enum_for_enumeration(Variant::Type p_type, const StringName &p_enumeration) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, StringName());
+
+	_VariantCall::EnumData &enum_data = _VariantCall::enum_data[p_type];
+
+	const StringName *enum_name = enum_data.value_to_enum.getptr(p_enumeration);
+	return (enum_name == nullptr) ? StringName() : *enum_name;
+}
+
 #ifdef DEBUG_METHODS_ENABLED
 #define bind_method(m_type, m_method, m_arg_names, m_default_args) \
 	METHOD_CLASS(m_type, m_method, &m_type::m_method);             \
@@ -2662,10 +2691,6 @@ static void _register_variant_builtin_constants() {
 		_VariantCall::add_variant_constant(Variant::COLOR, Color::get_named_color_name(i), Color::get_named_color(i));
 	}
 
-	_VariantCall::add_constant(Variant::VECTOR3, "AXIS_X", Vector3::AXIS_X);
-	_VariantCall::add_constant(Variant::VECTOR3, "AXIS_Y", Vector3::AXIS_Y);
-	_VariantCall::add_constant(Variant::VECTOR3, "AXIS_Z", Vector3::AXIS_Z);
-
 	_VariantCall::add_enum_constant(Variant::VECTOR3, "Axis", "AXIS_X", Vector3::AXIS_X);
 	_VariantCall::add_enum_constant(Variant::VECTOR3, "Axis", "AXIS_Y", Vector3::AXIS_Y);
 	_VariantCall::add_enum_constant(Variant::VECTOR3, "Axis", "AXIS_Z", Vector3::AXIS_Z);
@@ -2687,32 +2712,19 @@ static void _register_variant_builtin_constants() {
 	_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_FRONT", Vector3(0, 0, 1));
 	_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_REAR", Vector3(0, 0, -1));
 
-	_VariantCall::add_constant(Variant::VECTOR4, "AXIS_X", Vector4::AXIS_X);
-	_VariantCall::add_constant(Variant::VECTOR4, "AXIS_Y", Vector4::AXIS_Y);
-	_VariantCall::add_constant(Variant::VECTOR4, "AXIS_Z", Vector4::AXIS_Z);
-	_VariantCall::add_constant(Variant::VECTOR4, "AXIS_W", Vector4::AXIS_W);
-
 	_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_X", Vector4::AXIS_X);
 	_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_Y", Vector4::AXIS_Y);
 	_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_Z", Vector4::AXIS_Z);
 	_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_W", Vector4::AXIS_W);
+
 	_VariantCall::add_variant_constant(Variant::VECTOR4, "ZERO", Vector4(0, 0, 0, 0));
 	_VariantCall::add_variant_constant(Variant::VECTOR4, "ONE", Vector4(1, 1, 1, 1));
 	_VariantCall::add_variant_constant(Variant::VECTOR4, "INF", Vector4(INFINITY, INFINITY, INFINITY, INFINITY));
 
-	_VariantCall::add_constant(Variant::VECTOR3I, "AXIS_X", Vector3i::AXIS_X);
-	_VariantCall::add_constant(Variant::VECTOR3I, "AXIS_Y", Vector3i::AXIS_Y);
-	_VariantCall::add_constant(Variant::VECTOR3I, "AXIS_Z", Vector3i::AXIS_Z);
-
 	_VariantCall::add_enum_constant(Variant::VECTOR3I, "Axis", "AXIS_X", Vector3i::AXIS_X);
 	_VariantCall::add_enum_constant(Variant::VECTOR3I, "Axis", "AXIS_Y", Vector3i::AXIS_Y);
 	_VariantCall::add_enum_constant(Variant::VECTOR3I, "Axis", "AXIS_Z", Vector3i::AXIS_Z);
 
-	_VariantCall::add_constant(Variant::VECTOR4I, "AXIS_X", Vector4i::AXIS_X);
-	_VariantCall::add_constant(Variant::VECTOR4I, "AXIS_Y", Vector4i::AXIS_Y);
-	_VariantCall::add_constant(Variant::VECTOR4I, "AXIS_Z", Vector4i::AXIS_Z);
-	_VariantCall::add_constant(Variant::VECTOR4I, "AXIS_W", Vector4i::AXIS_W);
-
 	_VariantCall::add_enum_constant(Variant::VECTOR4I, "Axis", "AXIS_X", Vector4i::AXIS_X);
 	_VariantCall::add_enum_constant(Variant::VECTOR4I, "Axis", "AXIS_Y", Vector4i::AXIS_Y);
 	_VariantCall::add_enum_constant(Variant::VECTOR4I, "Axis", "AXIS_Z", Vector4i::AXIS_Z);
@@ -2734,15 +2746,9 @@ static void _register_variant_builtin_constants() {
 	_VariantCall::add_variant_constant(Variant::VECTOR3I, "FORWARD", Vector3i(0, 0, -1));
 	_VariantCall::add_variant_constant(Variant::VECTOR3I, "BACK", Vector3i(0, 0, 1));
 
-	_VariantCall::add_constant(Variant::VECTOR2, "AXIS_X", Vector2::AXIS_X);
-	_VariantCall::add_constant(Variant::VECTOR2, "AXIS_Y", Vector2::AXIS_Y);
-
 	_VariantCall::add_enum_constant(Variant::VECTOR2, "Axis", "AXIS_X", Vector2::AXIS_X);
 	_VariantCall::add_enum_constant(Variant::VECTOR2, "Axis", "AXIS_Y", Vector2::AXIS_Y);
 
-	_VariantCall::add_constant(Variant::VECTOR2I, "AXIS_X", Vector2i::AXIS_X);
-	_VariantCall::add_constant(Variant::VECTOR2I, "AXIS_Y", Vector2i::AXIS_Y);
-
 	_VariantCall::add_enum_constant(Variant::VECTOR2I, "Axis", "AXIS_X", Vector2i::AXIS_X);
 	_VariantCall::add_enum_constant(Variant::VECTOR2I, "Axis", "AXIS_Y", Vector2i::AXIS_Y);
 
@@ -2791,13 +2797,6 @@ static void _register_variant_builtin_constants() {
 
 	_VariantCall::add_variant_constant(Variant::QUATERNION, "IDENTITY", Quaternion(0, 0, 0, 1));
 
-	_VariantCall::add_constant(Variant::PROJECTION, "PLANE_NEAR", Projection::PLANE_NEAR);
-	_VariantCall::add_constant(Variant::PROJECTION, "PLANE_FAR", Projection::PLANE_FAR);
-	_VariantCall::add_constant(Variant::PROJECTION, "PLANE_LEFT", Projection::PLANE_LEFT);
-	_VariantCall::add_constant(Variant::PROJECTION, "PLANE_TOP", Projection::PLANE_TOP);
-	_VariantCall::add_constant(Variant::PROJECTION, "PLANE_RIGHT", Projection::PLANE_RIGHT);
-	_VariantCall::add_constant(Variant::PROJECTION, "PLANE_BOTTOM", Projection::PLANE_BOTTOM);
-
 	_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_NEAR", Projection::PLANE_NEAR);
 	_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_FAR", Projection::PLANE_FAR);
 	_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_LEFT", Projection::PLANE_LEFT);