238 files changed, 8003 insertions, 6739 deletions

diff --git a/core/SCsub b/core/SCsub
index b9f06d12ae..78a4395619 100644
--- a/core/SCsub
+++ b/core/SCsub
@@ -34,7 +34,7 @@ if "SCRIPT_AES256_ENCRYPTION_KEY" in os.environ:
 
 # NOTE: It is safe to generate this file here, since this is still executed serially
 with open("script_encryption_key.gen.cpp", "w") as f:
-    f.write('#include "core/project_settings.h"\nuint8_t script_encryption_key[32]={' + txt + "};\n")
+    f.write('#include "core/config/project_settings.h"\nuint8_t script_encryption_key[32]={' + txt + "};\n")
 
 
 # Add required thirdparty code.
@@ -174,7 +174,12 @@ SConscript("crypto/SCsub")
 SConscript("io/SCsub")
 SConscript("debugger/SCsub")
 SConscript("input/SCsub")
-SConscript("bind/SCsub")
+SConscript("variant/SCsub")
+SConscript("object/SCsub")
+SConscript("templates/SCsub")
+SConscript("string/SCsub")
+SConscript("config/SCsub")
+SConscript("error/SCsub")
 
 
 # Build it all as a library
diff --git a/core/bind/SCsub b/core/bind/SCsub
deleted file mode 100644
index 19a6549225..0000000000
--- a/core/bind/SCsub
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-
-Import("env")
-
-env.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/color_names.inc b/core/color_names.inc
deleted file mode 100644
index 2b50d88b02..0000000000
--- a/core/color_names.inc
+++ /dev/null
@@ -1,155 +0,0 @@
-// Names from https://en.wikipedia.org/wiki/X11_color_names
-#include "core/map.h"
-
-static Map<String, Color> _named_colors;
-static void _populate_named_colors() {
-	if (!_named_colors.empty()) {
-		return;
-	}
-	_named_colors.insert("aliceblue", Color(0.94, 0.97, 1.00));
-	_named_colors.insert("antiquewhite", Color(0.98, 0.92, 0.84));
-	_named_colors.insert("aqua", Color(0.00, 1.00, 1.00));
-	_named_colors.insert("aquamarine", Color(0.50, 1.00, 0.83));
-	_named_colors.insert("azure", Color(0.94, 1.00, 1.00));
-	_named_colors.insert("beige", Color(0.96, 0.96, 0.86));
-	_named_colors.insert("bisque", Color(1.00, 0.89, 0.77));
-	_named_colors.insert("black", Color(0.00, 0.00, 0.00));
-	_named_colors.insert("blanchedalmond", Color(1.00, 0.92, 0.80));
-	_named_colors.insert("blue", Color(0.00, 0.00, 1.00));
-	_named_colors.insert("blueviolet", Color(0.54, 0.17, 0.89));
-	_named_colors.insert("brown", Color(0.65, 0.16, 0.16));
-	_named_colors.insert("burlywood", Color(0.87, 0.72, 0.53));
-	_named_colors.insert("cadetblue", Color(0.37, 0.62, 0.63));
-	_named_colors.insert("chartreuse", Color(0.50, 1.00, 0.00));
-	_named_colors.insert("chocolate", Color(0.82, 0.41, 0.12));
-	_named_colors.insert("coral", Color(1.00, 0.50, 0.31));
-	_named_colors.insert("cornflower", Color(0.39, 0.58, 0.93));
-	_named_colors.insert("cornsilk", Color(1.00, 0.97, 0.86));
-	_named_colors.insert("crimson", Color(0.86, 0.08, 0.24));
-	_named_colors.insert("cyan", Color(0.00, 1.00, 1.00));
-	_named_colors.insert("darkblue", Color(0.00, 0.00, 0.55));
-	_named_colors.insert("darkcyan", Color(0.00, 0.55, 0.55));
-	_named_colors.insert("darkgoldenrod", Color(0.72, 0.53, 0.04));
-	_named_colors.insert("darkgray", Color(0.66, 0.66, 0.66));
-	_named_colors.insert("darkgreen", Color(0.00, 0.39, 0.00));
-	_named_colors.insert("darkkhaki", Color(0.74, 0.72, 0.42));
-	_named_colors.insert("darkmagenta", Color(0.55, 0.00, 0.55));
-	_named_colors.insert("darkolivegreen", Color(0.33, 0.42, 0.18));
-	_named_colors.insert("darkorange", Color(1.00, 0.55, 0.00));
-	_named_colors.insert("darkorchid", Color(0.60, 0.20, 0.80));
-	_named_colors.insert("darkred", Color(0.55, 0.00, 0.00));
-	_named_colors.insert("darksalmon", Color(0.91, 0.59, 0.48));
-	_named_colors.insert("darkseagreen", Color(0.56, 0.74, 0.56));
-	_named_colors.insert("darkslateblue", Color(0.28, 0.24, 0.55));
-	_named_colors.insert("darkslategray", Color(0.18, 0.31, 0.31));
-	_named_colors.insert("darkturquoise", Color(0.00, 0.81, 0.82));
-	_named_colors.insert("darkviolet", Color(0.58, 0.00, 0.83));
-	_named_colors.insert("deeppink", Color(1.00, 0.08, 0.58));
-	_named_colors.insert("deepskyblue", Color(0.00, 0.75, 1.00));
-	_named_colors.insert("dimgray", Color(0.41, 0.41, 0.41));
-	_named_colors.insert("dodgerblue", Color(0.12, 0.56, 1.00));
-	_named_colors.insert("firebrick", Color(0.70, 0.13, 0.13));
-	_named_colors.insert("floralwhite", Color(1.00, 0.98, 0.94));
-	_named_colors.insert("forestgreen", Color(0.13, 0.55, 0.13));
-	_named_colors.insert("fuchsia", Color(1.00, 0.00, 1.00));
-	_named_colors.insert("gainsboro", Color(0.86, 0.86, 0.86));
-	_named_colors.insert("ghostwhite", Color(0.97, 0.97, 1.00));
-	_named_colors.insert("gold", Color(1.00, 0.84, 0.00));
-	_named_colors.insert("goldenrod", Color(0.85, 0.65, 0.13));
-	_named_colors.insert("gray", Color(0.75, 0.75, 0.75));
-	_named_colors.insert("webgray", Color(0.50, 0.50, 0.50));
-	_named_colors.insert("green", Color(0.00, 1.00, 0.00));
-	_named_colors.insert("webgreen", Color(0.00, 0.50, 0.00));
-	_named_colors.insert("greenyellow", Color(0.68, 1.00, 0.18));
-	_named_colors.insert("honeydew", Color(0.94, 1.00, 0.94));
-	_named_colors.insert("hotpink", Color(1.00, 0.41, 0.71));
-	_named_colors.insert("indianred", Color(0.80, 0.36, 0.36));
-	_named_colors.insert("indigo", Color(0.29, 0.00, 0.51));
-	_named_colors.insert("ivory", Color(1.00, 1.00, 0.94));
-	_named_colors.insert("khaki", Color(0.94, 0.90, 0.55));
-	_named_colors.insert("lavender", Color(0.90, 0.90, 0.98));
-	_named_colors.insert("lavenderblush", Color(1.00, 0.94, 0.96));
-	_named_colors.insert("lawngreen", Color(0.49, 0.99, 0.00));
-	_named_colors.insert("lemonchiffon", Color(1.00, 0.98, 0.80));
-	_named_colors.insert("lightblue", Color(0.68, 0.85, 0.90));
-	_named_colors.insert("lightcoral", Color(0.94, 0.50, 0.50));
-	_named_colors.insert("lightcyan", Color(0.88, 1.00, 1.00));
-	_named_colors.insert("lightgoldenrod", Color(0.98, 0.98, 0.82));
-	_named_colors.insert("lightgray", Color(0.83, 0.83, 0.83));
-	_named_colors.insert("lightgreen", Color(0.56, 0.93, 0.56));
-	_named_colors.insert("lightpink", Color(1.00, 0.71, 0.76));
-	_named_colors.insert("lightsalmon", Color(1.00, 0.63, 0.48));
-	_named_colors.insert("lightseagreen", Color(0.13, 0.70, 0.67));
-	_named_colors.insert("lightskyblue", Color(0.53, 0.81, 0.98));
-	_named_colors.insert("lightslategray", Color(0.47, 0.53, 0.60));
-	_named_colors.insert("lightsteelblue", Color(0.69, 0.77, 0.87));
-	_named_colors.insert("lightyellow", Color(1.00, 1.00, 0.88));
-	_named_colors.insert("lime", Color(0.00, 1.00, 0.00));
-	_named_colors.insert("limegreen", Color(0.20, 0.80, 0.20));
-	_named_colors.insert("linen", Color(0.98, 0.94, 0.90));
-	_named_colors.insert("magenta", Color(1.00, 0.00, 1.00));
-	_named_colors.insert("maroon", Color(0.69, 0.19, 0.38));
-	_named_colors.insert("webmaroon", Color(0.50, 0.00, 0.00));
-	_named_colors.insert("mediumaquamarine", Color(0.40, 0.80, 0.67));
-	_named_colors.insert("mediumblue", Color(0.00, 0.00, 0.80));
-	_named_colors.insert("mediumorchid", Color(0.73, 0.33, 0.83));
-	_named_colors.insert("mediumpurple", Color(0.58, 0.44, 0.86));
-	_named_colors.insert("mediumseagreen", Color(0.24, 0.70, 0.44));
-	_named_colors.insert("mediumslateblue", Color(0.48, 0.41, 0.93));
-	_named_colors.insert("mediumspringgreen", Color(0.00, 0.98, 0.60));
-	_named_colors.insert("mediumturquoise", Color(0.28, 0.82, 0.80));
-	_named_colors.insert("mediumvioletred", Color(0.78, 0.08, 0.52));
-	_named_colors.insert("midnightblue", Color(0.10, 0.10, 0.44));
-	_named_colors.insert("mintcream", Color(0.96, 1.00, 0.98));
-	_named_colors.insert("mistyrose", Color(1.00, 0.89, 0.88));
-	_named_colors.insert("moccasin", Color(1.00, 0.89, 0.71));
-	_named_colors.insert("navajowhite", Color(1.00, 0.87, 0.68));
-	_named_colors.insert("navyblue", Color(0.00, 0.00, 0.50));
-	_named_colors.insert("oldlace", Color(0.99, 0.96, 0.90));
-	_named_colors.insert("olive", Color(0.50, 0.50, 0.00));
-	_named_colors.insert("olivedrab", Color(0.42, 0.56, 0.14));
-	_named_colors.insert("orange", Color(1.00, 0.65, 0.00));
-	_named_colors.insert("orangered", Color(1.00, 0.27, 0.00));
-	_named_colors.insert("orchid", Color(0.85, 0.44, 0.84));
-	_named_colors.insert("palegoldenrod", Color(0.93, 0.91, 0.67));
-	_named_colors.insert("palegreen", Color(0.60, 0.98, 0.60));
-	_named_colors.insert("paleturquoise", Color(0.69, 0.93, 0.93));
-	_named_colors.insert("palevioletred", Color(0.86, 0.44, 0.58));
-	_named_colors.insert("papayawhip", Color(1.00, 0.94, 0.84));
-	_named_colors.insert("peachpuff", Color(1.00, 0.85, 0.73));
-	_named_colors.insert("peru", Color(0.80, 0.52, 0.25));
-	_named_colors.insert("pink", Color(1.00, 0.75, 0.80));
-	_named_colors.insert("plum", Color(0.87, 0.63, 0.87));
-	_named_colors.insert("powderblue", Color(0.69, 0.88, 0.90));
-	_named_colors.insert("purple", Color(0.63, 0.13, 0.94));
-	_named_colors.insert("webpurple", Color(0.50, 0.00, 0.50));
-	_named_colors.insert("rebeccapurple", Color(0.40, 0.20, 0.60));
-	_named_colors.insert("red", Color(1.00, 0.00, 0.00));
-	_named_colors.insert("rosybrown", Color(0.74, 0.56, 0.56));
-	_named_colors.insert("royalblue", Color(0.25, 0.41, 0.88));
-	_named_colors.insert("saddlebrown", Color(0.55, 0.27, 0.07));
-	_named_colors.insert("salmon", Color(0.98, 0.50, 0.45));
-	_named_colors.insert("sandybrown", Color(0.96, 0.64, 0.38));
-	_named_colors.insert("seagreen", Color(0.18, 0.55, 0.34));
-	_named_colors.insert("seashell", Color(1.00, 0.96, 0.93));
-	_named_colors.insert("sienna", Color(0.63, 0.32, 0.18));
-	_named_colors.insert("silver", Color(0.75, 0.75, 0.75));
-	_named_colors.insert("skyblue", Color(0.53, 0.81, 0.92));
-	_named_colors.insert("slateblue", Color(0.42, 0.35, 0.80));
-	_named_colors.insert("slategray", Color(0.44, 0.50, 0.56));
-	_named_colors.insert("snow", Color(1.00, 0.98, 0.98));
-	_named_colors.insert("springgreen", Color(0.00, 1.00, 0.50));
-	_named_colors.insert("steelblue", Color(0.27, 0.51, 0.71));
-	_named_colors.insert("tan", Color(0.82, 0.71, 0.55));
-	_named_colors.insert("teal", Color(0.00, 0.50, 0.50));
-	_named_colors.insert("thistle", Color(0.85, 0.75, 0.85));
-	_named_colors.insert("tomato", Color(1.00, 0.39, 0.28));
-	_named_colors.insert("turquoise", Color(0.25, 0.88, 0.82));
-	_named_colors.insert("transparent", Color(1.00, 1.00, 1.00, 0.00));
-	_named_colors.insert("violet", Color(0.93, 0.51, 0.93));
-	_named_colors.insert("wheat", Color(0.96, 0.87, 0.70));
-	_named_colors.insert("white", Color(1.00, 1.00, 1.00));
-	_named_colors.insert("whitesmoke", Color(0.96, 0.96, 0.96));
-	_named_colors.insert("yellow", Color(1.00, 1.00, 0.00));
-	_named_colors.insert("yellowgreen", Color(0.60, 0.80, 0.20));
-}
diff --git a/core/config/SCsub b/core/config/SCsub
new file mode 100644
index 0000000000..bf70285490
--- /dev/null
+++ b/core/config/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env_config = env.Clone()
+
+env_config.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/engine.cpp b/core/config/engine.cpp
index b0037ffb37..b0037ffb37 100644
--- a/core/engine.cpp
+++ b/core/config/engine.cpp
diff --git a/core/engine.h b/core/config/engine.h
index b581c58ec5..1d3d963b39 100644
--- a/core/engine.h
+++ b/core/config/engine.h
@@ -31,10 +31,10 @@
 #ifndef ENGINE_H
 #define ENGINE_H
 
-#include "core/list.h"
 #include "core/os/main_loop.h"
-#include "core/ustring.h"
-#include "core/vector.h"
+#include "core/string/ustring.h"
+#include "core/templates/list.h"
+#include "core/templates/vector.h"
 
 class Engine {
 public:
diff --git a/core/project_settings.cpp b/core/config/project_settings.cpp
index 3829474626..aa954ed300 100644
--- a/core/project_settings.cpp
+++ b/core/config/project_settings.cpp
@@ -30,7 +30,7 @@
 
 #include "project_settings.h"
 
-#include "core/bind/core_bind.h"
+#include "core/core_bind.h"
 #include "core/core_string_names.h"
 #include "core/io/file_access_network.h"
 #include "core/io/file_access_pack.h"
@@ -39,7 +39,7 @@
 #include "core/os/file_access.h"
 #include "core/os/keyboard.h"
 #include "core/os/os.h"
-#include "core/variant_parser.h"
+#include "core/variant/variant_parser.h"
 
 #include <zlib.h>
 
diff --git a/core/project_settings.h b/core/config/project_settings.h
index 9a1d9cee97..a8c9adc587 100644
--- a/core/project_settings.h
+++ b/core/config/project_settings.h
@@ -31,9 +31,9 @@
 #ifndef PROJECT_SETTINGS_H
 #define PROJECT_SETTINGS_H
 
-#include "core/class_db.h"
+#include "core/object/class_db.h"
 #include "core/os/thread_safe.h"
-#include "core/set.h"
+#include "core/templates/set.h"
 
 class ProjectSettings : public Object {
 	GDCLASS(ProjectSettings, Object);
diff --git a/core/bind/core_bind.cpp b/core/core_bind.cpp
index baf5d4b928..f3bdea1eec 100644
--- a/core/bind/core_bind.cpp
+++ b/core/core_bind.cpp
@@ -30,6 +30,7 @@
 
 #include "core_bind.h"
 
+#include "core/config/project_settings.h"
 #include "core/crypto/crypto_core.h"
 #include "core/debugger/engine_debugger.h"
 #include "core/io/file_access_compressed.h"
@@ -40,7 +41,6 @@
 #include "core/math/geometry_3d.h"
 #include "core/os/keyboard.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 /**
  *  Time constants borrowed from loc_time.h
diff --git a/core/bind/core_bind.h b/core/core_bind.h
index e75e740cd5..7794750387 100644
--- a/core/bind/core_bind.h
+++ b/core/core_bind.h
@@ -31,8 +31,8 @@
 #ifndef CORE_BIND_H
 #define CORE_BIND_H
 
-#include "core/image.h"
 #include "core/io/compression.h"
+#include "core/io/image.h"
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
 #include "core/os/dir_access.h"
diff --git a/core/core_constants.cpp b/core/core_constants.cpp
new file mode 100644
index 0000000000..4229436e84
--- /dev/null
+++ b/core/core_constants.cpp
@@ -0,0 +1,690 @@
+/*************************************************************************/
+/*  core_constants.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "core_constants.h"
+
+#include "core/input/input_event.h"
+#include "core/object/class_db.h"
+#include "core/os/keyboard.h"
+#include "core/variant/variant.h"
+
+struct _CoreConstant {
+#ifdef DEBUG_METHODS_ENABLED
+	StringName enum_name;
+	bool ignore_value_in_docs;
+#endif
+	const char *name;
+	int value;
+
+	_CoreConstant() {}
+
+#ifdef DEBUG_METHODS_ENABLED
+	_CoreConstant(const StringName &p_enum_name, const char *p_name, int p_value, bool p_ignore_value_in_docs = false) :
+			enum_name(p_enum_name),
+			ignore_value_in_docs(p_ignore_value_in_docs),
+			name(p_name),
+			value(p_value) {
+	}
+#else
+	_CoreConstant(const char *p_name, int p_value) :
+			name(p_name),
+			value(p_value) {
+	}
+#endif
+};
+
+static Vector<_CoreConstant> _global_constants;
+
+#ifdef DEBUG_METHODS_ENABLED
+
+#define BIND_CORE_CONSTANT(m_constant) \
+	_global_constants.push_back(_CoreConstant(StringName(), #m_constant, m_constant));
+
+#define BIND_CORE_ENUM_CONSTANT(m_constant) \
+	_global_constants.push_back(_CoreConstant(__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant));
+
+#define BIND_CORE_ENUM_CONSTANT_CUSTOM(m_custom_name, m_constant) \
+	_global_constants.push_back(_CoreConstant(__constant_get_enum_name(m_constant, #m_constant), m_custom_name, m_constant));
+
+#define BIND_CORE_CONSTANT_NO_VAL(m_constant) \
+	_global_constants.push_back(_CoreConstant(StringName(), #m_constant, m_constant, true));
+
+#define BIND_CORE_ENUM_CONSTANT_NO_VAL(m_constant) \
+	_global_constants.push_back(_CoreConstant(__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant, true));
+
+#define BIND_CORE_ENUM_CONSTANT_CUSTOM_NO_VAL(m_custom_name, m_constant) \
+	_global_constants.push_back(_CoreConstant(__constant_get_enum_name(m_constant, #m_constant), m_custom_name, m_constant, true));
+
+#else
+
+#define BIND_CORE_CONSTANT(m_constant) \
+	_global_constants.push_back(_CoreConstant(#m_constant, m_constant));
+
+#define BIND_CORE_ENUM_CONSTANT(m_constant) \
+	_global_constants.push_back(_CoreConstant(#m_constant, m_constant));
+
+#define BIND_CORE_ENUM_CONSTANT_CUSTOM(m_custom_name, m_constant) \
+	_global_constants.push_back(_CoreConstant(m_custom_name, m_constant));
+
+#define BIND_CORE_CONSTANT_NO_VAL(m_constant) \
+	_global_constants.push_back(_CoreConstant(#m_constant, m_constant));
+
+#define BIND_CORE_ENUM_CONSTANT_NO_VAL(m_constant) \
+	_global_constants.push_back(_CoreConstant(#m_constant, m_constant));
+
+#define BIND_CORE_ENUM_CONSTANT_CUSTOM_NO_VAL(m_custom_name, m_constant) \
+	_global_constants.push_back(_CoreConstant(m_custom_name, m_constant));
+
+#endif
+
+VARIANT_ENUM_CAST(KeyList);
+VARIANT_ENUM_CAST(KeyModifierMask);
+VARIANT_ENUM_CAST(ButtonList);
+VARIANT_ENUM_CAST(JoyButtonList);
+VARIANT_ENUM_CAST(JoyAxisList);
+VARIANT_ENUM_CAST(MidiMessageList);
+
+void register_global_constants() {
+	BIND_CORE_ENUM_CONSTANT(MARGIN_LEFT);
+	BIND_CORE_ENUM_CONSTANT(MARGIN_TOP);
+	BIND_CORE_ENUM_CONSTANT(MARGIN_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(MARGIN_BOTTOM);
+
+	BIND_CORE_ENUM_CONSTANT(CORNER_TOP_LEFT);
+	BIND_CORE_ENUM_CONSTANT(CORNER_TOP_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(CORNER_BOTTOM_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(CORNER_BOTTOM_LEFT);
+
+	BIND_CORE_ENUM_CONSTANT(VERTICAL);
+	BIND_CORE_ENUM_CONSTANT(HORIZONTAL);
+
+	BIND_CORE_ENUM_CONSTANT(HALIGN_LEFT);
+	BIND_CORE_ENUM_CONSTANT(HALIGN_CENTER);
+	BIND_CORE_ENUM_CONSTANT(HALIGN_RIGHT);
+
+	BIND_CORE_ENUM_CONSTANT(VALIGN_TOP);
+	BIND_CORE_ENUM_CONSTANT(VALIGN_CENTER);
+	BIND_CORE_ENUM_CONSTANT(VALIGN_BOTTOM);
+
+	// huge list of keys
+	BIND_CORE_CONSTANT(SPKEY);
+
+	BIND_CORE_ENUM_CONSTANT(KEY_ESCAPE);
+	BIND_CORE_ENUM_CONSTANT(KEY_TAB);
+	BIND_CORE_ENUM_CONSTANT(KEY_BACKTAB);
+	BIND_CORE_ENUM_CONSTANT(KEY_BACKSPACE);
+	BIND_CORE_ENUM_CONSTANT(KEY_ENTER);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_ENTER);
+	BIND_CORE_ENUM_CONSTANT(KEY_INSERT);
+	BIND_CORE_ENUM_CONSTANT(KEY_DELETE);
+	BIND_CORE_ENUM_CONSTANT(KEY_PAUSE);
+	BIND_CORE_ENUM_CONSTANT(KEY_PRINT);
+	BIND_CORE_ENUM_CONSTANT(KEY_SYSREQ);
+	BIND_CORE_ENUM_CONSTANT(KEY_CLEAR);
+	BIND_CORE_ENUM_CONSTANT(KEY_HOME);
+	BIND_CORE_ENUM_CONSTANT(KEY_END);
+	BIND_CORE_ENUM_CONSTANT(KEY_LEFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_UP);
+	BIND_CORE_ENUM_CONSTANT(KEY_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(KEY_DOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_PAGEUP);
+	BIND_CORE_ENUM_CONSTANT(KEY_PAGEDOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_SHIFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_CONTROL);
+	BIND_CORE_ENUM_CONSTANT(KEY_META);
+	BIND_CORE_ENUM_CONSTANT(KEY_ALT);
+	BIND_CORE_ENUM_CONSTANT(KEY_CAPSLOCK);
+	BIND_CORE_ENUM_CONSTANT(KEY_NUMLOCK);
+	BIND_CORE_ENUM_CONSTANT(KEY_SCROLLLOCK);
+	BIND_CORE_ENUM_CONSTANT(KEY_F1);
+	BIND_CORE_ENUM_CONSTANT(KEY_F2);
+	BIND_CORE_ENUM_CONSTANT(KEY_F3);
+	BIND_CORE_ENUM_CONSTANT(KEY_F4);
+	BIND_CORE_ENUM_CONSTANT(KEY_F5);
+	BIND_CORE_ENUM_CONSTANT(KEY_F6);
+	BIND_CORE_ENUM_CONSTANT(KEY_F7);
+	BIND_CORE_ENUM_CONSTANT(KEY_F8);
+	BIND_CORE_ENUM_CONSTANT(KEY_F9);
+	BIND_CORE_ENUM_CONSTANT(KEY_F10);
+	BIND_CORE_ENUM_CONSTANT(KEY_F11);
+	BIND_CORE_ENUM_CONSTANT(KEY_F12);
+	BIND_CORE_ENUM_CONSTANT(KEY_F13);
+	BIND_CORE_ENUM_CONSTANT(KEY_F14);
+	BIND_CORE_ENUM_CONSTANT(KEY_F15);
+	BIND_CORE_ENUM_CONSTANT(KEY_F16);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_MULTIPLY);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_DIVIDE);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_SUBTRACT);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_PERIOD);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_ADD);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_0);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_1);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_2);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_3);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_4);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_5);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_6);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_7);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_8);
+	BIND_CORE_ENUM_CONSTANT(KEY_KP_9);
+	BIND_CORE_ENUM_CONSTANT(KEY_SUPER_L);
+	BIND_CORE_ENUM_CONSTANT(KEY_SUPER_R);
+	BIND_CORE_ENUM_CONSTANT(KEY_MENU);
+	BIND_CORE_ENUM_CONSTANT(KEY_HYPER_L);
+	BIND_CORE_ENUM_CONSTANT(KEY_HYPER_R);
+	BIND_CORE_ENUM_CONSTANT(KEY_HELP);
+	BIND_CORE_ENUM_CONSTANT(KEY_DIRECTION_L);
+	BIND_CORE_ENUM_CONSTANT(KEY_DIRECTION_R);
+	BIND_CORE_ENUM_CONSTANT(KEY_BACK);
+	BIND_CORE_ENUM_CONSTANT(KEY_FORWARD);
+	BIND_CORE_ENUM_CONSTANT(KEY_STOP);
+	BIND_CORE_ENUM_CONSTANT(KEY_REFRESH);
+	BIND_CORE_ENUM_CONSTANT(KEY_VOLUMEDOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_VOLUMEMUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_VOLUMEUP);
+	BIND_CORE_ENUM_CONSTANT(KEY_BASSBOOST);
+	BIND_CORE_ENUM_CONSTANT(KEY_BASSUP);
+	BIND_CORE_ENUM_CONSTANT(KEY_BASSDOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_TREBLEUP);
+	BIND_CORE_ENUM_CONSTANT(KEY_TREBLEDOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_MEDIAPLAY);
+	BIND_CORE_ENUM_CONSTANT(KEY_MEDIASTOP);
+	BIND_CORE_ENUM_CONSTANT(KEY_MEDIAPREVIOUS);
+	BIND_CORE_ENUM_CONSTANT(KEY_MEDIANEXT);
+	BIND_CORE_ENUM_CONSTANT(KEY_MEDIARECORD);
+	BIND_CORE_ENUM_CONSTANT(KEY_HOMEPAGE);
+	BIND_CORE_ENUM_CONSTANT(KEY_FAVORITES);
+	BIND_CORE_ENUM_CONSTANT(KEY_SEARCH);
+	BIND_CORE_ENUM_CONSTANT(KEY_STANDBY);
+	BIND_CORE_ENUM_CONSTANT(KEY_OPENURL);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHMAIL);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHMEDIA);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH0);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH1);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH2);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH3);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH4);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH5);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH6);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH7);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH8);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCH9);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHA);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHB);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHC);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHD);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHE);
+	BIND_CORE_ENUM_CONSTANT(KEY_LAUNCHF);
+
+	BIND_CORE_ENUM_CONSTANT(KEY_UNKNOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_SPACE);
+	BIND_CORE_ENUM_CONSTANT(KEY_EXCLAM);
+	BIND_CORE_ENUM_CONSTANT(KEY_QUOTEDBL);
+	BIND_CORE_ENUM_CONSTANT(KEY_NUMBERSIGN);
+	BIND_CORE_ENUM_CONSTANT(KEY_DOLLAR);
+	BIND_CORE_ENUM_CONSTANT(KEY_PERCENT);
+	BIND_CORE_ENUM_CONSTANT(KEY_AMPERSAND);
+	BIND_CORE_ENUM_CONSTANT(KEY_APOSTROPHE);
+	BIND_CORE_ENUM_CONSTANT(KEY_PARENLEFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_PARENRIGHT);
+	BIND_CORE_ENUM_CONSTANT(KEY_ASTERISK);
+	BIND_CORE_ENUM_CONSTANT(KEY_PLUS);
+	BIND_CORE_ENUM_CONSTANT(KEY_COMMA);
+	BIND_CORE_ENUM_CONSTANT(KEY_MINUS);
+	BIND_CORE_ENUM_CONSTANT(KEY_PERIOD);
+	BIND_CORE_ENUM_CONSTANT(KEY_SLASH);
+	BIND_CORE_ENUM_CONSTANT(KEY_0);
+	BIND_CORE_ENUM_CONSTANT(KEY_1);
+	BIND_CORE_ENUM_CONSTANT(KEY_2);
+	BIND_CORE_ENUM_CONSTANT(KEY_3);
+	BIND_CORE_ENUM_CONSTANT(KEY_4);
+	BIND_CORE_ENUM_CONSTANT(KEY_5);
+	BIND_CORE_ENUM_CONSTANT(KEY_6);
+	BIND_CORE_ENUM_CONSTANT(KEY_7);
+	BIND_CORE_ENUM_CONSTANT(KEY_8);
+	BIND_CORE_ENUM_CONSTANT(KEY_9);
+	BIND_CORE_ENUM_CONSTANT(KEY_COLON);
+	BIND_CORE_ENUM_CONSTANT(KEY_SEMICOLON);
+	BIND_CORE_ENUM_CONSTANT(KEY_LESS);
+	BIND_CORE_ENUM_CONSTANT(KEY_EQUAL);
+	BIND_CORE_ENUM_CONSTANT(KEY_GREATER);
+	BIND_CORE_ENUM_CONSTANT(KEY_QUESTION);
+	BIND_CORE_ENUM_CONSTANT(KEY_AT);
+	BIND_CORE_ENUM_CONSTANT(KEY_A);
+	BIND_CORE_ENUM_CONSTANT(KEY_B);
+	BIND_CORE_ENUM_CONSTANT(KEY_C);
+	BIND_CORE_ENUM_CONSTANT(KEY_D);
+	BIND_CORE_ENUM_CONSTANT(KEY_E);
+	BIND_CORE_ENUM_CONSTANT(KEY_F);
+	BIND_CORE_ENUM_CONSTANT(KEY_G);
+	BIND_CORE_ENUM_CONSTANT(KEY_H);
+	BIND_CORE_ENUM_CONSTANT(KEY_I);
+	BIND_CORE_ENUM_CONSTANT(KEY_J);
+	BIND_CORE_ENUM_CONSTANT(KEY_K);
+	BIND_CORE_ENUM_CONSTANT(KEY_L);
+	BIND_CORE_ENUM_CONSTANT(KEY_M);
+	BIND_CORE_ENUM_CONSTANT(KEY_N);
+	BIND_CORE_ENUM_CONSTANT(KEY_O);
+	BIND_CORE_ENUM_CONSTANT(KEY_P);
+	BIND_CORE_ENUM_CONSTANT(KEY_Q);
+	BIND_CORE_ENUM_CONSTANT(KEY_R);
+	BIND_CORE_ENUM_CONSTANT(KEY_S);
+	BIND_CORE_ENUM_CONSTANT(KEY_T);
+	BIND_CORE_ENUM_CONSTANT(KEY_U);
+	BIND_CORE_ENUM_CONSTANT(KEY_V);
+	BIND_CORE_ENUM_CONSTANT(KEY_W);
+	BIND_CORE_ENUM_CONSTANT(KEY_X);
+	BIND_CORE_ENUM_CONSTANT(KEY_Y);
+	BIND_CORE_ENUM_CONSTANT(KEY_Z);
+	BIND_CORE_ENUM_CONSTANT(KEY_BRACKETLEFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_BACKSLASH);
+	BIND_CORE_ENUM_CONSTANT(KEY_BRACKETRIGHT);
+	BIND_CORE_ENUM_CONSTANT(KEY_ASCIICIRCUM);
+	BIND_CORE_ENUM_CONSTANT(KEY_UNDERSCORE);
+	BIND_CORE_ENUM_CONSTANT(KEY_QUOTELEFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_BRACELEFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_BAR);
+	BIND_CORE_ENUM_CONSTANT(KEY_BRACERIGHT);
+	BIND_CORE_ENUM_CONSTANT(KEY_ASCIITILDE);
+	BIND_CORE_ENUM_CONSTANT(KEY_NOBREAKSPACE);
+	BIND_CORE_ENUM_CONSTANT(KEY_EXCLAMDOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_CENT);
+	BIND_CORE_ENUM_CONSTANT(KEY_STERLING);
+	BIND_CORE_ENUM_CONSTANT(KEY_CURRENCY);
+	BIND_CORE_ENUM_CONSTANT(KEY_YEN);
+	BIND_CORE_ENUM_CONSTANT(KEY_BROKENBAR);
+	BIND_CORE_ENUM_CONSTANT(KEY_SECTION);
+	BIND_CORE_ENUM_CONSTANT(KEY_DIAERESIS);
+	BIND_CORE_ENUM_CONSTANT(KEY_COPYRIGHT);
+	BIND_CORE_ENUM_CONSTANT(KEY_ORDFEMININE);
+	BIND_CORE_ENUM_CONSTANT(KEY_GUILLEMOTLEFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_NOTSIGN);
+	BIND_CORE_ENUM_CONSTANT(KEY_HYPHEN);
+	BIND_CORE_ENUM_CONSTANT(KEY_REGISTERED);
+	BIND_CORE_ENUM_CONSTANT(KEY_MACRON);
+	BIND_CORE_ENUM_CONSTANT(KEY_DEGREE);
+	BIND_CORE_ENUM_CONSTANT(KEY_PLUSMINUS);
+	BIND_CORE_ENUM_CONSTANT(KEY_TWOSUPERIOR);
+	BIND_CORE_ENUM_CONSTANT(KEY_THREESUPERIOR);
+	BIND_CORE_ENUM_CONSTANT(KEY_ACUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_MU);
+	BIND_CORE_ENUM_CONSTANT(KEY_PARAGRAPH);
+	BIND_CORE_ENUM_CONSTANT(KEY_PERIODCENTERED);
+	BIND_CORE_ENUM_CONSTANT(KEY_CEDILLA);
+	BIND_CORE_ENUM_CONSTANT(KEY_ONESUPERIOR);
+	BIND_CORE_ENUM_CONSTANT(KEY_MASCULINE);
+	BIND_CORE_ENUM_CONSTANT(KEY_GUILLEMOTRIGHT);
+	BIND_CORE_ENUM_CONSTANT(KEY_ONEQUARTER);
+	BIND_CORE_ENUM_CONSTANT(KEY_ONEHALF);
+	BIND_CORE_ENUM_CONSTANT(KEY_THREEQUARTERS);
+	BIND_CORE_ENUM_CONSTANT(KEY_QUESTIONDOWN);
+	BIND_CORE_ENUM_CONSTANT(KEY_AGRAVE);
+	BIND_CORE_ENUM_CONSTANT(KEY_AACUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_ACIRCUMFLEX);
+	BIND_CORE_ENUM_CONSTANT(KEY_ATILDE);
+	BIND_CORE_ENUM_CONSTANT(KEY_ADIAERESIS);
+	BIND_CORE_ENUM_CONSTANT(KEY_ARING);
+	BIND_CORE_ENUM_CONSTANT(KEY_AE);
+	BIND_CORE_ENUM_CONSTANT(KEY_CCEDILLA);
+	BIND_CORE_ENUM_CONSTANT(KEY_EGRAVE);
+	BIND_CORE_ENUM_CONSTANT(KEY_EACUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_ECIRCUMFLEX);
+	BIND_CORE_ENUM_CONSTANT(KEY_EDIAERESIS);
+	BIND_CORE_ENUM_CONSTANT(KEY_IGRAVE);
+	BIND_CORE_ENUM_CONSTANT(KEY_IACUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_ICIRCUMFLEX);
+	BIND_CORE_ENUM_CONSTANT(KEY_IDIAERESIS);
+	BIND_CORE_ENUM_CONSTANT(KEY_ETH);
+	BIND_CORE_ENUM_CONSTANT(KEY_NTILDE);
+	BIND_CORE_ENUM_CONSTANT(KEY_OGRAVE);
+	BIND_CORE_ENUM_CONSTANT(KEY_OACUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_OCIRCUMFLEX);
+	BIND_CORE_ENUM_CONSTANT(KEY_OTILDE);
+	BIND_CORE_ENUM_CONSTANT(KEY_ODIAERESIS);
+	BIND_CORE_ENUM_CONSTANT(KEY_MULTIPLY);
+	BIND_CORE_ENUM_CONSTANT(KEY_OOBLIQUE);
+	BIND_CORE_ENUM_CONSTANT(KEY_UGRAVE);
+	BIND_CORE_ENUM_CONSTANT(KEY_UACUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_UCIRCUMFLEX);
+	BIND_CORE_ENUM_CONSTANT(KEY_UDIAERESIS);
+	BIND_CORE_ENUM_CONSTANT(KEY_YACUTE);
+	BIND_CORE_ENUM_CONSTANT(KEY_THORN);
+	BIND_CORE_ENUM_CONSTANT(KEY_SSHARP);
+
+	BIND_CORE_ENUM_CONSTANT(KEY_DIVISION);
+	BIND_CORE_ENUM_CONSTANT(KEY_YDIAERESIS);
+
+	BIND_CORE_ENUM_CONSTANT(KEY_CODE_MASK);
+	BIND_CORE_ENUM_CONSTANT(KEY_MODIFIER_MASK);
+
+	BIND_CORE_ENUM_CONSTANT(KEY_MASK_SHIFT);
+	BIND_CORE_ENUM_CONSTANT(KEY_MASK_ALT);
+	BIND_CORE_ENUM_CONSTANT(KEY_MASK_META);
+	BIND_CORE_ENUM_CONSTANT(KEY_MASK_CTRL);
+	BIND_CORE_ENUM_CONSTANT_NO_VAL(KEY_MASK_CMD);
+	BIND_CORE_ENUM_CONSTANT(KEY_MASK_KPAD);
+	BIND_CORE_ENUM_CONSTANT(KEY_MASK_GROUP_SWITCH);
+
+	// mouse
+	BIND_CORE_ENUM_CONSTANT(BUTTON_LEFT);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_MIDDLE);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_XBUTTON1);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_XBUTTON2);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_WHEEL_UP);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_WHEEL_DOWN);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_WHEEL_LEFT);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_WHEEL_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_MASK_LEFT);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_MASK_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_MASK_MIDDLE);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_MASK_XBUTTON1);
+	BIND_CORE_ENUM_CONSTANT(BUTTON_MASK_XBUTTON2);
+
+	// Joypad buttons
+	BIND_CORE_ENUM_CONSTANT(JOY_INVALID_BUTTON);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_A);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_B);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_BACK);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_GUIDE);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_START);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_LEFT_STICK);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_RIGHT_STICK);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_LEFT_SHOULDER);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_RIGHT_SHOULDER);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_DPAD_UP);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_DPAD_DOWN);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_DPAD_LEFT);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_DPAD_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(JOY_SDL_BUTTONS);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_CROSS);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_CIRCLE);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_SQUARE);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_TRIANGLE);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_SELECT);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_START);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_PS);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_L1);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_R1);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_L3);
+	BIND_CORE_ENUM_CONSTANT(JOY_SONY_R3);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_A);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_B);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_BACK);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_START);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_HOME);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_LS);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_RS);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_LB);
+	BIND_CORE_ENUM_CONSTANT(JOY_XBOX_RB);
+	BIND_CORE_ENUM_CONSTANT(JOY_BUTTON_MAX);
+
+	// Joypad axes
+	BIND_CORE_ENUM_CONSTANT(JOY_INVALID_AXIS);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_LEFT_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_LEFT_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_RIGHT_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_RIGHT_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_TRIGGER_LEFT);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_TRIGGER_RIGHT);
+	BIND_CORE_ENUM_CONSTANT(JOY_SDL_AXES);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_0_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_0_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_1_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_1_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_2_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_2_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_3_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_3_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_4_X);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_4_Y);
+	BIND_CORE_ENUM_CONSTANT(JOY_AXIS_MAX);
+
+	// midi
+	BIND_CORE_ENUM_CONSTANT(MIDI_MESSAGE_NOTE_OFF);
+	BIND_CORE_ENUM_CONSTANT(MIDI_MESSAGE_NOTE_ON);
+	BIND_CORE_ENUM_CONSTANT(MIDI_MESSAGE_AFTERTOUCH);
+	BIND_CORE_ENUM_CONSTANT(MIDI_MESSAGE_CONTROL_CHANGE);
+	BIND_CORE_ENUM_CONSTANT(MIDI_MESSAGE_PROGRAM_CHANGE);
+	BIND_CORE_ENUM_CONSTANT(MIDI_MESSAGE_CHANNEL_PRESSURE);
+	BIND_CORE_ENUM_CONSTANT(MIDI_MESSAGE_PITCH_BEND);
+
+	// error list
+
+	BIND_CORE_ENUM_CONSTANT(OK); // (0)
+	BIND_CORE_ENUM_CONSTANT(FAILED);
+	BIND_CORE_ENUM_CONSTANT(ERR_UNAVAILABLE);
+	BIND_CORE_ENUM_CONSTANT(ERR_UNCONFIGURED);
+	BIND_CORE_ENUM_CONSTANT(ERR_UNAUTHORIZED);
+	BIND_CORE_ENUM_CONSTANT(ERR_PARAMETER_RANGE_ERROR); // (5)
+	BIND_CORE_ENUM_CONSTANT(ERR_OUT_OF_MEMORY);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_NOT_FOUND);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_BAD_DRIVE);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_BAD_PATH);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_NO_PERMISSION); // (10)
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_ALREADY_IN_USE);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_CANT_OPEN);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_CANT_WRITE);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_CANT_READ);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_UNRECOGNIZED); // (15)
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_CORRUPT);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_MISSING_DEPENDENCIES);
+	BIND_CORE_ENUM_CONSTANT(ERR_FILE_EOF);
+	BIND_CORE_ENUM_CONSTANT(ERR_CANT_OPEN);
+	BIND_CORE_ENUM_CONSTANT(ERR_CANT_CREATE); // (20)
+	BIND_CORE_ENUM_CONSTANT(ERR_QUERY_FAILED);
+	BIND_CORE_ENUM_CONSTANT(ERR_ALREADY_IN_USE);
+	BIND_CORE_ENUM_CONSTANT(ERR_LOCKED);
+	BIND_CORE_ENUM_CONSTANT(ERR_TIMEOUT);
+	BIND_CORE_ENUM_CONSTANT(ERR_CANT_CONNECT); // (25)
+	BIND_CORE_ENUM_CONSTANT(ERR_CANT_RESOLVE);
+	BIND_CORE_ENUM_CONSTANT(ERR_CONNECTION_ERROR);
+	BIND_CORE_ENUM_CONSTANT(ERR_CANT_ACQUIRE_RESOURCE);
+	BIND_CORE_ENUM_CONSTANT(ERR_CANT_FORK);
+	BIND_CORE_ENUM_CONSTANT(ERR_INVALID_DATA); // (30)
+	BIND_CORE_ENUM_CONSTANT(ERR_INVALID_PARAMETER);
+	BIND_CORE_ENUM_CONSTANT(ERR_ALREADY_EXISTS);
+	BIND_CORE_ENUM_CONSTANT(ERR_DOES_NOT_EXIST);
+	BIND_CORE_ENUM_CONSTANT(ERR_DATABASE_CANT_READ);
+	BIND_CORE_ENUM_CONSTANT(ERR_DATABASE_CANT_WRITE); // (35)
+	BIND_CORE_ENUM_CONSTANT(ERR_COMPILATION_FAILED);
+	BIND_CORE_ENUM_CONSTANT(ERR_METHOD_NOT_FOUND);
+	BIND_CORE_ENUM_CONSTANT(ERR_LINK_FAILED);
+	BIND_CORE_ENUM_CONSTANT(ERR_SCRIPT_FAILED);
+	BIND_CORE_ENUM_CONSTANT(ERR_CYCLIC_LINK); // (40)
+	BIND_CORE_ENUM_CONSTANT(ERR_INVALID_DECLARATION);
+	BIND_CORE_ENUM_CONSTANT(ERR_DUPLICATE_SYMBOL);
+	BIND_CORE_ENUM_CONSTANT(ERR_PARSE_ERROR);
+	BIND_CORE_ENUM_CONSTANT(ERR_BUSY);
+	BIND_CORE_ENUM_CONSTANT(ERR_SKIP); // (45)
+	BIND_CORE_ENUM_CONSTANT(ERR_HELP);
+	BIND_CORE_ENUM_CONSTANT(ERR_BUG);
+	BIND_CORE_ENUM_CONSTANT(ERR_PRINTER_ON_FIRE);
+
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_NONE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_RANGE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_EXP_RANGE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_ENUM);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_EXP_EASING);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_LENGTH);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_KEY_ACCEL);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_FLAGS);
+
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_2D_RENDER);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_2D_PHYSICS);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_3D_RENDER);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_3D_PHYSICS);
+
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_FILE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_DIR);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_GLOBAL_FILE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_GLOBAL_DIR);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_RESOURCE_TYPE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_MULTILINE_TEXT);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_PLACEHOLDER_TEXT);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_COLOR_NO_ALPHA);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_IMAGE_COMPRESS_LOSSY);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS);
+
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_STORAGE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_EDITOR);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NETWORK);
+
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_EDITOR_HELPER);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_CHECKABLE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_CHECKED);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_INTERNATIONALIZED);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_GROUP);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_CATEGORY);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_SUBGROUP);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NO_INSTANCE_STATE);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_RESTART_IF_CHANGED);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_SCRIPT_VARIABLE);
+
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_DEFAULT);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_DEFAULT_INTL);
+	BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NOEDITOR);
+
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAG_NORMAL);
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAG_EDITOR);
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAG_NOSCRIPT);
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAG_CONST);
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAG_REVERSE);
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAG_VIRTUAL);
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAG_FROM_SCRIPT);
+	BIND_CORE_ENUM_CONSTANT(METHOD_FLAGS_DEFAULT);
+
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_NIL", Variant::NIL);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_BOOL", Variant::BOOL);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_INT", Variant::INT);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_REAL", Variant::FLOAT);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_STRING", Variant::STRING);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR2", Variant::VECTOR2);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR2I", Variant::VECTOR2I);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_RECT2", Variant::RECT2);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_RECT2I", Variant::RECT2I);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR3", Variant::VECTOR3);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR3I", Variant::VECTOR3I);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_TRANSFORM2D", Variant::TRANSFORM2D);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_PLANE", Variant::PLANE);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_QUAT", Variant::QUAT);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_AABB", Variant::AABB);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_BASIS", Variant::BASIS);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_TRANSFORM", Variant::TRANSFORM);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_COLOR", Variant::COLOR);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_STRING_NAME", Variant::STRING_NAME);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_NODE_PATH", Variant::NODE_PATH);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_RID", Variant::RID);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_OBJECT", Variant::OBJECT);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_CALLABLE", Variant::CALLABLE);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_SIGNAL", Variant::SIGNAL);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_DICTIONARY", Variant::DICTIONARY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_ARRAY", Variant::ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_RAW_ARRAY", Variant::PACKED_BYTE_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_INT32_ARRAY", Variant::PACKED_INT32_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_INT64_ARRAY", Variant::PACKED_INT64_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_FLOAT32_ARRAY", Variant::PACKED_FLOAT32_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_FLOAT64_ARRAY", Variant::PACKED_FLOAT64_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_STRING_ARRAY", Variant::PACKED_STRING_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR2_ARRAY", Variant::PACKED_VECTOR2_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR3_ARRAY", Variant::PACKED_VECTOR3_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_COLOR_ARRAY", Variant::PACKED_COLOR_ARRAY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("TYPE_MAX", Variant::VARIANT_MAX);
+
+	//comparison
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_EQUAL", Variant::OP_EQUAL);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_NOT_EQUAL", Variant::OP_NOT_EQUAL);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_LESS", Variant::OP_LESS);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_LESS_EQUAL", Variant::OP_LESS_EQUAL);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_GREATER", Variant::OP_GREATER);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_GREATER_EQUAL", Variant::OP_GREATER_EQUAL);
+	//mathematic
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_ADD", Variant::OP_ADD);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_SUBTRACT", Variant::OP_SUBTRACT);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_MULTIPLY", Variant::OP_MULTIPLY);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_DIVIDE", Variant::OP_DIVIDE);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_NEGATE", Variant::OP_NEGATE);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_POSITIVE", Variant::OP_POSITIVE);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_MODULE", Variant::OP_MODULE);
+	//bitwise
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_SHIFT_LEFT", Variant::OP_SHIFT_LEFT);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_SHIFT_RIGHT", Variant::OP_SHIFT_RIGHT);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_BIT_AND", Variant::OP_BIT_AND);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_BIT_OR", Variant::OP_BIT_OR);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_BIT_XOR", Variant::OP_BIT_XOR);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_BIT_NEGATE", Variant::OP_BIT_NEGATE);
+	//logic
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_AND", Variant::OP_AND);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_OR", Variant::OP_OR);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_XOR", Variant::OP_XOR);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_NOT", Variant::OP_NOT);
+	//containment
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_IN", Variant::OP_IN);
+	BIND_CORE_ENUM_CONSTANT_CUSTOM("OP_MAX", Variant::OP_MAX);
+}
+
+void unregister_global_constants() {
+	_global_constants.clear();
+}
+
+int CoreConstants::get_global_constant_count() {
+	return _global_constants.size();
+}
+
+#ifdef DEBUG_METHODS_ENABLED
+StringName CoreConstants::get_global_constant_enum(int p_idx) {
+	return _global_constants[p_idx].enum_name;
+}
+
+bool CoreConstants::get_ignore_value_in_docs(int p_idx) {
+	return _global_constants[p_idx].ignore_value_in_docs;
+}
+#else
+StringName CoreConstants::get_global_constant_enum(int p_idx) {
+	return StringName();
+}
+
+bool CoreConstants::get_ignore_value_in_docs(int p_idx) {
+	return false;
+}
+#endif
+
+const char *CoreConstants::get_global_constant_name(int p_idx) {
+	return _global_constants[p_idx].name;
+}
+
+int CoreConstants::get_global_constant_value(int p_idx) {
+	return _global_constants[p_idx].value;
+}
diff --git a/core/global_constants.h b/core/core_constants.h
index 989633a6fa..6cddd9daec 100644
--- a/core/global_constants.h
+++ b/core/core_constants.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  global_constants.h                                                   */
+/*  core_constants.h                                                     */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,12 +28,12 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef GLOBAL_CONSTANTS_H
-#define GLOBAL_CONSTANTS_H
+#ifndef CORE_CONSTANTS_H
+#define CORE_CONSTANTS_H
 
-#include "core/string_name.h"
+#include "core/string/string_name.h"
 
-class GlobalConstants {
+class CoreConstants {
 public:
 	static int get_global_constant_count();
 	static StringName get_global_constant_enum(int p_idx);
diff --git a/core/core_string_names.h b/core/core_string_names.h
index 43597ef301..c0bdc33d28 100644
--- a/core/core_string_names.h
+++ b/core/core_string_names.h
@@ -31,7 +31,7 @@
 #ifndef CORE_STRING_NAMES_H
 #define CORE_STRING_NAMES_H
 
-#include "core/string_name.h"
+#include "core/string/string_name.h"
 
 class CoreStringNames {
 	friend void register_core_types();
diff --git a/core/crypto/aes_context.h b/core/crypto/aes_context.h
index 006ecee2ad..c23c504a72 100644
--- a/core/crypto/aes_context.h
+++ b/core/crypto/aes_context.h
@@ -32,7 +32,7 @@
 #define AES_CONTEXT_H
 
 #include "core/crypto/crypto_core.h"
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class AESContext : public Reference {
 	GDCLASS(AESContext, Reference);
diff --git a/core/crypto/crypto.cpp b/core/crypto/crypto.cpp
index 29d02e11df..d12108bca0 100644
--- a/core/crypto/crypto.cpp
+++ b/core/crypto/crypto.cpp
@@ -30,7 +30,7 @@
 
 #include "crypto.h"
 
-#include "core/engine.h"
+#include "core/config/engine.h"
 #include "core/io/certs_compressed.gen.h"
 #include "core/io/compression.h"
 
diff --git a/core/crypto/crypto.h b/core/crypto/crypto.h
index 916f7798eb..8325f043bf 100644
--- a/core/crypto/crypto.h
+++ b/core/crypto/crypto.h
@@ -32,10 +32,10 @@
 #define CRYPTO_H
 
 #include "core/crypto/hashing_context.h"
+#include "core/io/resource.h"
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
-#include "core/reference.h"
-#include "core/resource.h"
+#include "core/object/reference.h"
 
 class CryptoKey : public Resource {
 	GDCLASS(CryptoKey, Resource);
diff --git a/core/crypto/crypto_core.h b/core/crypto/crypto_core.h
index 9ab2871caa..57ba469f8d 100644
--- a/core/crypto/crypto_core.h
+++ b/core/crypto/crypto_core.h
@@ -31,7 +31,7 @@
 #ifndef CRYPTO_CORE_H
 #define CRYPTO_CORE_H
 
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class CryptoCore {
 public:
diff --git a/core/crypto/hashing_context.h b/core/crypto/hashing_context.h
index f9454fa891..40d075afa9 100644
--- a/core/crypto/hashing_context.h
+++ b/core/crypto/hashing_context.h
@@ -31,7 +31,7 @@
 #ifndef HASHING_CONTEXT_H
 #define HASHING_CONTEXT_H
 
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class HashingContext : public Reference {
 	GDCLASS(HashingContext, Reference);
diff --git a/core/debugger/debugger_marshalls.h b/core/debugger/debugger_marshalls.h
index 7b7f4ac4b5..f5a1a891bf 100644
--- a/core/debugger/debugger_marshalls.h
+++ b/core/debugger/debugger_marshalls.h
@@ -31,7 +31,7 @@
 #ifndef DEBUGGER_MARSHARLLS_H
 #define DEBUGGER_MARSHARLLS_H
 
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 #include "servers/rendering_server.h"
 
 struct DebuggerMarshalls {
diff --git a/core/debugger/engine_debugger.h b/core/debugger/engine_debugger.h
index 8d5ebb2394..10f04bf97a 100644
--- a/core/debugger/engine_debugger.h
+++ b/core/debugger/engine_debugger.h
@@ -31,12 +31,12 @@
 #ifndef ENGINE_DEBUGGER_H
 #define ENGINE_DEBUGGER_H
 
-#include "core/array.h"
-#include "core/map.h"
-#include "core/string_name.h"
-#include "core/ustring.h"
-#include "core/variant.h"
-#include "core/vector.h"
+#include "core/string/string_name.h"
+#include "core/string/ustring.h"
+#include "core/templates/map.h"
+#include "core/templates/vector.h"
+#include "core/variant/array.h"
+#include "core/variant/variant.h"
 
 class RemoteDebuggerPeer;
 class ScriptDebugger;
diff --git a/core/debugger/local_debugger.h b/core/debugger/local_debugger.h
index d342da6d44..dbdeec173b 100644
--- a/core/debugger/local_debugger.h
+++ b/core/debugger/local_debugger.h
@@ -32,8 +32,8 @@
 #define LOCAL_DEBUGGER_H
 
 #include "core/debugger/engine_debugger.h"
-#include "core/list.h"
-#include "core/script_language.h"
+#include "core/object/script_language.h"
+#include "core/templates/list.h"
 
 class LocalDebugger : public EngineDebugger {
 private:
diff --git a/core/debugger/remote_debugger.cpp b/core/debugger/remote_debugger.cpp
index 9d55e1312e..ff89517497 100644
--- a/core/debugger/remote_debugger.cpp
+++ b/core/debugger/remote_debugger.cpp
@@ -30,13 +30,13 @@
 
 #include "remote_debugger.h"
 
+#include "core/config/project_settings.h"
 #include "core/debugger/debugger_marshalls.h"
 #include "core/debugger/engine_debugger.h"
 #include "core/debugger/script_debugger.h"
 #include "core/input/input.h"
+#include "core/object/script_language.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
-#include "core/script_language.h"
 #include "scene/main/node.h"
 #include "servers/display_server.h"
 
diff --git a/core/debugger/remote_debugger.h b/core/debugger/remote_debugger.h
index 320ee15996..37cc8af2a5 100644
--- a/core/debugger/remote_debugger.h
+++ b/core/debugger/remote_debugger.h
@@ -31,13 +31,13 @@
 #ifndef REMOTE_DEBUGGER_H
 #define REMOTE_DEBUGGER_H
 
-#include "core/array.h"
-#include "core/class_db.h"
 #include "core/debugger/debugger_marshalls.h"
 #include "core/debugger/engine_debugger.h"
 #include "core/debugger/remote_debugger_peer.h"
-#include "core/string_name.h"
-#include "core/ustring.h"
+#include "core/object/class_db.h"
+#include "core/string/string_name.h"
+#include "core/string/ustring.h"
+#include "core/variant/array.h"
 
 class RemoteDebugger : public EngineDebugger {
 public:
diff --git a/core/debugger/remote_debugger_peer.cpp b/core/debugger/remote_debugger_peer.cpp
index 0ce0042f50..338c637014 100644
--- a/core/debugger/remote_debugger_peer.cpp
+++ b/core/debugger/remote_debugger_peer.cpp
@@ -30,9 +30,9 @@
 
 #include "remote_debugger_peer.h"
 
+#include "core/config/project_settings.h"
 #include "core/io/marshalls.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 bool RemoteDebuggerPeerTCP::is_peer_connected() {
 	return connected;
diff --git a/core/debugger/remote_debugger_peer.h b/core/debugger/remote_debugger_peer.h
index 3a75a2a02b..79b88f5549 100644
--- a/core/debugger/remote_debugger_peer.h
+++ b/core/debugger/remote_debugger_peer.h
@@ -32,10 +32,10 @@
 #define REMOTE_DEBUGGER_PEER_H
 
 #include "core/io/stream_peer_tcp.h"
+#include "core/object/reference.h"
 #include "core/os/mutex.h"
 #include "core/os/thread.h"
-#include "core/reference.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 class RemoteDebuggerPeer : public Reference {
 protected:
diff --git a/core/debugger/script_debugger.h b/core/debugger/script_debugger.h
index 0068691825..7f2f2becc2 100644
--- a/core/debugger/script_debugger.h
+++ b/core/debugger/script_debugger.h
@@ -31,11 +31,11 @@
 #ifndef SCRIPT_DEBUGGER_H
 #define SCRIPT_DEBUGGER_H
 
-#include "core/map.h"
-#include "core/script_language.h"
-#include "core/set.h"
-#include "core/string_name.h"
-#include "core/vector.h"
+#include "core/object/script_language.h"
+#include "core/string/string_name.h"
+#include "core/templates/map.h"
+#include "core/templates/set.h"
+#include "core/templates/vector.h"
 
 class ScriptDebugger {
 	typedef ScriptLanguage::StackInfo StackInfo;
diff --git a/core/error/SCsub b/core/error/SCsub
new file mode 100644
index 0000000000..dfd6248a94
--- /dev/null
+++ b/core/error/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env_error = env.Clone()
+
+env_error.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/error_list.h b/core/error/error_list.h
index a0218cf045..a0218cf045 100644
--- a/core/error_list.h
+++ b/core/error/error_list.h
diff --git a/core/error_macros.cpp b/core/error/error_macros.cpp
index 2fae939965..80879dd25d 100644
--- a/core/error_macros.cpp
+++ b/core/error/error_macros.cpp
@@ -31,8 +31,8 @@
 #include "error_macros.h"
 
 #include "core/io/logger.h"
-#include "core/ustring.h"
-#include "os/os.h"
+#include "core/os/os.h"
+#include "core/string/ustring.h"
 
 static ErrorHandlerList *error_handler_list = nullptr;
 
diff --git a/core/error_macros.h b/core/error/error_macros.h
index 6353961b04..6353961b04 100644
--- a/core/error_macros.h
+++ b/core/error/error_macros.h
diff --git a/core/func_ref.cpp b/core/func_ref.cpp
deleted file mode 100644
index 7e062f16d0..0000000000
--- a/core/func_ref.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*************************************************************************/
-/*  func_ref.cpp                                                         */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#include "func_ref.h"
-
-Variant FuncRef::call_func(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
-	if (id.is_null()) {
-		r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
-		return Variant();
-	}
-	Object *obj = ObjectDB::get_instance(id);
-
-	if (!obj) {
-		r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
-		return Variant();
-	}
-
-	return obj->call(function, p_args, p_argcount, r_error);
-}
-
-Variant FuncRef::call_funcv(const Array &p_args) {
-	ERR_FAIL_COND_V(id.is_null(), Variant());
-
-	Object *obj = ObjectDB::get_instance(id);
-
-	ERR_FAIL_COND_V(!obj, Variant());
-
-	return obj->callv(function, p_args);
-}
-
-void FuncRef::set_instance(Object *p_obj) {
-	ERR_FAIL_NULL(p_obj);
-	id = p_obj->get_instance_id();
-}
-
-void FuncRef::set_function(const StringName &p_func) {
-	function = p_func;
-}
-
-StringName FuncRef::get_function() {
-	return function;
-}
-
-bool FuncRef::is_valid() const {
-	if (id.is_null()) {
-		return false;
-	}
-
-	Object *obj = ObjectDB::get_instance(id);
-	if (!obj) {
-		return false;
-	}
-
-	return obj->has_method(function);
-}
-
-void FuncRef::_bind_methods() {
-	{
-		MethodInfo mi;
-		mi.name = "call_func";
-		Vector<Variant> defargs;
-		ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "call_func", &FuncRef::call_func, mi, defargs);
-	}
-
-	ClassDB::bind_method(D_METHOD("call_funcv", "arg_array"), &FuncRef::call_funcv);
-
-	ClassDB::bind_method(D_METHOD("set_instance", "instance"), &FuncRef::set_instance);
-	ClassDB::bind_method(D_METHOD("is_valid"), &FuncRef::is_valid);
-
-	ClassDB::bind_method(D_METHOD("set_function", "name"), &FuncRef::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &FuncRef::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "function"), "set_function", "get_function");
-}
diff --git a/core/func_ref.h b/core/func_ref.h
deleted file mode 100644
index 75b84e705e..0000000000
--- a/core/func_ref.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*************************************************************************/
-/*  func_ref.h                                                           */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#ifndef FUNC_REF_H
-#define FUNC_REF_H
-
-#include "core/reference.h"
-
-class FuncRef : public Reference {
-	GDCLASS(FuncRef, Reference);
-	ObjectID id;
-	StringName function;
-
-protected:
-	static void _bind_methods();
-
-public:
-	Variant call_func(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
-	Variant call_funcv(const Array &p_args);
-	void set_instance(Object *p_obj);
-	void set_function(const StringName &p_func);
-	StringName get_function();
-	bool is_valid() const;
-
-	FuncRef() {}
-};
-
-#endif // FUNC_REF_H
diff --git a/core/global_constants.cpp b/core/global_constants.cpp
deleted file mode 100644
index 064c302341..0000000000
--- a/core/global_constants.cpp
+++ /dev/null
@@ -1,691 +0,0 @@
-/*************************************************************************/
-/*  global_constants.cpp                                                 */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#include "global_constants.h"
-
-#include "core/class_db.h"
-#include "core/input/input_event.h"
-#include "core/os/keyboard.h"
-#include "core/variant.h"
-
-struct _GlobalConstant {
-#ifdef DEBUG_METHODS_ENABLED
-	StringName enum_name;
-	bool ignore_value_in_docs;
-#endif
-	const char *name;
-	int value;
-
-	_GlobalConstant() {}
-
-#ifdef DEBUG_METHODS_ENABLED
-	_GlobalConstant(const StringName &p_enum_name, const char *p_name, int p_value, bool p_ignore_value_in_docs = false) :
-			enum_name(p_enum_name),
-			ignore_value_in_docs(p_ignore_value_in_docs),
-			name(p_name),
-			value(p_value) {
-	}
-#else
-	_GlobalConstant(const char *p_name, int p_value) :
-			name(p_name),
-			value(p_value) {
-	}
-#endif
-};
-
-static Vector<_GlobalConstant> _global_constants;
-
-#ifdef DEBUG_METHODS_ENABLED
-
-#define BIND_GLOBAL_CONSTANT(m_constant) \
-	_global_constants.push_back(_GlobalConstant(StringName(), #m_constant, m_constant));
-
-#define BIND_GLOBAL_ENUM_CONSTANT(m_constant) \
-	_global_constants.push_back(_GlobalConstant(__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant));
-
-#define BIND_GLOBAL_ENUM_CONSTANT_CUSTOM(m_custom_name, m_constant) \
-	_global_constants.push_back(_GlobalConstant(__constant_get_enum_name(m_constant, #m_constant), m_custom_name, m_constant));
-
-#define BIND_GLOBAL_CONSTANT_NO_VAL(m_constant) \
-	_global_constants.push_back(_GlobalConstant(StringName(), #m_constant, m_constant, true));
-
-#define BIND_GLOBAL_ENUM_CONSTANT_NO_VAL(m_constant) \
-	_global_constants.push_back(_GlobalConstant(__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant, true));
-
-#define BIND_GLOBAL_ENUM_CONSTANT_CUSTOM_NO_VAL(m_custom_name, m_constant) \
-	_global_constants.push_back(_GlobalConstant(__constant_get_enum_name(m_constant, #m_constant), m_custom_name, m_constant, true));
-
-#else
-
-#define BIND_GLOBAL_CONSTANT(m_constant) \
-	_global_constants.push_back(_GlobalConstant(#m_constant, m_constant));
-
-#define BIND_GLOBAL_ENUM_CONSTANT(m_constant) \
-	_global_constants.push_back(_GlobalConstant(#m_constant, m_constant));
-
-#define BIND_GLOBAL_ENUM_CONSTANT_CUSTOM(m_custom_name, m_constant) \
-	_global_constants.push_back(_GlobalConstant(m_custom_name, m_constant));
-
-#define BIND_GLOBAL_CONSTANT_NO_VAL(m_constant) \
-	_global_constants.push_back(_GlobalConstant(#m_constant, m_constant));
-
-#define BIND_GLOBAL_ENUM_CONSTANT_NO_VAL(m_constant) \
-	_global_constants.push_back(_GlobalConstant(#m_constant, m_constant));
-
-#define BIND_GLOBAL_ENUM_CONSTANT_CUSTOM_NO_VAL(m_custom_name, m_constant) \
-	_global_constants.push_back(_GlobalConstant(m_custom_name, m_constant));
-
-#endif
-
-VARIANT_ENUM_CAST(KeyList);
-VARIANT_ENUM_CAST(KeyModifierMask);
-VARIANT_ENUM_CAST(ButtonList);
-VARIANT_ENUM_CAST(JoyButtonList);
-VARIANT_ENUM_CAST(JoyAxisList);
-VARIANT_ENUM_CAST(MidiMessageList);
-
-void register_global_constants() {
-	BIND_GLOBAL_ENUM_CONSTANT(MARGIN_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(MARGIN_TOP);
-	BIND_GLOBAL_ENUM_CONSTANT(MARGIN_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(MARGIN_BOTTOM);
-
-	BIND_GLOBAL_ENUM_CONSTANT(CORNER_TOP_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(CORNER_TOP_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(CORNER_BOTTOM_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(CORNER_BOTTOM_LEFT);
-
-	BIND_GLOBAL_ENUM_CONSTANT(VERTICAL);
-	BIND_GLOBAL_ENUM_CONSTANT(HORIZONTAL);
-
-	BIND_GLOBAL_ENUM_CONSTANT(HALIGN_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(HALIGN_CENTER);
-	BIND_GLOBAL_ENUM_CONSTANT(HALIGN_RIGHT);
-
-	BIND_GLOBAL_ENUM_CONSTANT(VALIGN_TOP);
-	BIND_GLOBAL_ENUM_CONSTANT(VALIGN_CENTER);
-	BIND_GLOBAL_ENUM_CONSTANT(VALIGN_BOTTOM);
-
-	// huge list of keys
-	BIND_GLOBAL_CONSTANT(SPKEY);
-
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ESCAPE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_TAB);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BACKTAB);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BACKSPACE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ENTER);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_ENTER);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_INSERT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DELETE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PAUSE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PRINT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SYSREQ);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CLEAR);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_HOME);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_END);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_UP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PAGEUP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PAGEDOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SHIFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CONTROL);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_META);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ALT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CAPSLOCK);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_NUMLOCK);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SCROLLLOCK);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F1);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F2);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F3);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F4);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F5);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F6);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F7);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F8);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F9);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F10);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F11);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F12);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F13);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F14);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F15);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F16);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_MULTIPLY);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_DIVIDE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_SUBTRACT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_PERIOD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_ADD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_0);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_1);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_2);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_3);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_4);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_5);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_6);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_7);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_8);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_KP_9);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SUPER_L);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SUPER_R);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MENU);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_HYPER_L);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_HYPER_R);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_HELP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DIRECTION_L);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DIRECTION_R);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BACK);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_FORWARD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_STOP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_REFRESH);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_VOLUMEDOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_VOLUMEMUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_VOLUMEUP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BASSBOOST);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BASSUP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BASSDOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_TREBLEUP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_TREBLEDOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MEDIAPLAY);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MEDIASTOP);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MEDIAPREVIOUS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MEDIANEXT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MEDIARECORD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_HOMEPAGE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_FAVORITES);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SEARCH);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_STANDBY);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_OPENURL);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHMAIL);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHMEDIA);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH0);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH1);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH2);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH3);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH4);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH5);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH6);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH7);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH8);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCH9);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHA);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHB);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHC);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LAUNCHF);
-
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_UNKNOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SPACE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_EXCLAM);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_QUOTEDBL);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_NUMBERSIGN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DOLLAR);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PERCENT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_AMPERSAND);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_APOSTROPHE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PARENLEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PARENRIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ASTERISK);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PLUS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_COMMA);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MINUS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PERIOD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SLASH);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_0);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_1);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_2);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_3);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_4);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_5);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_6);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_7);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_8);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_9);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_COLON);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SEMICOLON);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_LESS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_EQUAL);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_GREATER);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_QUESTION);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_AT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_A);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_B);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_C);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_D);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_E);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_F);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_G);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_H);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_I);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_J);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_K);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_L);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_M);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_N);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_O);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_P);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_Q);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_R);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_S);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_T);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_U);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_V);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_W);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_X);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_Z);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BRACKETLEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BACKSLASH);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BRACKETRIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ASCIICIRCUM);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_UNDERSCORE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_QUOTELEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BRACELEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BAR);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BRACERIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ASCIITILDE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_NOBREAKSPACE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_EXCLAMDOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CENT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_STERLING);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CURRENCY);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_YEN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_BROKENBAR);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SECTION);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DIAERESIS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_COPYRIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ORDFEMININE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_GUILLEMOTLEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_NOTSIGN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_HYPHEN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_REGISTERED);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MACRON);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DEGREE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PLUSMINUS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_TWOSUPERIOR);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_THREESUPERIOR);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ACUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MU);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PARAGRAPH);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_PERIODCENTERED);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CEDILLA);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ONESUPERIOR);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MASCULINE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_GUILLEMOTRIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ONEQUARTER);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ONEHALF);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_THREEQUARTERS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_QUESTIONDOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_AGRAVE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_AACUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ACIRCUMFLEX);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ATILDE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ADIAERESIS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ARING);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_AE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CCEDILLA);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_EGRAVE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_EACUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ECIRCUMFLEX);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_EDIAERESIS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_IGRAVE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_IACUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ICIRCUMFLEX);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_IDIAERESIS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ETH);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_NTILDE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_OGRAVE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_OACUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_OCIRCUMFLEX);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_OTILDE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_ODIAERESIS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MULTIPLY);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_OOBLIQUE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_UGRAVE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_UACUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_UCIRCUMFLEX);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_UDIAERESIS);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_YACUTE);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_THORN);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_SSHARP);
-
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_DIVISION);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_YDIAERESIS);
-
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_CODE_MASK);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MODIFIER_MASK);
-
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MASK_SHIFT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MASK_ALT);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MASK_META);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MASK_CTRL);
-	BIND_GLOBAL_ENUM_CONSTANT_NO_VAL(KEY_MASK_CMD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MASK_KPAD);
-	BIND_GLOBAL_ENUM_CONSTANT(KEY_MASK_GROUP_SWITCH);
-
-	// mouse
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_MIDDLE);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_XBUTTON1);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_XBUTTON2);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_WHEEL_UP);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_WHEEL_DOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_WHEEL_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_WHEEL_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_MASK_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_MASK_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_MASK_MIDDLE);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_MASK_XBUTTON1);
-	BIND_GLOBAL_ENUM_CONSTANT(BUTTON_MASK_XBUTTON2);
-
-	// Joypad buttons
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_INVALID_BUTTON);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_A);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_B);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_BACK);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_GUIDE);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_START);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_LEFT_STICK);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_RIGHT_STICK);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_LEFT_SHOULDER);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_RIGHT_SHOULDER);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_DPAD_UP);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_DPAD_DOWN);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_DPAD_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_DPAD_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SDL_BUTTONS);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_CROSS);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_CIRCLE);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_SQUARE);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_TRIANGLE);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_SELECT);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_START);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_PS);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_L1);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_R1);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_L3);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SONY_R3);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_A);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_B);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_BACK);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_START);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_HOME);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_LS);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_RS);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_LB);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_XBOX_RB);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_BUTTON_MAX);
-
-	// Joypad axes
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_INVALID_AXIS);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_LEFT_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_LEFT_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_RIGHT_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_RIGHT_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_TRIGGER_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_TRIGGER_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_SDL_AXES);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_0_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_0_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_1_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_1_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_2_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_2_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_3_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_3_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_4_X);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_4_Y);
-	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_MAX);
-
-	// midi
-	BIND_GLOBAL_ENUM_CONSTANT(MIDI_MESSAGE_NOTE_OFF);
-	BIND_GLOBAL_ENUM_CONSTANT(MIDI_MESSAGE_NOTE_ON);
-	BIND_GLOBAL_ENUM_CONSTANT(MIDI_MESSAGE_AFTERTOUCH);
-	BIND_GLOBAL_ENUM_CONSTANT(MIDI_MESSAGE_CONTROL_CHANGE);
-	BIND_GLOBAL_ENUM_CONSTANT(MIDI_MESSAGE_PROGRAM_CHANGE);
-	BIND_GLOBAL_ENUM_CONSTANT(MIDI_MESSAGE_CHANNEL_PRESSURE);
-	BIND_GLOBAL_ENUM_CONSTANT(MIDI_MESSAGE_PITCH_BEND);
-
-	// error list
-
-	BIND_GLOBAL_ENUM_CONSTANT(OK); // (0)
-	BIND_GLOBAL_ENUM_CONSTANT(FAILED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_UNAVAILABLE);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_UNCONFIGURED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_UNAUTHORIZED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_PARAMETER_RANGE_ERROR); // (5)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_OUT_OF_MEMORY);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_NOT_FOUND);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_BAD_DRIVE);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_BAD_PATH);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_NO_PERMISSION); // (10)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_ALREADY_IN_USE);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_CANT_OPEN);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_CANT_WRITE);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_CANT_READ);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_UNRECOGNIZED); // (15)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_CORRUPT);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_MISSING_DEPENDENCIES);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_FILE_EOF);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CANT_OPEN);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CANT_CREATE); // (20)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_QUERY_FAILED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_ALREADY_IN_USE);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_LOCKED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_TIMEOUT);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CANT_CONNECT); // (25)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CANT_RESOLVE);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CONNECTION_ERROR);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CANT_ACQUIRE_RESOURCE);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CANT_FORK);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_INVALID_DATA); // (30)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_INVALID_PARAMETER);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_ALREADY_EXISTS);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_DOES_NOT_EXIST);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_DATABASE_CANT_READ);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_DATABASE_CANT_WRITE); // (35)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_COMPILATION_FAILED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_METHOD_NOT_FOUND);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_LINK_FAILED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_SCRIPT_FAILED);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_CYCLIC_LINK); // (40)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_INVALID_DECLARATION);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_DUPLICATE_SYMBOL);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_PARSE_ERROR);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_BUSY);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_SKIP); // (45)
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_HELP);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_BUG);
-	BIND_GLOBAL_ENUM_CONSTANT(ERR_PRINTER_ON_FIRE);
-
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_NONE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_RANGE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_EXP_RANGE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_ENUM);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_EXP_EASING);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_LENGTH);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_KEY_ACCEL);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_FLAGS);
-
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_2D_RENDER);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_2D_PHYSICS);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_3D_RENDER);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_LAYERS_3D_PHYSICS);
-
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_FILE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_DIR);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_GLOBAL_FILE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_GLOBAL_DIR);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_RESOURCE_TYPE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_MULTILINE_TEXT);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_PLACEHOLDER_TEXT);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_COLOR_NO_ALPHA);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_IMAGE_COMPRESS_LOSSY);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS);
-
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_STORAGE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_EDITOR);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_NETWORK);
-
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_EDITOR_HELPER);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_CHECKABLE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_CHECKED);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_INTERNATIONALIZED);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_GROUP);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_CATEGORY);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_SUBGROUP);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_NO_INSTANCE_STATE);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_RESTART_IF_CHANGED);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_SCRIPT_VARIABLE);
-
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_DEFAULT);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_DEFAULT_INTL);
-	BIND_GLOBAL_ENUM_CONSTANT(PROPERTY_USAGE_NOEDITOR);
-
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAG_NORMAL);
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAG_EDITOR);
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAG_NOSCRIPT);
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAG_CONST);
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAG_REVERSE);
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAG_VIRTUAL);
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAG_FROM_SCRIPT);
-	BIND_GLOBAL_ENUM_CONSTANT(METHOD_FLAGS_DEFAULT);
-
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_NIL", Variant::NIL);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_BOOL", Variant::BOOL);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_INT", Variant::INT);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_REAL", Variant::FLOAT);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_STRING", Variant::STRING);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR2", Variant::VECTOR2);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR2I", Variant::VECTOR2I);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_RECT2", Variant::RECT2);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_RECT2I", Variant::RECT2I);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR3", Variant::VECTOR3);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR3I", Variant::VECTOR3I);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_TRANSFORM2D", Variant::TRANSFORM2D);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_PLANE", Variant::PLANE);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_QUAT", Variant::QUAT);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_AABB", Variant::AABB);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_BASIS", Variant::BASIS);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_TRANSFORM", Variant::TRANSFORM);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_COLOR", Variant::COLOR);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_STRING_NAME", Variant::STRING_NAME);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_NODE_PATH", Variant::NODE_PATH);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_RID", Variant::_RID);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_OBJECT", Variant::OBJECT);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_CALLABLE", Variant::CALLABLE);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_SIGNAL", Variant::SIGNAL);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_DICTIONARY", Variant::DICTIONARY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_ARRAY", Variant::ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_RAW_ARRAY", Variant::PACKED_BYTE_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_INT32_ARRAY", Variant::PACKED_INT32_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_INT64_ARRAY", Variant::PACKED_INT64_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_FLOAT32_ARRAY", Variant::PACKED_FLOAT32_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_FLOAT64_ARRAY", Variant::PACKED_FLOAT64_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_STRING_ARRAY", Variant::PACKED_STRING_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR2_ARRAY", Variant::PACKED_VECTOR2_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_VECTOR3_ARRAY", Variant::PACKED_VECTOR3_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_COLOR_ARRAY", Variant::PACKED_COLOR_ARRAY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("TYPE_MAX", Variant::VARIANT_MAX);
-
-	//comparison
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_EQUAL", Variant::OP_EQUAL);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_NOT_EQUAL", Variant::OP_NOT_EQUAL);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_LESS", Variant::OP_LESS);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_LESS_EQUAL", Variant::OP_LESS_EQUAL);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_GREATER", Variant::OP_GREATER);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_GREATER_EQUAL", Variant::OP_GREATER_EQUAL);
-	//mathematic
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_ADD", Variant::OP_ADD);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_SUBTRACT", Variant::OP_SUBTRACT);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_MULTIPLY", Variant::OP_MULTIPLY);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_DIVIDE", Variant::OP_DIVIDE);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_NEGATE", Variant::OP_NEGATE);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_POSITIVE", Variant::OP_POSITIVE);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_MODULE", Variant::OP_MODULE);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_STRING_CONCAT", Variant::OP_STRING_CONCAT);
-	//bitwise
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_SHIFT_LEFT", Variant::OP_SHIFT_LEFT);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_SHIFT_RIGHT", Variant::OP_SHIFT_RIGHT);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_BIT_AND", Variant::OP_BIT_AND);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_BIT_OR", Variant::OP_BIT_OR);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_BIT_XOR", Variant::OP_BIT_XOR);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_BIT_NEGATE", Variant::OP_BIT_NEGATE);
-	//logic
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_AND", Variant::OP_AND);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_OR", Variant::OP_OR);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_XOR", Variant::OP_XOR);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_NOT", Variant::OP_NOT);
-	//containment
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_IN", Variant::OP_IN);
-	BIND_GLOBAL_ENUM_CONSTANT_CUSTOM("OP_MAX", Variant::OP_MAX);
-}
-
-void unregister_global_constants() {
-	_global_constants.clear();
-}
-
-int GlobalConstants::get_global_constant_count() {
-	return _global_constants.size();
-}
-
-#ifdef DEBUG_METHODS_ENABLED
-StringName GlobalConstants::get_global_constant_enum(int p_idx) {
-	return _global_constants[p_idx].enum_name;
-}
-
-bool GlobalConstants::get_ignore_value_in_docs(int p_idx) {
-	return _global_constants[p_idx].ignore_value_in_docs;
-}
-#else
-StringName GlobalConstants::get_global_constant_enum(int p_idx) {
-	return StringName();
-}
-
-bool GlobalConstants::get_ignore_value_in_docs(int p_idx) {
-	return false;
-}
-#endif
-
-const char *GlobalConstants::get_global_constant_name(int p_idx) {
-	return _global_constants[p_idx].name;
-}
-
-int GlobalConstants::get_global_constant_value(int p_idx) {
-	return _global_constants[p_idx].value;
-}
diff --git a/core/input/input.cpp b/core/input/input.cpp
index b0b1d20222..ee66bf94cb 100644
--- a/core/input/input.cpp
+++ b/core/input/input.cpp
@@ -30,10 +30,10 @@
 
 #include "input.h"
 
+#include "core/config/project_settings.h"
 #include "core/input/default_controller_mappings.h"
 #include "core/input/input_map.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 #ifdef TOOLS_ENABLED
 #include "editor/editor_settings.h"
diff --git a/core/input/input.h b/core/input/input.h
index 60e378d72c..98bbff6441 100644
--- a/core/input/input.h
+++ b/core/input/input.h
@@ -32,7 +32,7 @@
 #define INPUT_H
 
 #include "core/input/input_event.h"
-#include "core/object.h"
+#include "core/object/object.h"
 #include "core/os/thread_safe.h"
 
 class Input : public Object {
diff --git a/core/input/input_event.h b/core/input/input_event.h
index 815ba5ae80..8b58cf08c2 100644
--- a/core/input/input_event.h
+++ b/core/input/input_event.h
@@ -31,11 +31,11 @@
 #ifndef INPUT_EVENT_H
 #define INPUT_EVENT_H
 
+#include "core/io/resource.h"
 #include "core/math/transform_2d.h"
 #include "core/os/copymem.h"
-#include "core/resource.h"
+#include "core/string/ustring.h"
 #include "core/typedefs.h"
-#include "core/ustring.h"
 
 /**
  * Input Event classes. These are used in the main loop.
diff --git a/core/input/input_map.cpp b/core/input/input_map.cpp
index 6319ffc8f1..ba1de3c58d 100644
--- a/core/input/input_map.cpp
+++ b/core/input/input_map.cpp
@@ -30,8 +30,8 @@
 
 #include "input_map.h"
 
+#include "core/config/project_settings.h"
 #include "core/os/keyboard.h"
-#include "core/project_settings.h"
 
 InputMap *InputMap::singleton = nullptr;
 
diff --git a/core/input/input_map.h b/core/input/input_map.h
index 755df26984..35c65d0881 100644
--- a/core/input/input_map.h
+++ b/core/input/input_map.h
@@ -31,8 +31,8 @@
 #ifndef INPUT_MAP_H
 #define INPUT_MAP_H
 
-#include "core/class_db.h"
 #include "core/input/input_event.h"
+#include "core/object/class_db.h"
 
 class InputMap : public Object {
 	GDCLASS(InputMap, Object);
diff --git a/core/int_types.h b/core/int_types.h
deleted file mode 100644
index 71caa2202d..0000000000
--- a/core/int_types.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*************************************************************************/
-/*  int_types.h                                                          */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#ifndef INT_TYPES_H
-#define INT_TYPES_H
-
-#ifdef _MSC_VER
-
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-
-#else
-
-#ifdef NO_STDINT_H
-typedef unsigned char uint8_t;
-typedef signed char int8_t;
-typedef unsigned short uint16_t;
-typedef signed short int16_t;
-typedef unsigned int uint32_t;
-typedef signed int int32_t;
-typedef long long int64_t;
-typedef unsigned long long uint64_t;
-#else
-#include <stdint.h>
-#endif
-
-#endif // _MSC_VER
-
-#endif // INT_TYPES_H
diff --git a/core/io/compression.cpp b/core/io/compression.cpp
index 7480262835..cd8793bb0a 100644
--- a/core/io/compression.cpp
+++ b/core/io/compression.cpp
@@ -30,9 +30,9 @@
 
 #include "compression.h"
 
+#include "core/config/project_settings.h"
 #include "core/io/zip_io.h"
 #include "core/os/copymem.h"
-#include "core/project_settings.h"
 
 #include "thirdparty/misc/fastlz.h"
 
diff --git a/core/io/compression.h b/core/io/compression.h
index c103fa8eae..864869788a 100644
--- a/core/io/compression.h
+++ b/core/io/compression.h
@@ -31,8 +31,8 @@
 #ifndef COMPRESSION_H
 #define COMPRESSION_H
 
+#include "core/templates/vector.h"
 #include "core/typedefs.h"
-#include "core/vector.h"
 
 class Compression {
 public:
diff --git a/core/io/config_file.cpp b/core/io/config_file.cpp
index 1af9142317..8be39178db 100644
--- a/core/io/config_file.cpp
+++ b/core/io/config_file.cpp
@@ -32,7 +32,7 @@
 
 #include "core/io/file_access_encrypted.h"
 #include "core/os/keyboard.h"
-#include "core/variant_parser.h"
+#include "core/variant/variant_parser.h"
 
 PackedStringArray ConfigFile::_get_sections() const {
 	List<String> s;
diff --git a/core/io/config_file.h b/core/io/config_file.h
index ae06960f02..1dc4492ca8 100644
--- a/core/io/config_file.h
+++ b/core/io/config_file.h
@@ -31,10 +31,10 @@
 #ifndef CONFIG_FILE_H
 #define CONFIG_FILE_H
 
-#include "core/ordered_hash_map.h"
+#include "core/object/reference.h"
 #include "core/os/file_access.h"
-#include "core/reference.h"
-#include "core/variant_parser.h"
+#include "core/templates/ordered_hash_map.h"
+#include "core/variant/variant_parser.h"
 
 class ConfigFile : public Reference {
 	GDCLASS(ConfigFile, Reference);
diff --git a/core/io/dtls_server.cpp b/core/io/dtls_server.cpp
index e43b1f5385..1930f40c47 100644
--- a/core/io/dtls_server.cpp
+++ b/core/io/dtls_server.cpp
@@ -30,8 +30,8 @@
 
 #include "dtls_server.h"
 
+#include "core/config/project_settings.h"
 #include "core/os/file_access.h"
-#include "core/project_settings.h"
 
 DTLSServer *(*DTLSServer::_create)() = nullptr;
 bool DTLSServer::available = false;
diff --git a/core/io/file_access_buffered.cpp b/core/io/file_access_buffered.cpp
index 6208f3a4d1..714f3b6099 100644
--- a/core/io/file_access_buffered.cpp
+++ b/core/io/file_access_buffered.cpp
@@ -30,7 +30,7 @@
 
 #include "file_access_buffered.h"
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 
 Error FileAccessBuffered::set_error(Error p_error) const {
 	return (last_error = p_error);
diff --git a/core/io/file_access_buffered.h b/core/io/file_access_buffered.h
index 99d5ce903d..7fd99b6373 100644
--- a/core/io/file_access_buffered.h
+++ b/core/io/file_access_buffered.h
@@ -33,7 +33,7 @@
 
 #include "core/os/file_access.h"
 
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 class FileAccessBuffered : public FileAccess {
 public:
diff --git a/core/io/file_access_compressed.cpp b/core/io/file_access_compressed.cpp
index 7817ccb773..4424192af2 100644
--- a/core/io/file_access_compressed.cpp
+++ b/core/io/file_access_compressed.cpp
@@ -30,7 +30,7 @@
 
 #include "file_access_compressed.h"
 
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 void FileAccessCompressed::configure(const String &p_magic, Compression::Mode p_mode, int p_block_size) {
 	magic = p_magic.ascii().get_data();
diff --git a/core/io/file_access_encrypted.cpp b/core/io/file_access_encrypted.cpp
index eb684f457e..2ac24d5169 100644
--- a/core/io/file_access_encrypted.cpp
+++ b/core/io/file_access_encrypted.cpp
@@ -32,8 +32,8 @@
 
 #include "core/crypto/crypto_core.h"
 #include "core/os/copymem.h"
-#include "core/print_string.h"
-#include "core/variant.h"
+#include "core/string/print_string.h"
+#include "core/variant/variant.h"
 
 #include <stdio.h>
 
diff --git a/core/io/file_access_memory.cpp b/core/io/file_access_memory.cpp
index a65ff92a89..79cba63765 100644
--- a/core/io/file_access_memory.cpp
+++ b/core/io/file_access_memory.cpp
@@ -30,10 +30,10 @@
 
 #include "file_access_memory.h"
 
-#include "core/map.h"
+#include "core/config/project_settings.h"
 #include "core/os/copymem.h"
 #include "core/os/dir_access.h"
-#include "core/project_settings.h"
+#include "core/templates/map.h"
 
 static Map<String, Vector<uint8_t>> *files = nullptr;
 
diff --git a/core/io/file_access_network.cpp b/core/io/file_access_network.cpp
index 6890740d90..1e9266f118 100644
--- a/core/io/file_access_network.cpp
+++ b/core/io/file_access_network.cpp
@@ -30,10 +30,10 @@
 
 #include "file_access_network.h"
 
+#include "core/config/project_settings.h"
 #include "core/io/ip.h"
 #include "core/io/marshalls.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 //#define DEBUG_PRINT(m_p) print_line(m_p)
 //#define DEBUG_TIME(m_what) printf("MS: %s - %lli\n",m_what,OS::get_singleton()->get_ticks_usec());
diff --git a/core/io/file_access_pack.cpp b/core/io/file_access_pack.cpp
index 8fdbb650d4..b63e0adc45 100644
--- a/core/io/file_access_pack.cpp
+++ b/core/io/file_access_pack.cpp
@@ -31,7 +31,7 @@
 #include "file_access_pack.h"
 
 #include "core/io/file_access_encrypted.h"
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 #include "core/version.h"
 
 #include <stdio.h>
diff --git a/core/io/file_access_pack.h b/core/io/file_access_pack.h
index d934b0deb5..5c58dc01b4 100644
--- a/core/io/file_access_pack.h
+++ b/core/io/file_access_pack.h
@@ -31,11 +31,11 @@
 #ifndef FILE_ACCESS_PACK_H
 #define FILE_ACCESS_PACK_H
 
-#include "core/list.h"
-#include "core/map.h"
 #include "core/os/dir_access.h"
 #include "core/os/file_access.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
+#include "core/templates/list.h"
+#include "core/templates/map.h"
 
 // Godot's packed file magic header ("GDPC" in ASCII).
 #define PACK_HEADER_MAGIC 0x43504447
diff --git a/core/io/file_access_zip.h b/core/io/file_access_zip.h
index c251b3c424..eff07c60e2 100644
--- a/core/io/file_access_zip.h
+++ b/core/io/file_access_zip.h
@@ -34,7 +34,7 @@
 #ifdef MINIZIP_ENABLED
 
 #include "core/io/file_access_pack.h"
-#include "core/map.h"
+#include "core/templates/map.h"
 
 #include "thirdparty/minizip/unzip.h"
 
diff --git a/core/io/http_client.h b/core/io/http_client.h
index 1dc1f3d76a..ece7e1924b 100644
--- a/core/io/http_client.h
+++ b/core/io/http_client.h
@@ -34,7 +34,7 @@
 #include "core/io/ip.h"
 #include "core/io/stream_peer.h"
 #include "core/io/stream_peer_tcp.h"
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class HTTPClient : public Reference {
 	GDCLASS(HTTPClient, Reference);
@@ -182,7 +182,8 @@ private:
 
 	int response_num = 0;
 	Vector<String> response_headers;
-	int read_chunk_size = 4096;
+	// 64 KiB by default (favors fast download speeds at the cost of memory usage).
+	int read_chunk_size = 65536;
 
 	Error _get_http_data(uint8_t *p_buffer, int p_bytes, int &r_received);
 
diff --git a/core/image.cpp b/core/io/image.cpp
index b8a443eed2..005fd481e8 100644
--- a/core/image.cpp
+++ b/core/io/image.cpp
@@ -30,13 +30,13 @@
 
 #include "image.h"
 
-#include "core/error_macros.h"
-#include "core/hash_map.h"
+#include "core/error/error_macros.h"
 #include "core/io/image_loader.h"
 #include "core/io/resource_loader.h"
 #include "core/math/math_funcs.h"
 #include "core/os/copymem.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
+#include "core/templates/hash_map.h"
 
 #include <stdio.h>
 
@@ -2711,6 +2711,7 @@ ImageMemLoadFunc Image::_png_mem_loader_func = nullptr;
 ImageMemLoadFunc Image::_jpg_mem_loader_func = nullptr;
 ImageMemLoadFunc Image::_webp_mem_loader_func = nullptr;
 ImageMemLoadFunc Image::_tga_mem_loader_func = nullptr;
+ImageMemLoadFunc Image::_bmp_mem_loader_func = nullptr;
 
 void (*Image::_image_compress_bc_func)(Image *, float, Image::UsedChannels) = nullptr;
 void (*Image::_image_compress_bptc_func)(Image *, float, Image::UsedChannels) = nullptr;
@@ -3141,6 +3142,7 @@ void Image::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("load_jpg_from_buffer", "buffer"), &Image::load_jpg_from_buffer);
 	ClassDB::bind_method(D_METHOD("load_webp_from_buffer", "buffer"), &Image::load_webp_from_buffer);
 	ClassDB::bind_method(D_METHOD("load_tga_from_buffer", "buffer"), &Image::load_tga_from_buffer);
+	ClassDB::bind_method(D_METHOD("load_bmp_from_buffer", "buffer"), &Image::load_bmp_from_buffer);
 
 	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE), "_set_data", "_get_data");
 
@@ -3473,10 +3475,21 @@ Error Image::load_webp_from_buffer(const Vector<uint8_t> &p_array) {
 }
 
 Error Image::load_tga_from_buffer(const Vector<uint8_t> &p_array) {
-	ERR_FAIL_NULL_V_MSG(_tga_mem_loader_func, ERR_UNAVAILABLE, "TGA module was not installed.");
+	ERR_FAIL_NULL_V_MSG(
+			_tga_mem_loader_func,
+			ERR_UNAVAILABLE,
+			"The TGA module isn't enabled. Recompile the Godot editor or export template binary with the `module_tga_enabled=yes` SCons option.");
 	return _load_from_buffer(p_array, _tga_mem_loader_func);
 }
 
+Error Image::load_bmp_from_buffer(const Vector<uint8_t> &p_array) {
+	ERR_FAIL_NULL_V_MSG(
+			_bmp_mem_loader_func,
+			ERR_UNAVAILABLE,
+			"The BMP module isn't enabled. Recompile the Godot editor or export template binary with the `module_bmp_enabled=yes` SCons option.");
+	return _load_from_buffer(p_array, _bmp_mem_loader_func);
+}
+
 void Image::convert_rg_to_ra_rgba8() {
 	ERR_FAIL_COND(format != FORMAT_RGBA8);
 	ERR_FAIL_COND(!data.size());
diff --git a/core/image.h b/core/io/image.h
index 06794c7fed..fecb90cab0 100644
--- a/core/image.h
+++ b/core/io/image.h
@@ -31,9 +31,9 @@
 #ifndef IMAGE_H
 #define IMAGE_H
 
-#include "core/color.h"
+#include "core/io/resource.h"
+#include "core/math/color.h"
 #include "core/math/rect2.h"
-#include "core/resource.h"
 
 /**
  *	@author Juan Linietsky <reduzio@gmail.com>
@@ -136,6 +136,7 @@ public:
 	static ImageMemLoadFunc _jpg_mem_loader_func;
 	static ImageMemLoadFunc _webp_mem_loader_func;
 	static ImageMemLoadFunc _tga_mem_loader_func;
+	static ImageMemLoadFunc _bmp_mem_loader_func;
 
 	static void (*_image_compress_bc_func)(Image *, float, UsedChannels p_channels);
 	static void (*_image_compress_bptc_func)(Image *, float p_lossy_quality, UsedChannels p_channels);
@@ -375,6 +376,7 @@ public:
 	Error load_jpg_from_buffer(const Vector<uint8_t> &p_array);
 	Error load_webp_from_buffer(const Vector<uint8_t> &p_array);
 	Error load_tga_from_buffer(const Vector<uint8_t> &p_array);
+	Error load_bmp_from_buffer(const Vector<uint8_t> &p_array);
 
 	void convert_rg_to_ra_rgba8();
 	void convert_ra_rgba8_to_rg();
diff --git a/core/io/image_loader.cpp b/core/io/image_loader.cpp
index b1e92eb87f..f6d8668349 100644
--- a/core/io/image_loader.cpp
+++ b/core/io/image_loader.cpp
@@ -30,7 +30,7 @@
 
 #include "image_loader.h"
 
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 bool ImageFormatLoader::recognize(const String &p_extension) const {
 	List<String> extensions;
diff --git a/core/io/image_loader.h b/core/io/image_loader.h
index 9682f144c7..d5fb4678eb 100644
--- a/core/io/image_loader.h
+++ b/core/io/image_loader.h
@@ -31,11 +31,11 @@
 #ifndef IMAGE_LOADER_H
 #define IMAGE_LOADER_H
 
-#include "core/image.h"
+#include "core/io/image.h"
 #include "core/io/resource_loader.h"
-#include "core/list.h"
 #include "core/os/file_access.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
+#include "core/templates/list.h"
 
 class ImageLoader;
 
diff --git a/core/io/ip.cpp b/core/io/ip.cpp
index 24b8ec7cc1..9f3540efad 100644
--- a/core/io/ip.cpp
+++ b/core/io/ip.cpp
@@ -30,9 +30,9 @@
 
 #include "ip.h"
 
-#include "core/hash_map.h"
 #include "core/os/semaphore.h"
 #include "core/os/thread.h"
+#include "core/templates/hash_map.h"
 
 VARIANT_ENUM_CAST(IP::ResolverStatus);
 
diff --git a/core/io/ip_address.h b/core/io/ip_address.h
index 2f8f83503e..7a813230f5 100644
--- a/core/io/ip_address.h
+++ b/core/io/ip_address.h
@@ -31,7 +31,7 @@
 #ifndef IP_ADDRESS_H
 #define IP_ADDRESS_H
 
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 struct IP_Address {
 private:
diff --git a/core/io/json.cpp b/core/io/json.cpp
index 1b89d966fd..58bce1cf63 100644
--- a/core/io/json.cpp
+++ b/core/io/json.cpp
@@ -30,7 +30,7 @@
 
 #include "json.h"
 
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 const char *JSON::tk_name[TK_MAX] = {
 	"'{'",
diff --git a/core/io/json.h b/core/io/json.h
index 9122228163..9fc6655fb4 100644
--- a/core/io/json.h
+++ b/core/io/json.h
@@ -31,7 +31,7 @@
 #ifndef JSON_H
 #define JSON_H
 
-#include "core/variant.h"
+#include "core/variant/variant.h"
 
 class JSON {
 	enum TokenType {
diff --git a/core/io/logger.cpp b/core/io/logger.cpp
index 886e5695b1..0e6a2e2c9f 100644
--- a/core/io/logger.cpp
+++ b/core/io/logger.cpp
@@ -32,7 +32,7 @@
 
 #include "core/os/dir_access.h"
 #include "core/os/os.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 #if defined(MINGW_ENABLED) || defined(_MSC_VER)
 #define sprintf sprintf_s
diff --git a/core/io/logger.h b/core/io/logger.h
index 277be9ed35..9eaf506c51 100644
--- a/core/io/logger.h
+++ b/core/io/logger.h
@@ -32,8 +32,8 @@
 #define LOGGER_H
 
 #include "core/os/file_access.h"
-#include "core/ustring.h"
-#include "core/vector.h"
+#include "core/string/ustring.h"
+#include "core/templates/vector.h"
 
 #include <stdarg.h>
 
diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp
index eb39b1433f..3cf4acaf39 100644
--- a/core/io/marshalls.cpp
+++ b/core/io/marshalls.cpp
@@ -30,9 +30,9 @@
 
 #include "marshalls.h"
 
+#include "core/object/reference.h"
 #include "core/os/keyboard.h"
-#include "core/print_string.h"
-#include "core/reference.h"
+#include "core/string/print_string.h"
 
 #include <limits.h>
 #include <stdio.h>
@@ -420,7 +420,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 			}
 
 		} break;
-		case Variant::_RID: {
+		case Variant::RID: {
 			r_variant = RID();
 		} break;
 		case Variant::OBJECT: {
@@ -1172,7 +1172,7 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bo
 			r_len += 4 * 4;
 
 		} break;
-		case Variant::_RID: {
+		case Variant::RID: {
 		} break;
 		case Variant::CALLABLE: {
 		} break;
diff --git a/core/io/marshalls.h b/core/io/marshalls.h
index c8ed497528..6969a9b500 100644
--- a/core/io/marshalls.h
+++ b/core/io/marshalls.h
@@ -31,9 +31,9 @@
 #ifndef MARSHALLS_H
 #define MARSHALLS_H
 
-#include "core/reference.h"
+#include "core/object/reference.h"
 #include "core/typedefs.h"
-#include "core/variant.h"
+#include "core/variant/variant.h"
 
 /**
   * Miscellaneous helpers for marshalling data types, and encoding
diff --git a/core/io/multiplayer_api.h b/core/io/multiplayer_api.h
index 06eab7796c..e0ce1c8ca4 100644
--- a/core/io/multiplayer_api.h
+++ b/core/io/multiplayer_api.h
@@ -32,7 +32,7 @@
 #define MULTIPLAYER_API_H
 
 #include "core/io/networked_multiplayer_peer.h"
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class MultiplayerAPI : public Reference {
 	GDCLASS(MultiplayerAPI, Reference);
diff --git a/core/io/net_socket.h b/core/io/net_socket.h
index 746945eced..67d0253985 100644
--- a/core/io/net_socket.h
+++ b/core/io/net_socket.h
@@ -32,7 +32,7 @@
 #define NET_SOCKET_H
 
 #include "core/io/ip.h"
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class NetSocket : public Reference {
 protected:
diff --git a/core/packed_data_container.cpp b/core/io/packed_data_container.cpp
index e335ec0daa..fbe8fa8a28 100644
--- a/core/packed_data_container.cpp
+++ b/core/io/packed_data_container.cpp
@@ -39,6 +39,9 @@ Variant PackedDataContainer::getvar(const Variant &p_key, bool *r_valid) const {
 	if (r_valid) {
 		*r_valid = !err;
 	}
+	if (err) {
+		return Object::getvar(p_key, r_valid);
+	}
 	return ret;
 }
 
@@ -243,7 +246,7 @@ uint32_t PackedDataContainer::_pack(const Variant &p_data, Vector<uint8_t> &tmpd
 
 		} break;
 		// misc types
-		case Variant::_RID:
+		case Variant::RID:
 		case Variant::OBJECT: {
 			return _pack(Variant(), tmpdata, string_cache);
 		} break;
diff --git a/core/packed_data_container.h b/core/io/packed_data_container.h
index 28ec9cc87c..b784abcd16 100644
--- a/core/packed_data_container.h
+++ b/core/io/packed_data_container.h
@@ -31,7 +31,7 @@
 #ifndef PACKED_DATA_CONTAINER_H
 #define PACKED_DATA_CONTAINER_H
 
-#include "core/resource.h"
+#include "core/io/resource.h"
 
 class PackedDataContainer : public Resource {
 	GDCLASS(PackedDataContainer, Resource);
diff --git a/core/io/packet_peer.cpp b/core/io/packet_peer.cpp
index dacd548a3e..b6cc5bf42a 100644
--- a/core/io/packet_peer.cpp
+++ b/core/io/packet_peer.cpp
@@ -30,8 +30,8 @@
 
 #include "packet_peer.h"
 
+#include "core/config/project_settings.h"
 #include "core/io/marshalls.h"
-#include "core/project_settings.h"
 
 /* helpers / binders */
 
diff --git a/core/io/packet_peer.h b/core/io/packet_peer.h
index fb4dc181db..f7f080aa43 100644
--- a/core/io/packet_peer.h
+++ b/core/io/packet_peer.h
@@ -31,9 +31,9 @@
 #ifndef PACKET_PEER_H
 #define PACKET_PEER_H
 
-#include "core/class_db.h"
 #include "core/io/stream_peer.h"
-#include "core/ring_buffer.h"
+#include "core/object/class_db.h"
+#include "core/templates/ring_buffer.h"
 
 class PacketPeer : public Reference {
 	GDCLASS(PacketPeer, Reference);
diff --git a/core/io/packet_peer_dtls.cpp b/core/io/packet_peer_dtls.cpp
index 632f86a9f6..9f6fccc993 100644
--- a/core/io/packet_peer_dtls.cpp
+++ b/core/io/packet_peer_dtls.cpp
@@ -29,8 +29,8 @@
 /*************************************************************************/
 
 #include "packet_peer_dtls.h"
+#include "core/config/project_settings.h"
 #include "core/os/file_access.h"
-#include "core/project_settings.h"
 
 PacketPeerDTLS *(*PacketPeerDTLS::_create)() = nullptr;
 bool PacketPeerDTLS::available = false;
diff --git a/core/io/pck_packer.h b/core/io/pck_packer.h
index a6054dff2c..c1026c2499 100644
--- a/core/io/pck_packer.h
+++ b/core/io/pck_packer.h
@@ -31,7 +31,7 @@
 #ifndef PCK_PACKER_H
 #define PCK_PACKER_H
 
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class FileAccess;
 
diff --git a/core/resource.cpp b/core/io/resource.cpp
index 3b589793ef..5b249f7af3 100644
--- a/core/resource.cpp
+++ b/core/io/resource.cpp
@@ -32,9 +32,9 @@
 
 #include "core/core_string_names.h"
 #include "core/io/resource_loader.h"
+#include "core/object/script_language.h"
 #include "core/os/file_access.h"
 #include "core/os/os.h"
-#include "core/script_language.h"
 #include "scene/main/node.h" //only so casting works
 
 #include <stdio.h>
diff --git a/core/resource.h b/core/io/resource.h
index 41707f216d..6e0bd7d7f4 100644
--- a/core/resource.h
+++ b/core/io/resource.h
@@ -31,10 +31,10 @@
 #ifndef RESOURCE_H
 #define RESOURCE_H
 
-#include "core/class_db.h"
-#include "core/reference.h"
-#include "core/safe_refcount.h"
-#include "core/self_list.h"
+#include "core/object/class_db.h"
+#include "core/object/reference.h"
+#include "core/templates/safe_refcount.h"
+#include "core/templates/self_list.h"
 
 #define RES_BASE_EXTENSION(m_ext)                                                                                   \
 public:                                                                                                             \
diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp
index 21de7835ce..c67e68e4fc 100644
--- a/core/io/resource_format_binary.cpp
+++ b/core/io/resource_format_binary.cpp
@@ -30,11 +30,11 @@
 
 #include "resource_format_binary.h"
 
-#include "core/image.h"
+#include "core/config/project_settings.h"
 #include "core/io/file_access_compressed.h"
+#include "core/io/image.h"
 #include "core/io/marshalls.h"
 #include "core/os/dir_access.h"
-#include "core/project_settings.h"
 #include "core/version.h"
 
 //#define print_bl(m_what) print_line(m_what)
@@ -1467,7 +1467,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(FileAccess *f, const Varia
 			}
 
 		} break;
-		case Variant::_RID: {
+		case Variant::RID: {
 			f->store_32(VARIANT_RID);
 			WARN_PRINT("Can't save RIDs.");
 			RID val = p_property;
diff --git a/core/io/resource_importer.cpp b/core/io/resource_importer.cpp
index 4d980bcf1a..c88331cf9e 100644
--- a/core/io/resource_importer.cpp
+++ b/core/io/resource_importer.cpp
@@ -30,9 +30,9 @@
 
 #include "resource_importer.h"
 
+#include "core/config/project_settings.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
-#include "core/variant_parser.h"
+#include "core/variant/variant_parser.h"
 
 bool ResourceFormatImporter::SortImporterByName::operator()(const Ref<ResourceImporter> &p_a, const Ref<ResourceImporter> &p_b) const {
 	return p_a->get_importer_name() < p_b->get_importer_name();
diff --git a/core/io/resource_loader.cpp b/core/io/resource_loader.cpp
index b5c598e860..9991ee405e 100644
--- a/core/io/resource_loader.cpp
+++ b/core/io/resource_loader.cpp
@@ -30,13 +30,13 @@
 
 #include "resource_loader.h"
 
+#include "core/config/project_settings.h"
 #include "core/io/resource_importer.h"
 #include "core/os/file_access.h"
 #include "core/os/os.h"
-#include "core/print_string.h"
-#include "core/project_settings.h"
-#include "core/translation.h"
-#include "core/variant_parser.h"
+#include "core/string/print_string.h"
+#include "core/string/translation.h"
+#include "core/variant/variant_parser.h"
 
 #ifdef DEBUG_LOAD_THREADED
 #define print_lt(m_text) print_line(m_text)
diff --git a/core/io/resource_loader.h b/core/io/resource_loader.h
index 9322b5273a..02c668f214 100644
--- a/core/io/resource_loader.h
+++ b/core/io/resource_loader.h
@@ -31,9 +31,9 @@
 #ifndef RESOURCE_LOADER_H
 #define RESOURCE_LOADER_H
 
+#include "core/io/resource.h"
 #include "core/os/semaphore.h"
 #include "core/os/thread.h"
-#include "core/resource.h"
 
 class ResourceFormatLoader : public Reference {
 	GDCLASS(ResourceFormatLoader, Reference);
diff --git a/core/io/resource_saver.cpp b/core/io/resource_saver.cpp
index a8da215b61..2eac2a6b4d 100644
--- a/core/io/resource_saver.cpp
+++ b/core/io/resource_saver.cpp
@@ -29,10 +29,10 @@
 /*************************************************************************/
 
 #include "resource_saver.h"
+#include "core/config/project_settings.h"
 #include "core/io/resource_loader.h"
+#include "core/object/script_language.h"
 #include "core/os/file_access.h"
-#include "core/project_settings.h"
-#include "core/script_language.h"
 
 Ref<ResourceFormatSaver> ResourceSaver::saver[MAX_SAVERS];
 
diff --git a/core/io/resource_saver.h b/core/io/resource_saver.h
index 8b4cdd86f8..2e2950af53 100644
--- a/core/io/resource_saver.h
+++ b/core/io/resource_saver.h
@@ -31,7 +31,7 @@
 #ifndef RESOURCE_SAVER_H
 #define RESOURCE_SAVER_H
 
-#include "core/resource.h"
+#include "core/io/resource.h"
 
 class ResourceFormatSaver : public Reference {
 	GDCLASS(ResourceFormatSaver, Reference);
diff --git a/core/io/stream_peer.h b/core/io/stream_peer.h
index 39097a57f2..8c1e918dd8 100644
--- a/core/io/stream_peer.h
+++ b/core/io/stream_peer.h
@@ -31,7 +31,7 @@
 #ifndef STREAM_PEER_H
 #define STREAM_PEER_H
 
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class StreamPeer : public Reference {
 	GDCLASS(StreamPeer, Reference);
diff --git a/core/io/stream_peer_ssl.cpp b/core/io/stream_peer_ssl.cpp
index 3dc31c6769..daf36a5350 100644
--- a/core/io/stream_peer_ssl.cpp
+++ b/core/io/stream_peer_ssl.cpp
@@ -30,7 +30,7 @@
 
 #include "stream_peer_ssl.h"
 
-#include "core/engine.h"
+#include "core/config/engine.h"
 
 StreamPeerSSL *(*StreamPeerSSL::_create)() = nullptr;
 
diff --git a/core/io/stream_peer_tcp.cpp b/core/io/stream_peer_tcp.cpp
index cce728c30a..aa9c409528 100644
--- a/core/io/stream_peer_tcp.cpp
+++ b/core/io/stream_peer_tcp.cpp
@@ -30,7 +30,7 @@
 
 #include "stream_peer_tcp.h"
 
-#include "core/project_settings.h"
+#include "core/config/project_settings.h"
 
 Error StreamPeerTCP::_poll_connection() {
 	ERR_FAIL_COND_V(status != STATUS_CONNECTING || !_sock.is_valid() || !_sock->is_open(), FAILED);
diff --git a/core/io/translation_loader_po.cpp b/core/io/translation_loader_po.cpp
index d8ddb213c3..34cccca540 100644
--- a/core/io/translation_loader_po.cpp
+++ b/core/io/translation_loader_po.cpp
@@ -31,8 +31,8 @@
 #include "translation_loader_po.h"
 
 #include "core/os/file_access.h"
-#include "core/translation.h"
-#include "core/translation_po.h"
+#include "core/string/translation.h"
+#include "core/string/translation_po.h"
 
 RES TranslationLoaderPO::load_translation(FileAccess *f, Error *r_error) {
 	enum Status {
diff --git a/core/io/translation_loader_po.h b/core/io/translation_loader_po.h
index a196a37dc0..16c9f1e680 100644
--- a/core/io/translation_loader_po.h
+++ b/core/io/translation_loader_po.h
@@ -33,7 +33,7 @@
 
 #include "core/io/resource_loader.h"
 #include "core/os/file_access.h"
-#include "core/translation.h"
+#include "core/string/translation.h"
 
 class TranslationLoaderPO : public ResourceFormatLoader {
 public:
diff --git a/core/io/xml_parser.cpp b/core/io/xml_parser.cpp
index fc75ac7d1e..85143c0f04 100644
--- a/core/io/xml_parser.cpp
+++ b/core/io/xml_parser.cpp
@@ -30,7 +30,7 @@
 
 #include "xml_parser.h"
 
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 //#define DEBUG_XML
 
diff --git a/core/io/xml_parser.h b/core/io/xml_parser.h
index ee2174d52c..d8cc26b4c1 100644
--- a/core/io/xml_parser.h
+++ b/core/io/xml_parser.h
@@ -31,10 +31,10 @@
 #ifndef XML_PARSER_H
 #define XML_PARSER_H
 
+#include "core/object/reference.h"
 #include "core/os/file_access.h"
-#include "core/reference.h"
-#include "core/ustring.h"
-#include "core/vector.h"
+#include "core/string/ustring.h"
+#include "core/templates/vector.h"
 
 /*
   Based on irrXML (see their zlib license). Added mainly for compatibility with their Collada loader.
diff --git a/core/math/a_star.cpp b/core/math/a_star.cpp
index 30f712b2c3..b4410acf7d 100644
--- a/core/math/a_star.cpp
+++ b/core/math/a_star.cpp
@@ -31,7 +31,7 @@
 #include "a_star.h"
 
 #include "core/math/geometry_3d.h"
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 #include "scene/scene_string_names.h"
 
 int AStar::get_available_point_id() const {
diff --git a/core/math/a_star.h b/core/math/a_star.h
index ba1c3033b8..a6fa771b30 100644
--- a/core/math/a_star.h
+++ b/core/math/a_star.h
@@ -31,8 +31,8 @@
 #ifndef A_STAR_H
 #define A_STAR_H
 
-#include "core/oa_hash_map.h"
-#include "core/reference.h"
+#include "core/object/reference.h"
+#include "core/templates/oa_hash_map.h"
 
 /**
 	A* pathfinding algorithm
diff --git a/core/math/aabb.cpp b/core/math/aabb.cpp
index e868ebc7c8..08673d0dd1 100644
--- a/core/math/aabb.cpp
+++ b/core/math/aabb.cpp
@@ -30,8 +30,8 @@
 
 #include "aabb.h"
 
-#include "core/print_string.h"
-#include "core/variant.h"
+#include "core/string/print_string.h"
+#include "core/variant/variant.h"
 
 real_t AABB::get_area() const {
 	return size.x * size.y * size.z;
diff --git a/core/math/aabb.h b/core/math/aabb.h
index 8c08754e1c..45dcbc7f7f 100644
--- a/core/math/aabb.h
+++ b/core/math/aabb.h
@@ -107,6 +107,14 @@ public:
 	Variant intersects_segment_bind(const Vector3 &p_from, const Vector3 &p_to) const;
 	Variant intersects_ray_bind(const Vector3 &p_from, const Vector3 &p_dir) const;
 
+	_FORCE_INLINE_ void set_end(const Vector3 &p_end) {
+		size = p_end - position;
+	}
+
+	_FORCE_INLINE_ Vector3 get_end() const {
+		return position + size;
+	}
+
 	operator String() const;
 
 	_FORCE_INLINE_ AABB() {}
diff --git a/core/math/basis.cpp b/core/math/basis.cpp
index a712ae7e3e..c6030d9757 100644
--- a/core/math/basis.cpp
+++ b/core/math/basis.cpp
@@ -32,7 +32,7 @@
 
 #include "core/math/math_funcs.h"
 #include "core/os/copymem.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 #define cofac(row1, col1, row2, col2) \
 	(elements[row1][col1] * elements[row2][col2] - elements[row1][col2] * elements[row2][col1])
diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp
index c154d57a13..5e5efb6356 100644
--- a/core/math/camera_matrix.cpp
+++ b/core/math/camera_matrix.cpp
@@ -31,7 +31,7 @@
 #include "camera_matrix.h"
 
 #include "core/math/math_funcs.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 float CameraMatrix::determinant() const {
 	return matrix[0][3] * matrix[1][2] * matrix[2][1] * matrix[3][0] - matrix[0][2] * matrix[1][3] * matrix[2][1] * matrix[3][0] -
diff --git a/core/color.cpp b/core/math/color.cpp
index 4047ca5037..2afe14bd63 100644
--- a/core/color.cpp
+++ b/core/math/color.cpp
@@ -30,10 +30,10 @@
 
 #include "color.h"
 
-#include "core/color_names.inc"
-#include "core/map.h"
+#include "color_names.inc"
 #include "core/math/math_funcs.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
+#include "core/templates/map.h"
 
 uint32_t Color::to_argb32() const {
 	uint32_t c = (uint8_t)Math::round(a * 255);
@@ -159,7 +159,7 @@ void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha) {
 	a = p_alpha;
 
 	if (p_s == 0) {
-		// acp_hromatic (grey)
+		// Achromatic (grey)
 		r = g = b = p_v;
 		return;
 	}
@@ -355,9 +355,6 @@ bool Color::html_is_valid(const String &p_color) {
 }
 
 Color Color::named(const String &p_name) {
-	if (_named_colors.empty()) {
-		_populate_named_colors(); // from color_names.inc
-	}
 	String name = p_name;
 	// Normalize name
 	name = name.replace(" ", "");
@@ -367,9 +364,31 @@ Color Color::named(const String &p_name) {
 	name = name.replace(".", "");
 	name = name.to_lower();
 
-	const Map<String, Color>::Element *color = _named_colors.find(name);
-	ERR_FAIL_NULL_V_MSG(color, Color(), "Invalid color name: " + p_name + ".");
-	return color->value();
+	int idx = 0;
+	while (named_colors[idx].name != nullptr) {
+		if (name == named_colors[idx].name) {
+			return named_colors[idx].color;
+		}
+		idx++;
+	}
+
+	ERR_FAIL_V_MSG(Color(), "Invalid color name: " + p_name + ".");
+
+	return Color();
+}
+
+int Color::get_named_color_count() {
+	int idx = 0;
+	while (named_colors[idx].name != nullptr) {
+		idx++;
+	}
+	return idx;
+}
+String Color::get_named_color_name(int p_idx) {
+	return named_colors[p_idx].name;
+}
+Color Color::get_named_color(int p_idx) {
+	return named_colors[p_idx].color;
 }
 
 String _to_hex(float p_val) {
@@ -470,6 +489,13 @@ Color Color::operator+(const Color &p_color) const {
 			a + p_color.a);
 }
 
+void Color::operator+=(const Color &p_color) {
+	r = r + p_color.r;
+	g = g + p_color.g;
+	b = b + p_color.b;
+	a = a + p_color.a;
+}
+
 Color Color::operator-(const Color &p_color) const {
 	return Color(
 			r - p_color.r,
@@ -493,12 +519,12 @@ Color Color::operator*(const Color &p_color) const {
 			a * p_color.a);
 }
 
-Color Color::operator*(const real_t &rvalue) const {
+Color Color::operator*(real_t p_rvalue) const {
 	return Color(
-			r * rvalue,
-			g * rvalue,
-			b * rvalue,
-			a * rvalue);
+			r * p_rvalue,
+			g * p_rvalue,
+			b * p_rvalue,
+			a * p_rvalue);
 }
 
 void Color::operator*=(const Color &p_color) {
@@ -508,11 +534,11 @@ void Color::operator*=(const Color &p_color) {
 	a = a * p_color.a;
 }
 
-void Color::operator*=(const real_t &rvalue) {
-	r = r * rvalue;
-	g = g * rvalue;
-	b = b * rvalue;
-	a = a * rvalue;
+void Color::operator*=(real_t p_rvalue) {
+	r = r * p_rvalue;
+	g = g * p_rvalue;
+	b = b * p_rvalue;
+	a = a * p_rvalue;
 }
 
 Color Color::operator/(const Color &p_color) const {
@@ -523,12 +549,12 @@ Color Color::operator/(const Color &p_color) const {
 			a / p_color.a);
 }
 
-Color Color::operator/(const real_t &rvalue) const {
+Color Color::operator/(real_t p_rvalue) const {
 	return Color(
-			r / rvalue,
-			g / rvalue,
-			b / rvalue,
-			a / rvalue);
+			r / p_rvalue,
+			g / p_rvalue,
+			b / p_rvalue,
+			a / p_rvalue);
 }
 
 void Color::operator/=(const Color &p_color) {
@@ -538,17 +564,17 @@ void Color::operator/=(const Color &p_color) {
 	a = a / p_color.a;
 }
 
-void Color::operator/=(const real_t &rvalue) {
-	if (rvalue == 0) {
+void Color::operator/=(real_t p_rvalue) {
+	if (p_rvalue == 0) {
 		r = 1.0;
 		g = 1.0;
 		b = 1.0;
 		a = 1.0;
 	} else {
-		r = r / rvalue;
-		g = g / rvalue;
-		b = b / rvalue;
-		a = a / rvalue;
+		r = r / p_rvalue;
+		g = g / p_rvalue;
+		b = b / p_rvalue;
+		a = a / p_rvalue;
 	}
 }
 
diff --git a/core/color.h b/core/math/color.h
index 8980efe74a..a9be9e9035 100644
--- a/core/color.h
+++ b/core/math/color.h
@@ -32,7 +32,7 @@
 #define COLOR_H
 
 #include "core/math/math_funcs.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 struct Color {
 	union {
@@ -45,9 +45,6 @@ struct Color {
 		float components[4] = { 0, 0, 0, 1.0 };
 	};
 
-	bool operator==(const Color &p_color) const { return (r == p_color.r && g == p_color.g && b == p_color.b && a == p_color.a); }
-	bool operator!=(const Color &p_color) const { return (r != p_color.r || g != p_color.g || b != p_color.b || a != p_color.a); }
-
 	uint32_t to_rgba32() const;
 	uint32_t to_argb32() const;
 	uint32_t to_abgr32() const;
@@ -59,34 +56,36 @@ struct Color {
 	float get_v() const;
 	void set_hsv(float p_h, float p_s, float p_v, float p_alpha = 1.0);
 
-	_FORCE_INLINE_ float &operator[](int idx) {
-		return components[idx];
+	_FORCE_INLINE_ float &operator[](int p_idx) {
+		return components[p_idx];
 	}
-	_FORCE_INLINE_ const float &operator[](int idx) const {
-		return components[idx];
+	_FORCE_INLINE_ const float &operator[](int p_idx) const {
+		return components[p_idx];
 	}
 
-	Color operator+(const Color &p_color) const;
-	_FORCE_INLINE_ void operator+=(const Color &p_color) {
-		r = r + p_color.r;
-		g = g + p_color.g;
-		b = b + p_color.b;
-		a = a + p_color.a;
+	bool operator==(const Color &p_color) const {
+		return (r == p_color.r && g == p_color.g && b == p_color.b && a == p_color.a);
 	}
+	bool operator!=(const Color &p_color) const {
+		return (r != p_color.r || g != p_color.g || b != p_color.b || a != p_color.a);
+	}
+
+	Color operator+(const Color &p_color) const;
+	void operator+=(const Color &p_color);
 
 	Color operator-() const;
 	Color operator-(const Color &p_color) const;
 	void operator-=(const Color &p_color);
 
 	Color operator*(const Color &p_color) const;
-	Color operator*(const real_t &rvalue) const;
+	Color operator*(real_t p_rvalue) const;
 	void operator*=(const Color &p_color);
-	void operator*=(const real_t &rvalue);
+	void operator*=(real_t p_rvalue);
 
 	Color operator/(const Color &p_color) const;
-	Color operator/(const real_t &rvalue) const;
+	Color operator/(real_t p_rvalue) const;
 	void operator/=(const Color &p_color);
-	void operator/=(const real_t &rvalue);
+	void operator/=(real_t p_rvalue);
 
 	bool is_equal_approx(const Color &p_color) const;
 
@@ -123,10 +122,9 @@ struct Color {
 	_FORCE_INLINE_ uint32_t to_rgbe9995() const {
 		const float pow2to9 = 512.0f;
 		const float B = 15.0f;
-		//const float Emax = 31.0f;
 		const float N = 9.0f;
 
-		float sharedexp = 65408.000f; //(( pow2to9  - 1.0f)/ pow2to9)*powf( 2.0f, 31.0f - 15.0f);
+		float sharedexp = 65408.000f; // Result of: ((pow2to9 - 1.0f) / pow2to9) * powf(2.0f, 31.0f - 15.0f)
 
 		float cRed = MAX(0.0f, MIN(sharedexp, r));
 		float cGreen = MAX(0.0f, MIN(sharedexp, g));
@@ -134,8 +132,6 @@ struct Color {
 
 		float cMax = MAX(cRed, MAX(cGreen, cBlue));
 
-		// expp = MAX(-B - 1, log2(maxc)) + 1 + B
-
 		float expp = MAX(-B - 1.0f, floor(Math::log(cMax) / Math_LN2)) + 1.0f + B;
 
 		float sMax = (float)floor((cMax / Math::pow(2.0f, expp - B - N)) + 0.5f);
@@ -186,6 +182,9 @@ struct Color {
 	static Color html(const String &p_rgba);
 	static bool html_is_valid(const String &p_color);
 	static Color named(const String &p_name);
+	static int get_named_color_count();
+	static String get_named_color_name(int p_idx);
+	static Color get_named_color(int p_idx);
 	String to_html(bool p_alpha = true) const;
 	Color from_hsv(float p_h, float p_s, float p_v, float p_a) const;
 	static Color from_rgbe9995(uint32_t p_rgbe);
@@ -193,12 +192,27 @@ struct Color {
 	_FORCE_INLINE_ bool operator<(const Color &p_color) const; //used in set keys
 	operator String() const;
 
+	// For the binder.
+	_FORCE_INLINE_ void set_r8(int32_t r8) { r = (CLAMP(r8, 0, 255) / 255.0); }
+	_FORCE_INLINE_ int32_t get_r8() const { return int32_t(CLAMP(r * 255.0, 0.0, 255.0)); }
+	_FORCE_INLINE_ void set_g8(int32_t g8) { g = (CLAMP(g8, 0, 255) / 255.0); }
+	_FORCE_INLINE_ int32_t get_g8() const { return int32_t(CLAMP(g * 255.0, 0.0, 255.0)); }
+	_FORCE_INLINE_ void set_b8(int32_t b8) { b = (CLAMP(b8, 0, 255) / 255.0); }
+	_FORCE_INLINE_ int32_t get_b8() const { return int32_t(CLAMP(b * 255.0, 0.0, 255.0)); }
+	_FORCE_INLINE_ void set_a8(int32_t a8) { a = (CLAMP(a8, 0, 255) / 255.0); }
+	_FORCE_INLINE_ int32_t get_a8() const { return int32_t(CLAMP(a * 255.0, 0.0, 255.0)); }
+
+	_FORCE_INLINE_ void set_h(float p_h) { set_hsv(p_h, get_s(), get_v()); }
+	_FORCE_INLINE_ void set_s(float p_s) { set_hsv(get_h(), p_s, get_v()); }
+	_FORCE_INLINE_ void set_v(float p_v) { set_hsv(get_h(), get_s(), p_v); }
+
 	_FORCE_INLINE_ Color() {}
 
 	/**
-	 * RGB / RGBA construct parameters. Alpha is optional, but defaults to 1.0
+	 * RGBA construct parameters.
+	 * Alpha is not optional as otherwise we can't bind the RGB version for scripting.
 	 */
-	_FORCE_INLINE_ Color(float p_r, float p_g, float p_b, float p_a = 1.0) {
+	_FORCE_INLINE_ Color(float p_r, float p_g, float p_b, float p_a) {
 		r = p_r;
 		g = p_g;
 		b = p_b;
@@ -206,6 +220,16 @@ struct Color {
 	}
 
 	/**
+	 * RGB construct parameters.
+	 */
+	_FORCE_INLINE_ Color(float p_r, float p_g, float p_b) {
+		r = p_r;
+		g = p_g;
+		b = p_b;
+		a = 1.0;
+	}
+
+	/**
 	 * Construct a Color from another Color, but with the specified alpha value.
 	 */
 	_FORCE_INLINE_ Color(const Color &p_c, float p_a) {
@@ -232,7 +256,7 @@ bool Color::operator<(const Color &p_color) const {
 	}
 }
 
-_FORCE_INLINE_ Color operator*(const real_t &p_real, const Color &p_color) {
+_FORCE_INLINE_ Color operator*(real_t p_real, const Color &p_color) {
 	return p_color * p_real;
 }
 
diff --git a/core/math/color_names.inc b/core/math/color_names.inc
new file mode 100644
index 0000000000..523c7e3c59
--- /dev/null
+++ b/core/math/color_names.inc
@@ -0,0 +1,160 @@
+// Names from https://en.wikipedia.org/wiki/X11_color_names
+
+// So this in a way that does not require memory allocation
+// the old way leaked memory
+// this is not used as often as for more performance to make sense
+
+struct NamedColor {
+	const char *name;
+	Color color;
+};
+
+static NamedColor named_colors[] = {
+	{ "aliceblue", Color(0.94, 0.97, 1.00) },
+	{ "antiquewhite", Color(0.98, 0.92, 0.84) },
+	{ "aqua", Color(0.00, 1.00, 1.00) },
+	{ "aquamarine", Color(0.50, 1.00, 0.83) },
+	{ "azure", Color(0.94, 1.00, 1.00) },
+	{ "beige", Color(0.96, 0.96, 0.86) },
+	{ "bisque", Color(1.00, 0.89, 0.77) },
+	{ "black", Color(0.00, 0.00, 0.00) },
+	{ "blanchedalmond", Color(1.00, 0.92, 0.80) },
+	{ "blue", Color(0.00, 0.00, 1.00) },
+	{ "blueviolet", Color(0.54, 0.17, 0.89) },
+	{ "brown", Color(0.65, 0.16, 0.16) },
+	{ "burlywood", Color(0.87, 0.72, 0.53) },
+	{ "cadetblue", Color(0.37, 0.62, 0.63) },
+	{ "chartreuse", Color(0.50, 1.00, 0.00) },
+	{ "chocolate", Color(0.82, 0.41, 0.12) },
+	{ "coral", Color(1.00, 0.50, 0.31) },
+	{ "cornflower", Color(0.39, 0.58, 0.93) },
+	{ "cornsilk", Color(1.00, 0.97, 0.86) },
+	{ "crimson", Color(0.86, 0.08, 0.24) },
+	{ "cyan", Color(0.00, 1.00, 1.00) },
+	{ "darkblue", Color(0.00, 0.00, 0.55) },
+	{ "darkcyan", Color(0.00, 0.55, 0.55) },
+	{ "darkgoldenrod", Color(0.72, 0.53, 0.04) },
+	{ "darkgray", Color(0.66, 0.66, 0.66) },
+	{ "darkgreen", Color(0.00, 0.39, 0.00) },
+	{ "darkkhaki", Color(0.74, 0.72, 0.42) },
+	{ "darkmagenta", Color(0.55, 0.00, 0.55) },
+	{ "darkolivegreen", Color(0.33, 0.42, 0.18) },
+	{ "darkorange", Color(1.00, 0.55, 0.00) },
+	{ "darkorchid", Color(0.60, 0.20, 0.80) },
+	{ "darkred", Color(0.55, 0.00, 0.00) },
+	{ "darksalmon", Color(0.91, 0.59, 0.48) },
+	{ "darkseagreen", Color(0.56, 0.74, 0.56) },
+	{ "darkslateblue", Color(0.28, 0.24, 0.55) },
+	{ "darkslategray", Color(0.18, 0.31, 0.31) },
+	{ "darkturquoise", Color(0.00, 0.81, 0.82) },
+	{ "darkviolet", Color(0.58, 0.00, 0.83) },
+	{ "deeppink", Color(1.00, 0.08, 0.58) },
+	{ "deepskyblue", Color(0.00, 0.75, 1.00) },
+	{ "dimgray", Color(0.41, 0.41, 0.41) },
+	{ "dodgerblue", Color(0.12, 0.56, 1.00) },
+	{ "firebrick", Color(0.70, 0.13, 0.13) },
+	{ "floralwhite", Color(1.00, 0.98, 0.94) },
+	{ "forestgreen", Color(0.13, 0.55, 0.13) },
+	{ "fuchsia", Color(1.00, 0.00, 1.00) },
+	{ "gainsboro", Color(0.86, 0.86, 0.86) },
+	{ "ghostwhite", Color(0.97, 0.97, 1.00) },
+	{ "gold", Color(1.00, 0.84, 0.00) },
+	{ "goldenrod", Color(0.85, 0.65, 0.13) },
+	{ "gray", Color(0.75, 0.75, 0.75) },
+	{ "green", Color(0.00, 1.00, 0.00) },
+	{ "greenyellow", Color(0.68, 1.00, 0.18) },
+	{ "honeydew", Color(0.94, 1.00, 0.94) },
+	{ "hotpink", Color(1.00, 0.41, 0.71) },
+	{ "indianred", Color(0.80, 0.36, 0.36) },
+	{ "indigo", Color(0.29, 0.00, 0.51) },
+	{ "ivory", Color(1.00, 1.00, 0.94) },
+	{ "khaki", Color(0.94, 0.90, 0.55) },
+	{ "lavender", Color(0.90, 0.90, 0.98) },
+	{ "lavenderblush", Color(1.00, 0.94, 0.96) },
+	{ "lawngreen", Color(0.49, 0.99, 0.00) },
+	{ "lemonchiffon", Color(1.00, 0.98, 0.80) },
+	{ "lightblue", Color(0.68, 0.85, 0.90) },
+	{ "lightcoral", Color(0.94, 0.50, 0.50) },
+	{ "lightcyan", Color(0.88, 1.00, 1.00) },
+	{ "lightgoldenrod", Color(0.98, 0.98, 0.82) },
+	{ "lightgray", Color(0.83, 0.83, 0.83) },
+	{ "lightgreen", Color(0.56, 0.93, 0.56) },
+	{ "lightpink", Color(1.00, 0.71, 0.76) },
+	{ "lightsalmon", Color(1.00, 0.63, 0.48) },
+	{ "lightseagreen", Color(0.13, 0.70, 0.67) },
+	{ "lightskyblue", Color(0.53, 0.81, 0.98) },
+	{ "lightslategray", Color(0.47, 0.53, 0.60) },
+	{ "lightsteelblue", Color(0.69, 0.77, 0.87) },
+	{ "lightyellow", Color(1.00, 1.00, 0.88) },
+	{ "lime", Color(0.00, 1.00, 0.00) },
+	{ "limegreen", Color(0.20, 0.80, 0.20) },
+	{ "linen", Color(0.98, 0.94, 0.90) },
+	{ "magenta", Color(1.00, 0.00, 1.00) },
+	{ "maroon", Color(0.69, 0.19, 0.38) },
+	{ "mediumaquamarine", Color(0.40, 0.80, 0.67) },
+	{ "mediumblue", Color(0.00, 0.00, 0.80) },
+	{ "mediumorchid", Color(0.73, 0.33, 0.83) },
+	{ "mediumpurple", Color(0.58, 0.44, 0.86) },
+	{ "mediumseagreen", Color(0.24, 0.70, 0.44) },
+	{ "mediumslateblue", Color(0.48, 0.41, 0.93) },
+	{ "mediumspringgreen", Color(0.00, 0.98, 0.60) },
+	{ "mediumturquoise", Color(0.28, 0.82, 0.80) },
+	{ "mediumvioletred", Color(0.78, 0.08, 0.52) },
+	{ "midnightblue", Color(0.10, 0.10, 0.44) },
+	{ "mintcream", Color(0.96, 1.00, 0.98) },
+	{ "mistyrose", Color(1.00, 0.89, 0.88) },
+	{ "moccasin", Color(1.00, 0.89, 0.71) },
+	{ "navajowhite", Color(1.00, 0.87, 0.68) },
+	{ "navyblue", Color(0.00, 0.00, 0.50) },
+	{ "oldlace", Color(0.99, 0.96, 0.90) },
+	{ "olive", Color(0.50, 0.50, 0.00) },
+	{ "olivedrab", Color(0.42, 0.56, 0.14) },
+	{ "orange", Color(1.00, 0.65, 0.00) },
+	{ "orangered", Color(1.00, 0.27, 0.00) },
+	{ "orchid", Color(0.85, 0.44, 0.84) },
+	{ "palegoldenrod", Color(0.93, 0.91, 0.67) },
+	{ "palegreen", Color(0.60, 0.98, 0.60) },
+	{ "paleturquoise", Color(0.69, 0.93, 0.93) },
+	{ "palevioletred", Color(0.86, 0.44, 0.58) },
+	{ "papayawhip", Color(1.00, 0.94, 0.84) },
+	{ "peachpuff", Color(1.00, 0.85, 0.73) },
+	{ "peru", Color(0.80, 0.52, 0.25) },
+	{ "pink", Color(1.00, 0.75, 0.80) },
+	{ "plum", Color(0.87, 0.63, 0.87) },
+	{ "powderblue", Color(0.69, 0.88, 0.90) },
+	{ "purple", Color(0.63, 0.13, 0.94) },
+	{ "rebeccapurple", Color(0.40, 0.20, 0.60) },
+	{ "red", Color(1.00, 0.00, 0.00) },
+	{ "rosybrown", Color(0.74, 0.56, 0.56) },
+	{ "royalblue", Color(0.25, 0.41, 0.88) },
+	{ "saddlebrown", Color(0.55, 0.27, 0.07) },
+	{ "salmon", Color(0.98, 0.50, 0.45) },
+	{ "sandybrown", Color(0.96, 0.64, 0.38) },
+	{ "seagreen", Color(0.18, 0.55, 0.34) },
+	{ "seashell", Color(1.00, 0.96, 0.93) },
+	{ "sienna", Color(0.63, 0.32, 0.18) },
+	{ "silver", Color(0.75, 0.75, 0.75) },
+	{ "skyblue", Color(0.53, 0.81, 0.92) },
+	{ "slateblue", Color(0.42, 0.35, 0.80) },
+	{ "slategray", Color(0.44, 0.50, 0.56) },
+	{ "snow", Color(1.00, 0.98, 0.98) },
+	{ "springgreen", Color(0.00, 1.00, 0.50) },
+	{ "steelblue", Color(0.27, 0.51, 0.71) },
+	{ "tan", Color(0.82, 0.71, 0.55) },
+	{ "teal", Color(0.00, 0.50, 0.50) },
+	{ "thistle", Color(0.85, 0.75, 0.85) },
+	{ "tomato", Color(1.00, 0.39, 0.28) },
+	{ "transparent", Color(1.00, 1.00, 1.00, 0.00) },
+	{ "turquoise", Color(0.25, 0.88, 0.82) },
+	{ "violet", Color(0.93, 0.51, 0.93) },
+	{ "webgray", Color(0.50, 0.50, 0.50) },
+	{ "webgreen", Color(0.00, 0.50, 0.00) },
+	{ "webmaroon", Color(0.50, 0.00, 0.00) },
+	{ "webpurple", Color(0.50, 0.00, 0.50) },
+	{ "wheat", Color(0.96, 0.87, 0.70) },
+	{ "white", Color(1.00, 1.00, 1.00) },
+	{ "whitesmoke", Color(0.96, 0.96, 0.96) },
+	{ "yellow", Color(1.00, 1.00, 0.00) },
+	{ "yellowgreen", Color(0.60, 0.80, 0.20) },
+	{ nullptr, Color(0.60, 0.80, 0.20) },
+};
diff --git a/core/math/delaunay_3d.h b/core/math/delaunay_3d.h
index 014b4c4621..ea8655cfff 100644
--- a/core/math/delaunay_3d.h
+++ b/core/math/delaunay_3d.h
@@ -31,15 +31,15 @@
 #ifndef DELAUNAY_3D_H
 #define DELAUNAY_3D_H
 
-#include "core/local_vector.h"
 #include "core/math/aabb.h"
 #include "core/math/camera_matrix.h"
 #include "core/math/vector3.h"
-#include "core/oa_hash_map.h"
 #include "core/os/file_access.h"
-#include "core/print_string.h"
-#include "core/variant.h"
-#include "core/vector.h"
+#include "core/string/print_string.h"
+#include "core/templates/local_vector.h"
+#include "core/templates/oa_hash_map.h"
+#include "core/templates/vector.h"
+#include "core/variant/variant.h"
 
 #include "thirdparty/misc/r128.h"
 
diff --git a/core/math/disjoint_set.h b/core/math/disjoint_set.h
index 198f46e111..51b9ce81af 100644
--- a/core/math/disjoint_set.h
+++ b/core/math/disjoint_set.h
@@ -31,8 +31,8 @@
 #ifndef DISJOINT_SET_H
 #define DISJOINT_SET_H
 
-#include "core/map.h"
-#include "core/vector.h"
+#include "core/templates/map.h"
+#include "core/templates/vector.h"
 
 /**
 	@author Marios Staikopoulos <marios@staik.net>
diff --git a/core/math/expression.cpp b/core/math/expression.cpp
index 1040f9e0e4..48ad73bd32 100644
--- a/core/math/expression.cpp
+++ b/core/math/expression.cpp
@@ -30,13 +30,12 @@
 
 #include "expression.h"
 
-#include "core/class_db.h"
-#include "core/func_ref.h"
 #include "core/io/marshalls.h"
 #include "core/math/math_funcs.h"
+#include "core/object/class_db.h"
+#include "core/object/reference.h"
 #include "core/os/os.h"
-#include "core/reference.h"
-#include "core/variant_parser.h"
+#include "core/variant/variant_parser.h"
 
 const char *Expression::func_name[Expression::FUNC_MAX] = {
 	"sin",
@@ -76,7 +75,8 @@ const char *Expression::func_name[Expression::FUNC_MAX] = {
 	"randomize",
 	"randi",
 	"randf",
-	"rand_range",
+	"randf_range",
+	"randi_range",
 	"seed",
 	"rand_seed",
 	"deg2rad",
@@ -92,7 +92,6 @@ const char *Expression::func_name[Expression::FUNC_MAX] = {
 	"clamp",
 	"nearest_po2",
 	"weakref",
-	"funcref",
 	"convert",
 	"typeof",
 	"type_exists",
@@ -127,7 +126,7 @@ String Expression::get_func_name(BuiltinFunc p_func) {
 int Expression::get_func_argument_count(BuiltinFunc p_func) {
 	switch (p_func) {
 		case MATH_RANDOMIZE:
-		case MATH_RAND:
+		case MATH_RANDI:
 		case MATH_RANDF:
 			return 0;
 		case MATH_SIN:
@@ -178,12 +177,12 @@ int Expression::get_func_argument_count(BuiltinFunc p_func) {
 		case MATH_POW:
 		case MATH_EASE:
 		case MATH_STEPIFY:
-		case MATH_RANDOM:
+		case MATH_RANDF_RANGE:
+		case MATH_RANDI_RANGE:
 		case MATH_POLAR2CARTESIAN:
 		case MATH_CARTESIAN2POLAR:
 		case LOGIC_MAX:
 		case LOGIC_MIN:
-		case FUNC_FUNCREF:
 		case TYPE_CONVERT:
 		case COLORN:
 			return 2;
@@ -397,17 +396,22 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			Math::randomize();
 
 		} break;
-		case MATH_RAND: {
+		case MATH_RANDI: {
 			*r_return = Math::rand();
 		} break;
 		case MATH_RANDF: {
 			*r_return = Math::randf();
 		} break;
-		case MATH_RANDOM: {
+		case MATH_RANDF_RANGE: {
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
+		case MATH_RANDI_RANGE: {
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			*r_return = Math::random((int)*p_inputs[0], (int)*p_inputs[1]);
+		} break;
 		case MATH_SEED: {
 			VALIDATE_ARG_NUM(0);
 			uint64_t seed = *p_inputs[0];
@@ -549,30 +553,6 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			}
 
 		} break;
-		case FUNC_FUNCREF: {
-			if (p_inputs[0]->get_type() != Variant::OBJECT) {
-				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument = 0;
-				r_error.expected = Variant::OBJECT;
-
-				return;
-			}
-			if (p_inputs[1]->get_type() != Variant::STRING && p_inputs[1]->get_type() != Variant::NODE_PATH) {
-				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument = 1;
-				r_error.expected = Variant::STRING;
-
-				return;
-			}
-
-			Ref<FuncRef> fr = memnew(FuncRef);
-
-			fr->set_instance(*p_inputs[0]);
-			fr->set_function(*p_inputs[1]);
-
-			*r_return = fr;
-
-		} break;
 		case TYPE_CONVERT: {
 			VALIDATE_ARG_NUM(1);
 			int type = *p_inputs[1];
@@ -584,7 +564,7 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 				return;
 
 			} else {
-				*r_return = Variant::construct(Variant::Type(type), p_inputs, 1, r_error);
+				Variant::construct(Variant::Type(type), *r_return, p_inputs, 1, r_error);
 			}
 		} break;
 		case TYPE_OF: {
@@ -1973,7 +1953,7 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			}
 
 			bool valid;
-			r_ret = base.get_named(index->name, &valid);
+			r_ret = base.get_named(index->name, valid);
 			if (!valid) {
 				r_error_str = vformat(RTR("Invalid named index '%s' for base type %s"), String(index->name), Variant::get_type_name(base.get_type()));
 				return true;
@@ -2041,7 +2021,7 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			}
 
 			Callable::CallError ce;
-			r_ret = Variant::construct(constructor->data_type, (const Variant **)argp.ptr(), argp.size(), ce);
+			Variant::construct(constructor->data_type, r_ret, (const Variant **)argp.ptr(), argp.size(), ce);
 
 			if (ce.error != Callable::CallError::CALL_OK) {
 				r_error_str = vformat(RTR("Invalid arguments to construct '%s'"), Variant::get_type_name(constructor->data_type));
diff --git a/core/math/expression.h b/core/math/expression.h
index f2cfe6b1a6..991554f4fd 100644
--- a/core/math/expression.h
+++ b/core/math/expression.h
@@ -31,7 +31,7 @@
 #ifndef EXPRESSION_H
 #define EXPRESSION_H
 
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class Expression : public Reference {
 	GDCLASS(Expression, Reference);
@@ -73,9 +73,10 @@ public:
 		MATH_MOVE_TOWARD,
 		MATH_DECTIME,
 		MATH_RANDOMIZE,
-		MATH_RAND,
+		MATH_RANDI,
 		MATH_RANDF,
-		MATH_RANDOM,
+		MATH_RANDF_RANGE,
+		MATH_RANDI_RANGE,
 		MATH_SEED,
 		MATH_RANDSEED,
 		MATH_DEG2RAD,
@@ -91,7 +92,6 @@ public:
 		LOGIC_CLAMP,
 		LOGIC_NEAREST_PO2,
 		OBJ_WEAKREF,
-		FUNC_FUNCREF,
 		TYPE_CONVERT,
 		TYPE_OF,
 		TYPE_EXISTS,
diff --git a/core/math/geometry_2d.h b/core/math/geometry_2d.h
index cfd7abfacb..12bad5768e 100644
--- a/core/math/geometry_2d.h
+++ b/core/math/geometry_2d.h
@@ -34,8 +34,8 @@
 #include "core/math/delaunay_2d.h"
 #include "core/math/rect2.h"
 #include "core/math/triangulate.h"
-#include "core/object.h"
-#include "core/vector.h"
+#include "core/object/object.h"
+#include "core/templates/vector.h"
 
 class Geometry2D {
 	Geometry2D();
diff --git a/core/math/geometry_3d.cpp b/core/math/geometry_3d.cpp
index 2c19fe2085..56353de783 100644
--- a/core/math/geometry_3d.cpp
+++ b/core/math/geometry_3d.cpp
@@ -30,7 +30,7 @@
 
 #include "geometry_3d.h"
 
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 #include "thirdparty/misc/clipper.hpp"
 #include "thirdparty/misc/triangulator.h"
diff --git a/core/math/geometry_3d.h b/core/math/geometry_3d.h
index 11cac8f108..f10fbeaaaf 100644
--- a/core/math/geometry_3d.h
+++ b/core/math/geometry_3d.h
@@ -32,8 +32,8 @@
 #define GEOMETRY_3D_H
 
 #include "core/math/face3.h"
-#include "core/object.h"
-#include "core/vector.h"
+#include "core/object/object.h"
+#include "core/templates/vector.h"
 
 class Geometry3D {
 	Geometry3D();
diff --git a/core/math/math_fieldwise.h b/core/math/math_fieldwise.h
index c1ee9ec8f0..e8aac0dced 100644
--- a/core/math/math_fieldwise.h
+++ b/core/math/math_fieldwise.h
@@ -33,7 +33,7 @@
 
 #ifdef TOOLS_ENABLED
 
-#include "core/variant.h"
+#include "core/variant/variant.h"
 
 Variant fieldwise_assign(const Variant &p_target, const Variant &p_source, const String &p_field);
 
diff --git a/core/math/math_funcs.cpp b/core/math/math_funcs.cpp
index 4154713a87..e57257b442 100644
--- a/core/math/math_funcs.cpp
+++ b/core/math/math_funcs.cpp
@@ -30,7 +30,7 @@
 
 #include "math_funcs.h"
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 
 RandomPCG Math::default_rand(RandomPCG::DEFAULT_SEED, RandomPCG::DEFAULT_INC);
 
@@ -181,3 +181,7 @@ double Math::random(double from, double to) {
 float Math::random(float from, float to) {
 	return default_rand.random(from, to);
 }
+
+int Math::random(int from, int to) {
+	return default_rand.random(from, to);
+}
diff --git a/core/math/math_funcs.h b/core/math/math_funcs.h
index f83ee44f4a..827637bf2b 100644
--- a/core/math/math_funcs.h
+++ b/core/math/math_funcs.h
@@ -289,7 +289,7 @@ public:
 
 	static double random(double from, double to);
 	static float random(float from, float to);
-	static real_t random(int from, int to) { return (real_t)random((real_t)from, (real_t)to); }
+	static int random(int from, int to);
 
 	static _ALWAYS_INLINE_ bool is_equal_approx(real_t a, real_t b) {
 		// Check for exact equality first, required to handle "infinity" values.
diff --git a/core/math/octree.h b/core/math/octree.h
index 5d9688d442..40201f99b1 100644
--- a/core/math/octree.h
+++ b/core/math/octree.h
@@ -31,13 +31,13 @@
 #ifndef OCTREE_H
 #define OCTREE_H
 
-#include "core/list.h"
-#include "core/map.h"
 #include "core/math/aabb.h"
 #include "core/math/geometry_3d.h"
 #include "core/math/vector3.h"
-#include "core/print_string.h"
-#include "core/variant.h"
+#include "core/string/print_string.h"
+#include "core/templates/list.h"
+#include "core/templates/map.h"
+#include "core/variant/variant.h"
 
 typedef uint32_t OctreeElementID;
 
diff --git a/core/math/plane.cpp b/core/math/plane.cpp
index ae2021d2f6..e1ae3288ed 100644
--- a/core/math/plane.cpp
+++ b/core/math/plane.cpp
@@ -31,7 +31,7 @@
 #include "plane.h"
 
 #include "core/math/math_funcs.h"
-#include "core/variant.h"
+#include "core/variant/variant.h"
 
 void Plane::set_normal(const Vector3 &p_normal) {
 	normal = p_normal;
diff --git a/core/math/quat.cpp b/core/math/quat.cpp
index c10f5da494..b6a017dd41 100644
--- a/core/math/quat.cpp
+++ b/core/math/quat.cpp
@@ -31,7 +31,7 @@
 #include "quat.h"
 
 #include "core/math/basis.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 // set_euler_xyz expects a vector containing the Euler angles in the format
 // (ax,ay,az), where ax is the angle of rotation around x axis,
diff --git a/core/math/quat.h b/core/math/quat.h
index 3152b7d233..f8ab537d7b 100644
--- a/core/math/quat.h
+++ b/core/math/quat.h
@@ -36,12 +36,26 @@
 
 #include "core/math/math_defs.h"
 #include "core/math/math_funcs.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 class Quat {
 public:
-	real_t x = 0, y = 0, z = 0, w = 1;
-
+	union {
+		struct {
+			real_t x;
+			real_t y;
+			real_t z;
+			real_t w;
+		};
+		real_t components[4] = { 0, 0, 0, 1.0 };
+	};
+
+	_FORCE_INLINE_ real_t &operator[](int idx) {
+		return components[idx];
+	}
+	_FORCE_INLINE_ const real_t &operator[](int idx) const {
+		return components[idx];
+	}
 	_FORCE_INLINE_ real_t length_squared() const;
 	bool is_equal_approx(const Quat &p_quat) const;
 	real_t length() const;
@@ -91,6 +105,10 @@ public:
 		return v + ((uv * w) + u.cross(uv)) * ((real_t)2);
 	}
 
+	_FORCE_INLINE_ Vector3 xform_inv(const Vector3 &v) const {
+		return inverse().xform(v);
+	}
+
 	_FORCE_INLINE_ void operator+=(const Quat &q);
 	_FORCE_INLINE_ void operator-=(const Quat &q);
 	_FORCE_INLINE_ void operator*=(const real_t &s);
diff --git a/core/math/quick_hull.cpp b/core/math/quick_hull.cpp
index 8ba1ba9286..8dff13c050 100644
--- a/core/math/quick_hull.cpp
+++ b/core/math/quick_hull.cpp
@@ -30,7 +30,7 @@
 
 #include "quick_hull.h"
 
-#include "core/map.h"
+#include "core/templates/map.h"
 
 uint32_t QuickHull::debug_stop_after = 0xFFFFFFFF;
 
diff --git a/core/math/quick_hull.h b/core/math/quick_hull.h
index cac8e58d23..80f32e191b 100644
--- a/core/math/quick_hull.h
+++ b/core/math/quick_hull.h
@@ -31,10 +31,10 @@
 #ifndef QUICK_HULL_H
 #define QUICK_HULL_H
 
-#include "core/list.h"
 #include "core/math/aabb.h"
 #include "core/math/geometry_3d.h"
-#include "core/set.h"
+#include "core/templates/list.h"
+#include "core/templates/set.h"
 
 class QuickHull {
 public:
diff --git a/core/math/random_number_generator.h b/core/math/random_number_generator.h
index 2e7941b345..0d0ea17205 100644
--- a/core/math/random_number_generator.h
+++ b/core/math/random_number_generator.h
@@ -32,7 +32,7 @@
 #define RANDOM_NUMBER_GENERATOR_H
 
 #include "core/math/random_pcg.h"
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class RandomNumberGenerator : public Reference {
 	GDCLASS(RandomNumberGenerator, Reference);
@@ -43,7 +43,7 @@ protected:
 	static void _bind_methods();
 
 public:
-	_FORCE_INLINE_ void set_seed(uint64_t seed) { randbase.seed(seed); }
+	_FORCE_INLINE_ void set_seed(uint64_t p_seed) { randbase.seed(p_seed); }
 
 	_FORCE_INLINE_ uint64_t get_seed() { return randbase.get_seed(); }
 
@@ -53,24 +53,11 @@ public:
 
 	_FORCE_INLINE_ real_t randf() { return randbase.randf(); }
 
-	_FORCE_INLINE_ real_t randf_range(real_t from, real_t to) { return randbase.random(from, to); }
+	_FORCE_INLINE_ real_t randf_range(real_t p_from, real_t p_to) { return randbase.random(p_from, p_to); }
 
-	_FORCE_INLINE_ real_t randfn(real_t mean = 0.0, real_t deviation = 1.0) { return randbase.randfn(mean, deviation); }
+	_FORCE_INLINE_ real_t randfn(real_t p_mean = 0.0, real_t p_deviation = 1.0) { return randbase.randfn(p_mean, p_deviation); }
 
-	_FORCE_INLINE_ int randi_range(int from, int to) {
-		int range;
-		int min;
-		if (to > from) {
-			range = to - from + 1;
-			min = from;
-		} else if (to < from) {
-			range = from - to + 1;
-			min = to;
-		} else { // from == to
-			return from;
-		}
-		return randbase.rand(range) + min;
-	}
+	_FORCE_INLINE_ int randi_range(int p_from, int p_to) { return randbase.random(p_from, p_to); }
 
 	RandomNumberGenerator() {}
 };
diff --git a/core/math/random_pcg.cpp b/core/math/random_pcg.cpp
index 02257c38d9..e0768b9403 100644
--- a/core/math/random_pcg.cpp
+++ b/core/math/random_pcg.cpp
@@ -49,3 +49,18 @@ double RandomPCG::random(double p_from, double p_to) {
 float RandomPCG::random(float p_from, float p_to) {
 	return randf() * (p_to - p_from) + p_from;
 }
+
+int RandomPCG::random(int p_from, int p_to) {
+	int range;
+	int min;
+	if (p_to > p_from) {
+		range = p_to - p_from + 1;
+		min = p_from;
+	} else if (p_to < p_from) {
+		range = p_from - p_to + 1;
+		min = p_to;
+	} else { // from == to
+		return p_from;
+	}
+	return rand(range) + min;
+}
diff --git a/core/math/random_pcg.h b/core/math/random_pcg.h
index dfdae53eed..fe6b1b5639 100644
--- a/core/math/random_pcg.h
+++ b/core/math/random_pcg.h
@@ -133,7 +133,7 @@ public:
 
 	double random(double p_from, double p_to);
 	float random(float p_from, float p_to);
-	real_t random(int p_from, int p_to) { return (real_t)random((real_t)p_from, (real_t)p_to); }
+	int random(int p_from, int p_to);
 };
 
 #endif // RANDOM_PCG_H
diff --git a/core/math/rect2.h b/core/math/rect2.h
index 5a746aa732..b1fe865ba5 100644
--- a/core/math/rect2.h
+++ b/core/math/rect2.h
@@ -306,6 +306,15 @@ struct Rect2 {
 			return false;
 		}
 	}
+
+	_FORCE_INLINE_ void set_end(const Vector2 &p_end) {
+		size = p_end - position;
+	}
+
+	_FORCE_INLINE_ Vector2 get_end() const {
+		return position + size;
+	}
+
 	operator String() const { return String(position) + ", " + String(size); }
 
 	Rect2() {}
@@ -475,6 +484,14 @@ struct Rect2i {
 		return Rect2i(Point2i(position.x + MIN(size.x, 0), position.y + MIN(size.y, 0)), size.abs());
 	}
 
+	_FORCE_INLINE_ void set_end(const Vector2i &p_end) {
+		size = p_end - position;
+	}
+
+	_FORCE_INLINE_ Vector2i get_end() const {
+		return position + size;
+	}
+
 	operator String() const { return String(position) + ", " + String(size); }
 
 	operator Rect2() const { return Rect2(position, size); }
diff --git a/core/math/transform.cpp b/core/math/transform.cpp
index 0274dd18af..733bb4d55e 100644
--- a/core/math/transform.cpp
+++ b/core/math/transform.cpp
@@ -32,7 +32,7 @@
 
 #include "core/math/math_funcs.h"
 #include "core/os/copymem.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 void Transform::affine_invert() {
 	basis.invert();
@@ -200,6 +200,13 @@ Transform::Transform(const Basis &p_basis, const Vector3 &p_origin) :
 		origin(p_origin) {
 }
 
+Transform::Transform(const Vector3 &p_x, const Vector3 &p_y, const Vector3 &p_z, const Vector3 &p_origin) :
+		origin(p_origin) {
+	basis.set_axis(0, p_x);
+	basis.set_axis(1, p_y);
+	basis.set_axis(2, p_z);
+}
+
 Transform::Transform(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t ox, real_t oy, real_t oz) {
 	basis = Basis(xx, xy, xz, yx, yy, yz, zx, zy, zz);
 	origin = Vector3(ox, oy, oz);
diff --git a/core/math/transform.h b/core/math/transform.h
index 71847d36ac..c63dbcb989 100644
--- a/core/math/transform.h
+++ b/core/math/transform.h
@@ -106,9 +106,10 @@ public:
 
 	operator String() const;
 
-	Transform(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t ox, real_t oy, real_t oz);
-	Transform(const Basis &p_basis, const Vector3 &p_origin = Vector3());
 	Transform() {}
+	Transform(const Basis &p_basis, const Vector3 &p_origin = Vector3());
+	Transform(const Vector3 &p_x, const Vector3 &p_y, const Vector3 &p_z, const Vector3 &p_origin);
+	Transform(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t ox, real_t oy, real_t oz);
 };
 
 _FORCE_INLINE_ Vector3 Transform::xform(const Vector3 &p_vector) const {
diff --git a/core/math/transform_2d.h b/core/math/transform_2d.h
index 46e97abaa7..342623939e 100644
--- a/core/math/transform_2d.h
+++ b/core/math/transform_2d.h
@@ -128,6 +128,12 @@ struct Transform2D {
 		elements[2][1] = oy;
 	}
 
+	Transform2D(const Vector2 &p_x, const Vector2 &p_y, const Vector2 &p_origin) {
+		elements[0] = p_x;
+		elements[1] = p_y;
+		elements[2] = p_origin;
+	}
+
 	Transform2D(real_t p_rot, const Vector2 &p_pos);
 	Transform2D() {
 		elements[0][0] = 1.0;
diff --git a/core/math/triangle_mesh.cpp b/core/math/triangle_mesh.cpp
index c9a546e385..cfe8422d80 100644
--- a/core/math/triangle_mesh.cpp
+++ b/core/math/triangle_mesh.cpp
@@ -30,7 +30,7 @@
 
 #include "triangle_mesh.h"
 
-#include "core/sort_array.h"
+#include "core/templates/sort_array.h"
 
 int TriangleMesh::_create_bvh(BVH *p_bvh, BVH **p_bb, int p_from, int p_size, int p_depth, int &max_depth, int &max_alloc) {
 	if (p_depth > max_depth) {
diff --git a/core/math/triangle_mesh.h b/core/math/triangle_mesh.h
index 86412cf725..d719822ec3 100644
--- a/core/math/triangle_mesh.h
+++ b/core/math/triangle_mesh.h
@@ -32,7 +32,7 @@
 #define TRIANGLE_MESH_H
 
 #include "core/math/face3.h"
-#include "core/reference.h"
+#include "core/object/reference.h"
 
 class TriangleMesh : public Reference {
 	GDCLASS(TriangleMesh, Reference);
diff --git a/core/math/vector2.cpp b/core/math/vector2.cpp
index 233421e070..75e742a5f1 100644
--- a/core/math/vector2.cpp
+++ b/core/math/vector2.cpp
@@ -233,6 +233,19 @@ void Vector2i::operator/=(const int &rvalue) {
 	y /= rvalue;
 }
 
+Vector2i Vector2i::operator%(const Vector2i &p_v1) const {
+	return Vector2i(x % p_v1.x, y % p_v1.y);
+}
+
+Vector2i Vector2i::operator%(const int &rvalue) const {
+	return Vector2i(x % rvalue, y % rvalue);
+}
+
+void Vector2i::operator%=(const int &rvalue) {
+	x %= rvalue;
+	y %= rvalue;
+}
+
 Vector2i Vector2i::operator-() const {
 	return Vector2i(-x, -y);
 }
diff --git a/core/math/vector2.h b/core/math/vector2.h
index c2a2656e72..8cb63b2fb5 100644
--- a/core/math/vector2.h
+++ b/core/math/vector2.h
@@ -32,7 +32,7 @@
 #define VECTOR2_H
 
 #include "core/math/math_funcs.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 struct Vector2i;
 
@@ -290,11 +290,13 @@ struct Vector2i {
 	void operator*=(const int &rvalue);
 
 	Vector2i operator/(const Vector2i &p_v1) const;
-
 	Vector2i operator/(const int &rvalue) const;
-
 	void operator/=(const int &rvalue);
 
+	Vector2i operator%(const Vector2i &p_v1) const;
+	Vector2i operator%(const int &rvalue) const;
+	void operator%=(const int &rvalue);
+
 	Vector2i operator-() const;
 	bool operator<(const Vector2i &p_vec2) const { return (x == p_vec2.x) ? (y < p_vec2.y) : (x < p_vec2.x); }
 	bool operator>(const Vector2i &p_vec2) const { return (x == p_vec2.x) ? (y > p_vec2.y) : (x > p_vec2.x); }
diff --git a/core/math/vector3.h b/core/math/vector3.h
index 5370b297f1..ae8b9376cf 100644
--- a/core/math/vector3.h
+++ b/core/math/vector3.h
@@ -33,7 +33,7 @@
 
 #include "core/math/math_funcs.h"
 #include "core/math/vector3i.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 class Basis;
 
diff --git a/core/math/vector3i.h b/core/math/vector3i.h
index 08729ad056..1bfd6d5ab2 100644
--- a/core/math/vector3i.h
+++ b/core/math/vector3i.h
@@ -31,8 +31,8 @@
 #ifndef VECTOR3I_H
 #define VECTOR3I_H
 
+#include "core/string/ustring.h"
 #include "core/typedefs.h"
-#include "core/ustring.h"
 
 struct Vector3i {
 	enum Axis {
@@ -80,11 +80,15 @@ struct Vector3i {
 	_FORCE_INLINE_ Vector3i operator*(const Vector3i &p_v) const;
 	_FORCE_INLINE_ Vector3i &operator/=(const Vector3i &p_v);
 	_FORCE_INLINE_ Vector3i operator/(const Vector3i &p_v) const;
+	_FORCE_INLINE_ Vector3i &operator%=(const Vector3i &p_v);
+	_FORCE_INLINE_ Vector3i operator%(const Vector3i &p_v) const;
 
 	_FORCE_INLINE_ Vector3i &operator*=(int32_t p_scalar);
 	_FORCE_INLINE_ Vector3i operator*(int32_t p_scalar) const;
 	_FORCE_INLINE_ Vector3i &operator/=(int32_t p_scalar);
 	_FORCE_INLINE_ Vector3i operator/(int32_t p_scalar) const;
+	_FORCE_INLINE_ Vector3i &operator%=(int32_t p_scalar);
+	_FORCE_INLINE_ Vector3i operator%(int32_t p_scalar) const;
 
 	_FORCE_INLINE_ Vector3i operator-() const;
 
@@ -159,6 +163,17 @@ Vector3i Vector3i::operator/(const Vector3i &p_v) const {
 	return Vector3i(x / p_v.x, y / p_v.y, z / p_v.z);
 }
 
+Vector3i &Vector3i::operator%=(const Vector3i &p_v) {
+	x %= p_v.x;
+	y %= p_v.y;
+	z %= p_v.z;
+	return *this;
+}
+
+Vector3i Vector3i::operator%(const Vector3i &p_v) const {
+	return Vector3i(x % p_v.x, y % p_v.y, z % p_v.z);
+}
+
 Vector3i &Vector3i::operator*=(int32_t p_scalar) {
 	x *= p_scalar;
 	y *= p_scalar;
@@ -185,6 +200,17 @@ Vector3i Vector3i::operator/(int32_t p_scalar) const {
 	return Vector3i(x / p_scalar, y / p_scalar, z / p_scalar);
 }
 
+Vector3i &Vector3i::operator%=(int32_t p_scalar) {
+	x %= p_scalar;
+	y %= p_scalar;
+	z %= p_scalar;
+	return *this;
+}
+
+Vector3i Vector3i::operator%(int32_t p_scalar) const {
+	return Vector3i(x % p_scalar, y % p_scalar, z % p_scalar);
+}
+
 Vector3i Vector3i::operator-() const {
 	return Vector3i(-x, -y, -z);
 }
diff --git a/core/object/SCsub b/core/object/SCsub
new file mode 100644
index 0000000000..5d429960e5
--- /dev/null
+++ b/core/object/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env_object = env.Clone()
+
+env_object.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/callable_method_pointer.cpp b/core/object/callable_method_pointer.cpp
index 21a917cbd7..21a917cbd7 100644
--- a/core/callable_method_pointer.cpp
+++ b/core/object/callable_method_pointer.cpp
diff --git a/core/callable_method_pointer.h b/core/object/callable_method_pointer.h
index 2007b9f338..ee6da6a8db 100644
--- a/core/callable_method_pointer.h
+++ b/core/object/callable_method_pointer.h
@@ -31,12 +31,12 @@
 #ifndef CALLABLE_METHOD_POINTER_H
 #define CALLABLE_METHOD_POINTER_H
 
-#include "core/binder_common.h"
-#include "core/callable.h"
-#include "core/hashfuncs.h"
-#include "core/object.h"
+#include "core/object/object.h"
 #include "core/os/copymem.h"
-#include "core/simple_type.h"
+#include "core/templates/hashfuncs.h"
+#include "core/templates/simple_type.h"
+#include "core/variant/binder_common.h"
+#include "core/variant/callable.h"
 
 class CallableCustomMethodPointerBase : public CallableCustom {
 	uint32_t *comp_ptr;
diff --git a/core/class_db.cpp b/core/object/class_db.cpp
index 81bc901561..64ebeb427e 100644
--- a/core/class_db.cpp
+++ b/core/object/class_db.cpp
@@ -30,7 +30,7 @@
 
 #include "class_db.h"
 
-#include "core/engine.h"
+#include "core/config/engine.h"
 #include "core/os/mutex.h"
 #include "core/version.h"
 
diff --git a/core/class_db.h b/core/object/class_db.h
index 22072066d9..94f26da60d 100644
--- a/core/class_db.h
+++ b/core/object/class_db.h
@@ -31,9 +31,9 @@
 #ifndef CLASS_DB_H
 #define CLASS_DB_H
 
-#include "core/method_bind.h"
-#include "core/object.h"
-#include "core/print_string.h"
+#include "core/object/method_bind.h"
+#include "core/object/object.h"
+#include "core/string/print_string.h"
 
 /** To bind more then 6 parameters include this:
  *
@@ -41,7 +41,7 @@
 
 // Makes callable_mp readily available in all classes connecting signals.
 // Needs to come after method_bind and object have been included.
-#include "core/callable_method_pointer.h"
+#include "core/object/callable_method_pointer.h"
 
 #define DEFVAL(m_defval) (m_defval)
 
diff --git a/core/message_queue.cpp b/core/object/message_queue.cpp
index 6dcf24e7ed..f0d6786853 100644
--- a/core/message_queue.cpp
+++ b/core/object/message_queue.cpp
@@ -30,9 +30,9 @@
 
 #include "message_queue.h"
 
+#include "core/config/project_settings.h"
 #include "core/core_string_names.h"
-#include "core/project_settings.h"
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 
 MessageQueue *MessageQueue::singleton = nullptr;
 
diff --git a/core/message_queue.h b/core/object/message_queue.h
index 5d39ceee03..2901ab196a 100644
--- a/core/message_queue.h
+++ b/core/object/message_queue.h
@@ -31,7 +31,7 @@
 #ifndef MESSAGE_QUEUE_H
 #define MESSAGE_QUEUE_H
 
-#include "core/class_db.h"
+#include "core/object/class_db.h"
 #include "core/os/thread_safe.h"
 
 class MessageQueue {
diff --git a/core/method_bind.cpp b/core/object/method_bind.cpp
index 3244c63292..e6652ac09f 100644
--- a/core/method_bind.cpp
+++ b/core/object/method_bind.cpp
@@ -30,7 +30,7 @@
 
 // object.h needs to be the first include *before* method_bind.h
 // FIXME: Find out why and fix potential cyclical dependencies.
-#include "core/object.h"
+#include "core/object/object.h"
 
 #include "method_bind.h"
 
diff --git a/core/method_bind.h b/core/object/method_bind.h
index d43186257b..ab4ba90b94 100644
--- a/core/method_bind.h
+++ b/core/object/method_bind.h
@@ -31,7 +31,7 @@
 #ifndef METHOD_BIND_H
 #define METHOD_BIND_H
 
-#include "core/binder_common.h"
+#include "core/variant/binder_common.h"
 
 enum MethodFlags {
 
diff --git a/core/object.cpp b/core/object/object.cpp
index 0d9e5c5116..c3f49856ca 100644
--- a/core/object.cpp
+++ b/core/object/object.cpp
@@ -30,14 +30,14 @@
 
 #include "object.h"
 
-#include "core/class_db.h"
 #include "core/core_string_names.h"
-#include "core/message_queue.h"
+#include "core/io/resource.h"
+#include "core/object/class_db.h"
+#include "core/object/message_queue.h"
+#include "core/object/script_language.h"
 #include "core/os/os.h"
-#include "core/print_string.h"
-#include "core/resource.h"
-#include "core/script_language.h"
-#include "core/translation.h"
+#include "core/string/print_string.h"
+#include "core/string/translation.h"
 
 #ifdef DEBUG_ENABLED
 
@@ -421,17 +421,6 @@ void Object::set(const StringName &p_name, const Variant &p_value, bool *r_valid
 		return;
 	}
 
-	{
-		bool valid;
-		setvar(p_name, p_value, &valid);
-		if (valid) {
-			if (r_valid) {
-				*r_valid = true;
-			}
-			return;
-		}
-	}
-
 #ifdef TOOLS_ENABLED
 	if (script_instance) {
 		bool valid;
@@ -496,18 +485,6 @@ Variant Object::get(const StringName &p_name, bool *r_valid) const {
 			return ret;
 		}
 
-		//if nothing else, use getvar
-		{
-			bool valid;
-			ret = getvar(p_name, &valid);
-			if (valid) {
-				if (r_valid) {
-					*r_valid = true;
-				}
-				return ret;
-			}
-		}
-
 #ifdef TOOLS_ENABLED
 		if (script_instance) {
 			bool valid;
@@ -555,9 +532,12 @@ void Object::set_indexed(const Vector<StringName> &p_names, const Variant &p_val
 	}
 
 	for (int i = 1; i < p_names.size() - 1; i++) {
-		value_stack.push_back(value_stack.back()->get().get_named(p_names[i], r_valid));
+		value_stack.push_back(value_stack.back()->get().get_named(p_names[i], valid));
+		if (r_valid) {
+			*r_valid = valid;
+		}
 
-		if (!*r_valid) {
+		if (!valid) {
 			value_stack.clear();
 			return;
 		}
@@ -566,10 +546,13 @@ void Object::set_indexed(const Vector<StringName> &p_names, const Variant &p_val
 	value_stack.push_back(p_value); // p_names[p_names.size() - 1]
 
 	for (int i = p_names.size() - 1; i > 0; i--) {
-		value_stack.back()->prev()->get().set_named(p_names[i], value_stack.back()->get(), r_valid);
+		value_stack.back()->prev()->get().set_named(p_names[i], value_stack.back()->get(), valid);
 		value_stack.pop_back();
 
-		if (!*r_valid) {
+		if (r_valid) {
+			*r_valid = valid;
+		}
+		if (!valid) {
 			value_stack.clear();
 			return;
 		}
@@ -592,7 +575,7 @@ Variant Object::get_indexed(const Vector<StringName> &p_names, bool *r_valid) co
 
 	Variant current_value = get(p_names[0], &valid);
 	for (int i = 1; i < p_names.size(); i++) {
-		current_value = current_value.get_named(p_names[i], &valid);
+		current_value = current_value.get_named(p_names[i], valid);
 
 		if (!valid) {
 			break;
@@ -698,6 +681,10 @@ Variant Object::getvar(const Variant &p_key, bool *r_valid) const {
 	if (r_valid) {
 		*r_valid = false;
 	}
+
+	if (p_key.get_type() == Variant::STRING_NAME || p_key.get_type() == Variant::STRING) {
+		return get(p_key, r_valid);
+	}
 	return Variant();
 }
 
@@ -705,6 +692,9 @@ void Object::setvar(const Variant &p_key, const Variant &p_value, bool *r_valid)
 	if (r_valid) {
 		*r_valid = false;
 	}
+	if (p_key.get_type() == Variant::STRING_NAME || p_key.get_type() == Variant::STRING) {
+		return set(p_key, p_value, r_valid);
+	}
 }
 
 Variant Object::callv(const StringName &p_method, const Array &p_args) {
@@ -1700,7 +1690,8 @@ Variant::Type Object::get_static_property_type_indexed(const Vector<StringName>
 	}
 
 	Callable::CallError ce;
-	Variant check = Variant::construct(t, nullptr, 0, ce);
+	Variant check;
+	Variant::construct(t, check, nullptr, 0, ce);
 
 	for (int i = 1; i < p_path.size(); i++) {
 		if (check.get_type() == Variant::OBJECT || check.get_type() == Variant::DICTIONARY || check.get_type() == Variant::ARRAY) {
@@ -1711,7 +1702,7 @@ Variant::Type Object::get_static_property_type_indexed(const Vector<StringName>
 			return Variant::NIL;
 		}
 
-		check = check.get_named(p_path[i], &valid);
+		check = check.get_named(p_path[i], valid);
 
 		if (!valid) {
 			if (r_valid) {
diff --git a/core/object.h b/core/object/object.h
index 765fb63c6e..c79745cf74 100644
--- a/core/object.h
+++ b/core/object/object.h
@@ -31,16 +31,16 @@
 #ifndef OBJECT_H
 #define OBJECT_H
 
-#include "core/callable_bind.h"
-#include "core/hash_map.h"
-#include "core/list.h"
-#include "core/map.h"
-#include "core/object_id.h"
+#include "core/object/object_id.h"
 #include "core/os/rw_lock.h"
-#include "core/set.h"
-#include "core/spin_lock.h"
-#include "core/variant.h"
-#include "core/vmap.h"
+#include "core/os/spin_lock.h"
+#include "core/templates/hash_map.h"
+#include "core/templates/list.h"
+#include "core/templates/map.h"
+#include "core/templates/set.h"
+#include "core/templates/vmap.h"
+#include "core/variant/callable_bind.h"
+#include "core/variant/variant.h"
 
 #define VARIANT_ARG_LIST const Variant &p_arg1 = Variant(), const Variant &p_arg2 = Variant(), const Variant &p_arg3 = Variant(), const Variant &p_arg4 = Variant(), const Variant &p_arg5 = Variant()
 #define VARIANT_ARG_PASS p_arg1, p_arg2, p_arg3, p_arg4, p_arg5
diff --git a/core/object_id.h b/core/object/object_id.h
index 63b0c27af8..63b0c27af8 100644
--- a/core/object_id.h
+++ b/core/object/object_id.h
diff --git a/core/reference.cpp b/core/object/reference.cpp
index d1dba0d9bf..ce95d83dfc 100644
--- a/core/reference.cpp
+++ b/core/object/reference.cpp
@@ -30,7 +30,7 @@
 
 #include "reference.h"
 
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 
 bool Reference::init_ref() {
 	if (reference()) {
diff --git a/core/reference.h b/core/object/reference.h
index 868894aad4..575f1cd914 100644
--- a/core/reference.h
+++ b/core/object/reference.h
@@ -31,8 +31,8 @@
 #ifndef REFERENCE_H
 #define REFERENCE_H
 
-#include "core/class_db.h"
-#include "core/safe_refcount.h"
+#include "core/object/class_db.h"
+#include "core/templates/safe_refcount.h"
 
 class Reference : public Object {
 	GDCLASS(Reference, Object);
diff --git a/core/script_language.cpp b/core/object/script_language.cpp
index d535c54dea..17ac75e19f 100644
--- a/core/script_language.cpp
+++ b/core/object/script_language.cpp
@@ -30,10 +30,10 @@
 
 #include "script_language.h"
 
+#include "core/config/project_settings.h"
 #include "core/core_string_names.h"
 #include "core/debugger/engine_debugger.h"
 #include "core/debugger/script_debugger.h"
-#include "core/project_settings.h"
 
 #include <stdint.h>
 
diff --git a/core/script_language.h b/core/object/script_language.h
index a94c128932..447216f14f 100644
--- a/core/script_language.h
+++ b/core/object/script_language.h
@@ -32,9 +32,9 @@
 #define SCRIPT_LANGUAGE_H
 
 #include "core/io/multiplayer_api.h"
-#include "core/map.h"
-#include "core/pair.h"
-#include "core/resource.h"
+#include "core/io/resource.h"
+#include "core/templates/map.h"
+#include "core/templates/pair.h"
 
 class ScriptLanguage;
 
diff --git a/core/undo_redo.cpp b/core/object/undo_redo.cpp
index 1dcbb0cd6b..1dcbb0cd6b 100644
--- a/core/undo_redo.cpp
+++ b/core/object/undo_redo.cpp
diff --git a/core/undo_redo.h b/core/object/undo_redo.h
index 68a553efd4..68d78e0d7d 100644
--- a/core/undo_redo.h
+++ b/core/object/undo_redo.h
@@ -31,8 +31,8 @@
 #ifndef UNDO_REDO_H
 #define UNDO_REDO_H
 
-#include "core/class_db.h"
-#include "core/resource.h"
+#include "core/io/resource.h"
+#include "core/object/class_db.h"
 
 class UndoRedo : public Object {
 	GDCLASS(UndoRedo, Object);
diff --git a/core/os/dir_access.cpp b/core/os/dir_access.cpp
index 5e1cb8ea29..30b1b51b53 100644
--- a/core/os/dir_access.cpp
+++ b/core/os/dir_access.cpp
@@ -30,10 +30,10 @@
 
 #include "dir_access.h"
 
+#include "core/config/project_settings.h"
 #include "core/os/file_access.h"
 #include "core/os/memory.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 String DirAccess::_get_root_path() const {
 	switch (_access_type) {
diff --git a/core/os/dir_access.h b/core/os/dir_access.h
index 6bce9a4c12..0f4fa9b250 100644
--- a/core/os/dir_access.h
+++ b/core/os/dir_access.h
@@ -31,8 +31,8 @@
 #ifndef DIR_ACCESS_H
 #define DIR_ACCESS_H
 
+#include "core/string/ustring.h"
 #include "core/typedefs.h"
-#include "core/ustring.h"
 
 //@ TODO, excellent candidate for THREAD_SAFE MACRO, should go through all these and add THREAD_SAFE where it applies
 class DirAccess {
diff --git a/core/os/file_access.cpp b/core/os/file_access.cpp
index 9dbb2952f7..ef3eb6800a 100644
--- a/core/os/file_access.cpp
+++ b/core/os/file_access.cpp
@@ -30,11 +30,11 @@
 
 #include "file_access.h"
 
+#include "core/config/project_settings.h"
 #include "core/crypto/crypto_core.h"
 #include "core/io/file_access_pack.h"
 #include "core/io/marshalls.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 FileAccess::CreateFunc FileAccess::create_func[ACCESS_MAX] = { nullptr, nullptr };
 
diff --git a/core/os/file_access.h b/core/os/file_access.h
index 48b9ee4269..39b977a4d9 100644
--- a/core/os/file_access.h
+++ b/core/os/file_access.h
@@ -33,8 +33,8 @@
 
 #include "core/math/math_defs.h"
 #include "core/os/memory.h"
+#include "core/string/ustring.h"
 #include "core/typedefs.h"
-#include "core/ustring.h"
 
 /**
  * Multi-Platform abstraction for accessing to files.
diff --git a/core/os/keyboard.h b/core/os/keyboard.h
index 5d11e6a378..92664aff8f 100644
--- a/core/os/keyboard.h
+++ b/core/os/keyboard.h
@@ -31,7 +31,7 @@
 #ifndef KEYBOARD_H
 #define KEYBOARD_H
 
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 /*
 	Special Key:
diff --git a/core/os/main_loop.cpp b/core/os/main_loop.cpp
index 6651fb80d7..d29bcd011f 100644
--- a/core/os/main_loop.cpp
+++ b/core/os/main_loop.cpp
@@ -30,7 +30,7 @@
 
 #include "main_loop.h"
 
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 
 void MainLoop::_bind_methods() {
 	BIND_VMETHOD(MethodInfo("_initialize"));
diff --git a/core/os/main_loop.h b/core/os/main_loop.h
index 2c34cf193c..8c46ad9b6a 100644
--- a/core/os/main_loop.h
+++ b/core/os/main_loop.h
@@ -32,8 +32,8 @@
 #define MAIN_LOOP_H
 
 #include "core/input/input_event.h"
-#include "core/reference.h"
-#include "core/script_language.h"
+#include "core/object/reference.h"
+#include "core/object/script_language.h"
 
 class MainLoop : public Object {
 	GDCLASS(MainLoop, Object);
diff --git a/core/os/memory.cpp b/core/os/memory.cpp
index 8457c52092..f2723d13f6 100644
--- a/core/os/memory.cpp
+++ b/core/os/memory.cpp
@@ -30,9 +30,9 @@
 
 #include "memory.h"
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/os/copymem.h"
-#include "core/safe_refcount.h"
+#include "core/templates/safe_refcount.h"
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/core/os/memory.h b/core/os/memory.h
index 46ffb4124b..dee08d4de4 100644
--- a/core/os/memory.h
+++ b/core/os/memory.h
@@ -31,8 +31,8 @@
 #ifndef MEMORY_H
 #define MEMORY_H
 
-#include "core/error_macros.h"
-#include "core/safe_refcount.h"
+#include "core/error/error_macros.h"
+#include "core/templates/safe_refcount.h"
 
 #include <stddef.h>
 
diff --git a/core/os/midi_driver.h b/core/os/midi_driver.h
index bc922e1fcf..f487b31d4c 100644
--- a/core/os/midi_driver.h
+++ b/core/os/midi_driver.h
@@ -32,7 +32,7 @@
 #define MIDI_DRIVER_H
 
 #include "core/typedefs.h"
-#include "core/variant.h"
+#include "core/variant/variant.h"
 
 /**
  * Multi-Platform abstraction for accessing to MIDI.
diff --git a/core/os/mutex.h b/core/os/mutex.h
index d42cbed821..778bdaba09 100644
--- a/core/os/mutex.h
+++ b/core/os/mutex.h
@@ -31,7 +31,7 @@
 #ifndef MUTEX_H
 #define MUTEX_H
 
-#include "core/error_list.h"
+#include "core/error/error_list.h"
 #include "core/typedefs.h"
 
 #if !defined(NO_THREADS)
diff --git a/core/os/os.cpp b/core/os/os.cpp
index 3a398316bd..552bf043bf 100644
--- a/core/os/os.cpp
+++ b/core/os/os.cpp
@@ -30,11 +30,11 @@
 
 #include "os.h"
 
+#include "core/config/project_settings.h"
 #include "core/input/input.h"
 #include "core/os/dir_access.h"
 #include "core/os/file_access.h"
 #include "core/os/midi_driver.h"
-#include "core/project_settings.h"
 #include "core/version_generated.gen.h"
 #include "servers/audio_server.h"
 
diff --git a/core/os/os.h b/core/os/os.h
index 4c1d930107..a1e75b5ee9 100644
--- a/core/os/os.h
+++ b/core/os/os.h
@@ -31,13 +31,13 @@
 #ifndef OS_H
 #define OS_H
 
-#include "core/engine.h"
-#include "core/image.h"
+#include "core/config/engine.h"
+#include "core/io/image.h"
 #include "core/io/logger.h"
-#include "core/list.h"
 #include "core/os/main_loop.h"
-#include "core/ustring.h"
-#include "core/vector.h"
+#include "core/string/ustring.h"
+#include "core/templates/list.h"
+#include "core/templates/vector.h"
 
 #include <stdarg.h>
 
diff --git a/core/pool_allocator.cpp b/core/os/pool_allocator.cpp
index b222c20a00..52536ff45d 100644
--- a/core/pool_allocator.cpp
+++ b/core/os/pool_allocator.cpp
@@ -30,11 +30,11 @@
 
 #include "pool_allocator.h"
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/os/copymem.h"
 #include "core/os/memory.h"
 #include "core/os/os.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 #include <assert.h>
 
diff --git a/core/pool_allocator.h b/core/os/pool_allocator.h
index 7d77af6266..7d77af6266 100644
--- a/core/pool_allocator.h
+++ b/core/os/pool_allocator.h
diff --git a/core/os/rw_lock.cpp b/core/os/rw_lock.cpp
index a668fe2b4c..669f05c6b0 100644
--- a/core/os/rw_lock.cpp
+++ b/core/os/rw_lock.cpp
@@ -30,7 +30,7 @@
 
 #include "rw_lock.h"
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 
 #include <stddef.h>
 
diff --git a/core/os/rw_lock.h b/core/os/rw_lock.h
index 1035072cce..1190102a83 100644
--- a/core/os/rw_lock.h
+++ b/core/os/rw_lock.h
@@ -31,7 +31,7 @@
 #ifndef RW_LOCK_H
 #define RW_LOCK_H
 
-#include "core/error_list.h"
+#include "core/error/error_list.h"
 
 class RWLock {
 protected:
diff --git a/core/os/semaphore.h b/core/os/semaphore.h
index 077e04704b..b170cada3a 100644
--- a/core/os/semaphore.h
+++ b/core/os/semaphore.h
@@ -31,7 +31,7 @@
 #ifndef SEMAPHORE_H
 #define SEMAPHORE_H
 
-#include "core/error_list.h"
+#include "core/error/error_list.h"
 #include "core/typedefs.h"
 
 #if !defined(NO_THREADS)
diff --git a/core/spin_lock.h b/core/os/spin_lock.h
index 1bb810bb29..1bb810bb29 100644
--- a/core/spin_lock.h
+++ b/core/os/spin_lock.h
diff --git a/core/os/thread.h b/core/os/thread.h
index f761d4ca43..d68476e683 100644
--- a/core/os/thread.h
+++ b/core/os/thread.h
@@ -31,8 +31,8 @@
 #ifndef THREAD_H
 #define THREAD_H
 
+#include "core/string/ustring.h"
 #include "core/typedefs.h"
-#include "core/ustring.h"
 
 typedef void (*ThreadCreateCallback)(void *p_userdata);
 
diff --git a/core/os/threaded_array_processor.h b/core/os/threaded_array_processor.h
index d27399e4cc..ed141a5339 100644
--- a/core/os/threaded_array_processor.h
+++ b/core/os/threaded_array_processor.h
@@ -35,7 +35,7 @@
 #include "core/os/os.h"
 #include "core/os/thread.h"
 #include "core/os/thread_safe.h"
-#include "core/safe_refcount.h"
+#include "core/templates/safe_refcount.h"
 
 template <class C, class U>
 struct ThreadArrayProcessData {
diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp
index a2b3f75bea..6bbdad11f8 100644
--- a/core/register_core_types.cpp
+++ b/core/register_core_types.cpp
@@ -30,15 +30,13 @@
 
 #include "register_core_types.h"
 
-#include "core/bind/core_bind.h"
-#include "core/class_db.h"
-#include "core/compressed_translation.h"
+#include "core/config/engine.h"
+#include "core/config/project_settings.h"
+#include "core/core_bind.h"
 #include "core/core_string_names.h"
 #include "core/crypto/aes_context.h"
 #include "core/crypto/crypto.h"
 #include "core/crypto/hashing_context.h"
-#include "core/engine.h"
-#include "core/func_ref.h"
 #include "core/input/input.h"
 #include "core/input/input_map.h"
 #include "core/io/config_file.h"
@@ -48,6 +46,7 @@
 #include "core/io/marshalls.h"
 #include "core/io/multiplayer_api.h"
 #include "core/io/networked_multiplayer_peer.h"
+#include "core/io/packed_data_container.h"
 #include "core/io/packet_peer.h"
 #include "core/io/packet_peer_dtls.h"
 #include "core/io/packet_peer_udp.h"
@@ -65,11 +64,11 @@
 #include "core/math/geometry_3d.h"
 #include "core/math/random_number_generator.h"
 #include "core/math/triangle_mesh.h"
+#include "core/object/class_db.h"
+#include "core/object/undo_redo.h"
 #include "core/os/main_loop.h"
-#include "core/packed_data_container.h"
-#include "core/project_settings.h"
-#include "core/translation.h"
-#include "core/undo_redo.h"
+#include "core/string/compressed_translation.h"
+#include "core/string/translation.h"
 
 static Ref<ResourceFormatSaverBinary> resource_saver_binary;
 static Ref<ResourceFormatLoaderBinary> resource_loader_binary;
@@ -97,8 +96,6 @@ extern Mutex _global_mutex;
 
 extern void register_global_constants();
 extern void unregister_global_constants();
-extern void register_variant_methods();
-extern void unregister_variant_methods();
 
 void register_core_types() {
 	//consistency check
@@ -111,7 +108,8 @@ void register_core_types() {
 	ResourceLoader::initialize();
 
 	register_global_constants();
-	register_variant_methods();
+
+	Variant::register_types();
 
 	CoreStringNames::create();
 
@@ -155,7 +153,6 @@ void register_core_types() {
 	ClassDB::register_class<InputEventPanGesture>();
 	ClassDB::register_class<InputEventMIDI>();
 
-	ClassDB::register_class<FuncRef>();
 	ClassDB::register_virtual_class<StreamPeer>();
 	ClassDB::register_class<StreamPeerBuffer>();
 	ClassDB::register_class<StreamPeerTCP>();
@@ -319,7 +316,8 @@ void unregister_core_types() {
 	ClassDB::cleanup_defaults();
 	ObjectDB::cleanup();
 
-	unregister_variant_methods();
+	Variant::unregister_types();
+
 	unregister_global_constants();
 
 	ClassDB::cleanup();
diff --git a/core/string/SCsub b/core/string/SCsub
new file mode 100644
index 0000000000..3217166f18
--- /dev/null
+++ b/core/string/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env_string = env.Clone()
+
+env_string.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/compressed_translation.cpp b/core/string/compressed_translation.cpp
index a92275565d..bdb296a79b 100644
--- a/core/compressed_translation.cpp
+++ b/core/string/compressed_translation.cpp
@@ -30,7 +30,7 @@
 
 #include "compressed_translation.h"
 
-#include "core/pair.h"
+#include "core/templates/pair.h"
 
 extern "C" {
 #include "thirdparty/misc/smaz.h"
diff --git a/core/compressed_translation.h b/core/string/compressed_translation.h
index c8b3cd2330..efb3535362 100644
--- a/core/compressed_translation.h
+++ b/core/string/compressed_translation.h
@@ -31,7 +31,7 @@
 #ifndef COMPRESSED_TRANSLATION_H
 #define COMPRESSED_TRANSLATION_H
 
-#include "core/translation.h"
+#include "core/string/translation.h"
 
 class PHashTranslation : public Translation {
 	GDCLASS(PHashTranslation, Translation);
diff --git a/core/node_path.cpp b/core/string/node_path.cpp
index 2a51dca74a..4d152d9258 100644
--- a/core/node_path.cpp
+++ b/core/string/node_path.cpp
@@ -30,7 +30,7 @@
 
 #include "node_path.h"
 
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 void NodePath::_update_hash_cache() const {
 	uint32_t h = data->absolute ? 1 : 0;
diff --git a/core/node_path.h b/core/string/node_path.h
index 7c06bf01ce..b4513ddb3c 100644
--- a/core/node_path.h
+++ b/core/string/node_path.h
@@ -31,8 +31,8 @@
 #ifndef NODE_PATH_H
 #define NODE_PATH_H
 
-#include "core/string_name.h"
-#include "core/ustring.h"
+#include "core/string/string_name.h"
+#include "core/string/ustring.h"
 
 class NodePath {
 	struct Data {
diff --git a/core/print_string.cpp b/core/string/print_string.cpp
index 54de229471..54de229471 100644
--- a/core/print_string.cpp
+++ b/core/string/print_string.cpp
diff --git a/core/print_string.h b/core/string/print_string.h
index 4d03f4a6de..3e8f244cc5 100644
--- a/core/print_string.h
+++ b/core/string/print_string.h
@@ -31,7 +31,7 @@
 #ifndef PRINT_STRING_H
 #define PRINT_STRING_H
 
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 extern void (*_print_func)(String);
 
diff --git a/core/string_buffer.h b/core/string/string_buffer.h
index a685720851..1317b538d4 100644
--- a/core/string_buffer.h
+++ b/core/string/string_buffer.h
@@ -31,7 +31,7 @@
 #ifndef STRING_BUFFER_H
 #define STRING_BUFFER_H
 
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 template <int SHORT_BUFFER_SIZE = 64>
 class StringBuffer {
diff --git a/core/string_builder.cpp b/core/string/string_builder.cpp
index dec299ffa3..dec299ffa3 100644
--- a/core/string_builder.cpp
+++ b/core/string/string_builder.cpp
diff --git a/core/string_builder.h b/core/string/string_builder.h
index 2a37d14218..c732f1b9ea 100644
--- a/core/string_builder.h
+++ b/core/string/string_builder.h
@@ -31,8 +31,8 @@
 #ifndef STRING_BUILDER_H
 #define STRING_BUILDER_H
 
-#include "core/ustring.h"
-#include "core/vector.h"
+#include "core/string/ustring.h"
+#include "core/templates/vector.h"
 
 class StringBuilder {
 	uint32_t string_length = 0;
diff --git a/core/string_name.cpp b/core/string/string_name.cpp
index 6260e3ce8c..34afdaee38 100644
--- a/core/string_name.cpp
+++ b/core/string/string_name.cpp
@@ -31,7 +31,7 @@
 #include "string_name.h"
 
 #include "core/os/os.h"
-#include "core/print_string.h"
+#include "core/string/print_string.h"
 
 StaticCString StaticCString::create(const char *p_ptr) {
 	StaticCString scs;
@@ -377,3 +377,17 @@ StringName StringName::search(const String &p_name) {
 StringName::~StringName() {
 	unref();
 }
+
+bool operator==(const String &p_name, const StringName &p_string_name) {
+	return p_name == p_string_name.operator String();
+}
+bool operator!=(const String &p_name, const StringName &p_string_name) {
+	return p_name != p_string_name.operator String();
+}
+
+bool operator==(const char *p_name, const StringName &p_string_name) {
+	return p_name == p_string_name.operator String();
+}
+bool operator!=(const char *p_name, const StringName &p_string_name) {
+	return p_name != p_string_name.operator String();
+}
diff --git a/core/string_name.h b/core/string/string_name.h
index 4f90479bda..e6b46506c3 100644
--- a/core/string_name.h
+++ b/core/string/string_name.h
@@ -32,8 +32,8 @@
 #define STRING_NAME_H
 
 #include "core/os/mutex.h"
-#include "core/safe_refcount.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
+#include "core/templates/safe_refcount.h"
 
 class Main;
 
@@ -155,6 +155,11 @@ public:
 	~StringName();
 };
 
+bool operator==(const String &p_name, const StringName &p_string_name);
+bool operator!=(const String &p_name, const StringName &p_string_name);
+bool operator==(const char *p_name, const StringName &p_string_name);
+bool operator!=(const char *p_name, const StringName &p_string_name);
+
 StringName _scs_create(const char *p_chr);
 
 #endif // STRING_NAME_H
diff --git a/core/translation.cpp b/core/string/translation.cpp
index 8c8ca06740..df8a26e5ce 100644
--- a/core/translation.cpp
+++ b/core/string/translation.cpp
@@ -30,9 +30,9 @@
 
 #include "translation.h"
 
+#include "core/config/project_settings.h"
 #include "core/io/resource_loader.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 // ISO 639-1 language codes, with the addition of glibc locales with their
 // regional identifiers. This list must match the language names (in English)
diff --git a/core/translation.h b/core/string/translation.h
index cba25a434f..8d34f7997e 100644
--- a/core/translation.h
+++ b/core/string/translation.h
@@ -31,7 +31,7 @@
 #ifndef TRANSLATION_H
 #define TRANSLATION_H
 
-#include "core/resource.h"
+#include "core/io/resource.h"
 
 class Translation : public Resource {
 	GDCLASS(Translation, Resource);
diff --git a/core/translation_po.cpp b/core/string/translation_po.cpp
index 203f29026b..203f29026b 100644
--- a/core/translation_po.cpp
+++ b/core/string/translation_po.cpp
diff --git a/core/translation_po.h b/core/string/translation_po.h
index 88830210ef..c8a47bec5a 100644
--- a/core/translation_po.h
+++ b/core/string/translation_po.h
@@ -34,7 +34,7 @@
 //#define DEBUG_TRANSLATION_PO
 
 #include "core/math/expression.h"
-#include "core/translation.h"
+#include "core/string/translation.h"
 
 class TranslationPO : public Translation {
 	GDCLASS(TranslationPO, Translation);
diff --git a/core/ucaps.h b/core/string/ucaps.h
index 79b346acba..79b346acba 100644
--- a/core/ucaps.h
+++ b/core/string/ucaps.h
diff --git a/core/ustring.cpp b/core/string/ustring.cpp
index 27dab8db6e..b5758bddf3 100644
--- a/core/ustring.cpp
+++ b/core/string/ustring.cpp
@@ -30,14 +30,14 @@
 
 #include "ustring.h"
 
-#include "core/color.h"
 #include "core/crypto/crypto_core.h"
+#include "core/math/color.h"
 #include "core/math/math_funcs.h"
 #include "core/os/memory.h"
-#include "core/print_string.h"
-#include "core/translation.h"
-#include "core/ucaps.h"
-#include "core/variant.h"
+#include "core/string/print_string.h"
+#include "core/string/translation.h"
+#include "core/string/ucaps.h"
+#include "core/variant/variant.h"
 
 #include <cstdint>
 
@@ -637,6 +637,20 @@ bool operator==(const wchar_t *p_chr, const String &p_str) {
 #endif
 }
 
+bool operator!=(const char *p_chr, const String &p_str) {
+	return !(p_str == p_chr);
+}
+
+bool operator!=(const wchar_t *p_chr, const String &p_str) {
+#ifdef WINDOWS_ENABLED
+	// wchar_t is 16-bit
+	return !(p_str == String::utf16((const char16_t *)p_chr));
+#else
+	// wchar_t is 32-bi
+	return !(p_str == String((const char32_t *)p_chr));
+#endif
+}
+
 bool String::operator!=(const char *p_str) const {
 	return (!(*this == p_str));
 }
@@ -654,7 +668,14 @@ bool String::operator!=(const String &p_str) const {
 }
 
 bool String::operator<=(const String &p_str) const {
-	return (*this < p_str) || (*this == p_str);
+	return !(p_str < *this);
+}
+
+bool String::operator>(const String &p_str) const {
+	return p_str < *this;
+}
+bool String::operator>=(const String &p_str) const {
+	return !(*this < p_str);
 }
 
 bool String::operator<(const char *p_str) const {
@@ -4455,7 +4476,9 @@ String String::sprintf(const Array &values, bool *error) const {
 	bool left_justified = false;
 	bool show_sign = false;
 
-	*error = true;
+	if (error) {
+		*error = true;
+	}
 
 	for (; *self; self++) {
 		const char32_t c = *self;
@@ -4716,7 +4739,9 @@ String String::sprintf(const Array &values, bool *error) const {
 		return "not all arguments converted during string formatting";
 	}
 
-	*error = false;
+	if (error) {
+		*error = false;
+	}
 	return formatted;
 }
 
diff --git a/core/ustring.h b/core/string/ustring.h
index bf9c06b9ca..201b439b12 100644
--- a/core/ustring.h
+++ b/core/string/ustring.h
@@ -31,10 +31,10 @@
 #ifndef USTRING_H
 #define USTRING_H
 
-#include "core/array.h"
-#include "core/cowdata.h"
+#include "core/templates/cowdata.h"
+#include "core/templates/vector.h"
 #include "core/typedefs.h"
-#include "core/vector.h"
+#include "core/variant/array.h"
 
 /*************************************************************************/
 /*  CharProxy                                                            */
@@ -254,6 +254,8 @@ public:
 
 	bool operator<(const String &p_str) const;
 	bool operator<=(const String &p_str) const;
+	bool operator>(const String &p_str) const;
+	bool operator>=(const String &p_str) const;
 
 	signed char casecmp_to(const String &p_str) const;
 	signed char nocasecmp_to(const String &p_str) const;
@@ -431,10 +433,10 @@ public:
 	/**
 	 * The constructors must not depend on other overloads
 	 */
-	/*	String(char32_t p_char);*/
 
 	_FORCE_INLINE_ String() {}
 	_FORCE_INLINE_ String(const String &p_str) { _cowdata._ref(p_str._cowdata); }
+
 	String &operator=(const String &p_str) {
 		_cowdata._ref(p_str._cowdata);
 		return *this;
@@ -456,6 +458,8 @@ public:
 
 bool operator==(const char *p_chr, const String &p_str);
 bool operator==(const wchar_t *p_chr, const String &p_str);
+bool operator!=(const char *p_chr, const String &p_str);
+bool operator!=(const wchar_t *p_chr, const String &p_str);
 
 String operator+(const char *p_chr, const String &p_str);
 String operator+(const wchar_t *p_chr, const String &p_str);
diff --git a/core/templates/SCsub b/core/templates/SCsub
new file mode 100644
index 0000000000..8c4c843a33
--- /dev/null
+++ b/core/templates/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env_templates = env.Clone()
+
+env_templates.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/command_queue_mt.cpp b/core/templates/command_queue_mt.cpp
index a55eed5d3c..a94853a21c 100644
--- a/core/command_queue_mt.cpp
+++ b/core/templates/command_queue_mt.cpp
@@ -30,8 +30,8 @@
 
 #include "command_queue_mt.h"
 
+#include "core/config/project_settings.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 
 void CommandQueueMT::lock() {
 	mutex.lock();
diff --git a/core/command_queue_mt.h b/core/templates/command_queue_mt.h
index 0e5bc7f369..ac38d330de 100644
--- a/core/command_queue_mt.h
+++ b/core/templates/command_queue_mt.h
@@ -34,7 +34,7 @@
 #include "core/os/memory.h"
 #include "core/os/mutex.h"
 #include "core/os/semaphore.h"
-#include "core/simple_type.h"
+#include "core/templates/simple_type.h"
 #include "core/typedefs.h"
 
 #define COMMA(N) _COMMA_##N
diff --git a/core/cowdata.h b/core/templates/cowdata.h
index 79676e6d80..d5eb08286d 100644
--- a/core/cowdata.h
+++ b/core/templates/cowdata.h
@@ -31,9 +31,9 @@
 #ifndef COWDATA_H
 #define COWDATA_H
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/os/memory.h"
-#include "core/safe_refcount.h"
+#include "core/templates/safe_refcount.h"
 
 #include <string.h>
 
diff --git a/core/hash_map.h b/core/templates/hash_map.h
index 10fc931e7a..f6b889015a 100644
--- a/core/hash_map.h
+++ b/core/templates/hash_map.h
@@ -31,12 +31,12 @@
 #ifndef HASH_MAP_H
 #define HASH_MAP_H
 
-#include "core/error_macros.h"
-#include "core/hashfuncs.h"
-#include "core/list.h"
+#include "core/error/error_macros.h"
 #include "core/math/math_funcs.h"
 #include "core/os/memory.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
+#include "core/templates/hashfuncs.h"
+#include "core/templates/list.h"
 
 /**
  * @class HashMap
diff --git a/core/hashfuncs.h b/core/templates/hashfuncs.h
index f4048843fc..86bb1b5228 100644
--- a/core/hashfuncs.h
+++ b/core/templates/hashfuncs.h
@@ -33,12 +33,12 @@
 
 #include "core/math/math_defs.h"
 #include "core/math/math_funcs.h"
-#include "core/node_path.h"
-#include "core/object_id.h"
-#include "core/rid.h"
-#include "core/string_name.h"
+#include "core/object/object_id.h"
+#include "core/string/node_path.h"
+#include "core/string/string_name.h"
+#include "core/string/ustring.h"
+#include "core/templates/rid.h"
 #include "core/typedefs.h"
-#include "core/ustring.h"
 /**
  * Hashing functions
  */
diff --git a/core/list.h b/core/templates/list.h
index 1cef3c484d..d745066e4c 100644
--- a/core/list.h
+++ b/core/templates/list.h
@@ -31,9 +31,9 @@
 #ifndef LIST_H
 #define LIST_H
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/os/memory.h"
-#include "core/sort_array.h"
+#include "core/templates/sort_array.h"
 
 /**
  * Generic Templatized Linked List Implementation.
diff --git a/core/local_vector.h b/core/templates/local_vector.h
index b0dbd22b29..4ef040dc77 100644
--- a/core/local_vector.h
+++ b/core/templates/local_vector.h
@@ -31,11 +31,11 @@
 #ifndef LOCAL_VECTOR_H
 #define LOCAL_VECTOR_H
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/os/copymem.h"
 #include "core/os/memory.h"
-#include "core/sort_array.h"
-#include "core/vector.h"
+#include "core/templates/sort_array.h"
+#include "core/templates/vector.h"
 
 template <class T, class U = uint32_t, bool force_trivial = false>
 class LocalVector {
diff --git a/core/map.h b/core/templates/map.h
index fd4f500556..c454d69256 100644
--- a/core/map.h
+++ b/core/templates/map.h
@@ -31,8 +31,8 @@
 #ifndef MAP_H
 #define MAP_H
 
-#include "core/error_macros.h"
-#include "core/set.h"
+#include "core/error/error_macros.h"
+#include "core/templates/set.h"
 
 // based on the very nice implementation of rb-trees by:
 // https://web.archive.org/web/20120507164830/http://web.mit.edu/~emin/www/source_code/red_black_tree/index.html
diff --git a/core/oa_hash_map.h b/core/templates/oa_hash_map.h
index 6061366ab3..d9d632b4ce 100644
--- a/core/oa_hash_map.h
+++ b/core/templates/oa_hash_map.h
@@ -31,10 +31,10 @@
 #ifndef OA_HASH_MAP_H
 #define OA_HASH_MAP_H
 
-#include "core/hashfuncs.h"
 #include "core/math/math_funcs.h"
 #include "core/os/copymem.h"
 #include "core/os/memory.h"
+#include "core/templates/hashfuncs.h"
 
 /**
  * A HashMap implementation that uses open addressing with Robin Hood hashing.
diff --git a/core/ordered_hash_map.h b/core/templates/ordered_hash_map.h
index e6a6340a2f..9398868b01 100644
--- a/core/ordered_hash_map.h
+++ b/core/templates/ordered_hash_map.h
@@ -31,9 +31,9 @@
 #ifndef ORDERED_HASH_MAP_H
 #define ORDERED_HASH_MAP_H
 
-#include "core/hash_map.h"
-#include "core/list.h"
-#include "core/pair.h"
+#include "core/templates/hash_map.h"
+#include "core/templates/list.h"
+#include "core/templates/pair.h"
 
 /**
  * A hash map which allows to iterate elements in insertion order.
diff --git a/core/pair.h b/core/templates/pair.h
index 89ea2b9fd9..89ea2b9fd9 100644
--- a/core/pair.h
+++ b/core/templates/pair.h
diff --git a/core/rid.h b/core/templates/rid.h
index 4b65f3fb6a..a475d166d5 100644
--- a/core/rid.h
+++ b/core/templates/rid.h
@@ -52,6 +52,9 @@ public:
 	_FORCE_INLINE_ bool operator>(const RID &p_rid) const {
 		return _id > p_rid._id;
 	}
+	_FORCE_INLINE_ bool operator>=(const RID &p_rid) const {
+		return _id >= p_rid._id;
+	}
 	_FORCE_INLINE_ bool operator!=(const RID &p_rid) const {
 		return _id != p_rid._id;
 	}
diff --git a/core/rid_owner.cpp b/core/templates/rid_owner.cpp
index a5065f29f8..a5065f29f8 100644
--- a/core/rid_owner.cpp
+++ b/core/templates/rid_owner.cpp
diff --git a/core/rid_owner.h b/core/templates/rid_owner.h
index 30f1e41733..d1bcb92010 100644
--- a/core/rid_owner.h
+++ b/core/templates/rid_owner.h
@@ -31,14 +31,14 @@
 #ifndef RID_OWNER_H
 #define RID_OWNER_H
 
-#include "core/list.h"
-#include "core/oa_hash_map.h"
 #include "core/os/memory.h"
-#include "core/print_string.h"
-#include "core/rid.h"
-#include "core/safe_refcount.h"
-#include "core/set.h"
-#include "core/spin_lock.h"
+#include "core/os/spin_lock.h"
+#include "core/string/print_string.h"
+#include "core/templates/list.h"
+#include "core/templates/oa_hash_map.h"
+#include "core/templates/rid.h"
+#include "core/templates/safe_refcount.h"
+#include "core/templates/set.h"
 
 #include <stdio.h>
 #include <typeinfo>
diff --git a/core/ring_buffer.h b/core/templates/ring_buffer.h
index 6b71d12cf3..12ec047fb6 100644
--- a/core/ring_buffer.h
+++ b/core/templates/ring_buffer.h
@@ -31,7 +31,7 @@
 #ifndef RING_BUFFER_H
 #define RING_BUFFER_H
 
-#include "core/vector.h"
+#include "core/templates/vector.h"
 
 template <typename T>
 class RingBuffer {
diff --git a/core/safe_refcount.cpp b/core/templates/safe_refcount.cpp
index d5ee778ef7..d5ee778ef7 100644
--- a/core/safe_refcount.cpp
+++ b/core/templates/safe_refcount.cpp
diff --git a/core/safe_refcount.h b/core/templates/safe_refcount.h
index dc4e62354a..dc4e62354a 100644
--- a/core/safe_refcount.h
+++ b/core/templates/safe_refcount.h
diff --git a/core/self_list.h b/core/templates/self_list.h
index 3104bcb714..2a037d109c 100644
--- a/core/self_list.h
+++ b/core/templates/self_list.h
@@ -31,7 +31,7 @@
 #ifndef SELF_LIST_H
 #define SELF_LIST_H
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/typedefs.h"
 
 template <class T>
diff --git a/core/set.h b/core/templates/set.h
index 1bc0a3f41e..1bc0a3f41e 100644
--- a/core/set.h
+++ b/core/templates/set.h
diff --git a/core/simple_type.h b/core/templates/simple_type.h
index 841ab9f384..841ab9f384 100644
--- a/core/simple_type.h
+++ b/core/templates/simple_type.h
diff --git a/core/sort_array.h b/core/templates/sort_array.h
index 93cc6f727d..a4326ac565 100644
--- a/core/sort_array.h
+++ b/core/templates/sort_array.h
@@ -31,7 +31,7 @@
 #ifndef SORT_ARRAY_H
 #define SORT_ARRAY_H
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/typedefs.h"
 
 #define ERR_BAD_COMPARE(cond)                                         \
diff --git a/core/thread_work_pool.cpp b/core/templates/thread_work_pool.cpp
index 3a95e83ffc..3a95e83ffc 100644
--- a/core/thread_work_pool.cpp
+++ b/core/templates/thread_work_pool.cpp
diff --git a/core/thread_work_pool.h b/core/templates/thread_work_pool.h
index 661060aa3f..661060aa3f 100644
--- a/core/thread_work_pool.h
+++ b/core/templates/thread_work_pool.h
diff --git a/core/vector.h b/core/templates/vector.h
index 5a61f0eae3..9d45f7c30a 100644
--- a/core/vector.h
+++ b/core/templates/vector.h
@@ -37,11 +37,11 @@
  * Vector container. Regular Vector Container. Use with care and for smaller arrays when possible. Use Vector for large arrays.
 */
 
-#include "core/cowdata.h"
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/os/copymem.h"
 #include "core/os/memory.h"
-#include "core/sort_array.h"
+#include "core/templates/cowdata.h"
+#include "core/templates/sort_array.h"
 
 template <class T>
 class VectorWriteProxy {
@@ -157,6 +157,32 @@ public:
 		return slice;
 	}
 
+	bool operator==(const Vector<T> &p_arr) const {
+		int s = size();
+		if (s != p_arr.size()) {
+			return false;
+		}
+		for (int i = 0; i < s; i++) {
+			if (operator[](i) != p_arr[i]) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	bool operator!=(const Vector<T> &p_arr) const {
+		int s = size();
+		if (s != p_arr.size()) {
+			return true;
+		}
+		for (int i = 0; i < s; i++) {
+			if (operator[](i) != p_arr[i]) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	_FORCE_INLINE_ Vector() {}
 	_FORCE_INLINE_ Vector(const Vector &p_from) { _cowdata._ref(p_from._cowdata); }
 
diff --git a/core/vmap.h b/core/templates/vmap.h
index c91ea9b3c9..8d2a3d2a9c 100644
--- a/core/vmap.h
+++ b/core/templates/vmap.h
@@ -31,7 +31,7 @@
 #ifndef VMAP_H
 #define VMAP_H
 
-#include "core/cowdata.h"
+#include "core/templates/cowdata.h"
 #include "core/typedefs.h"
 
 template <class T, class V>
diff --git a/core/vset.h b/core/templates/vset.h
index 034b8fe851..4c0b8717b6 100644
--- a/core/vset.h
+++ b/core/templates/vset.h
@@ -31,8 +31,8 @@
 #ifndef VSET_H
 #define VSET_H
 
+#include "core/templates/vector.h"
 #include "core/typedefs.h"
-#include "core/vector.h"
 
 template <class T>
 class VSet {
diff --git a/core/typedefs.h b/core/typedefs.h
index f0c32f2c95..d7ee5ee40e 100644
--- a/core/typedefs.h
+++ b/core/typedefs.h
@@ -41,8 +41,8 @@
 #include "platform_config.h"
 
 // Should be available everywhere.
-#include "core/error_list.h"
-#include "core/int_types.h"
+#include "core/error/error_list.h"
+#include <cstdint>
 
 // Turn argument to string constant:
 // https://gcc.gnu.org/onlinedocs/cpp/Stringizing.html#Stringizing
diff --git a/core/variant/SCsub b/core/variant/SCsub
new file mode 100644
index 0000000000..7f4c8b7788
--- /dev/null
+++ b/core/variant/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env_variant = env.Clone()
+
+env_variant.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/array.cpp b/core/variant/array.cpp
index c6e90d71ec..04ee47efff 100644
--- a/core/array.cpp
+++ b/core/variant/array.cpp
@@ -31,11 +31,11 @@
 #include "array.h"
 
 #include "container_type_validate.h"
-#include "core/class_db.h"
-#include "core/hashfuncs.h"
-#include "core/script_language.h"
-#include "core/variant.h"
-#include "core/vector.h"
+#include "core/object/class_db.h"
+#include "core/object/script_language.h"
+#include "core/templates/hashfuncs.h"
+#include "core/templates/vector.h"
+#include "core/variant/variant.h"
 
 class ArrayPrivate {
 public:
@@ -98,6 +98,37 @@ bool Array::operator==(const Array &p_array) const {
 	return _p == p_array._p;
 }
 
+bool Array::operator!=(const Array &p_array) const {
+	return !operator==(p_array);
+}
+
+bool Array::operator<(const Array &p_array) const {
+	int a_len = size();
+	int b_len = p_array.size();
+
+	int min_cmp = MIN(a_len, b_len);
+
+	for (int i = 0; i < min_cmp; i++) {
+		if (operator[](i) < p_array[i]) {
+			return true;
+		} else if (p_array[i] < operator[](i)) {
+			return false;
+		}
+	}
+
+	return a_len < b_len;
+}
+
+bool Array::operator<=(const Array &p_array) const {
+	return !operator>(p_array);
+}
+bool Array::operator>(const Array &p_array) const {
+	return p_array < *this;
+}
+bool Array::operator>=(const Array &p_array) const {
+	return !operator<(p_array);
+}
+
 uint32_t Array::hash() const {
 	uint32_t h = hash_djb2_one_32(0);
 
@@ -134,7 +165,7 @@ void Array::_assign(const Array &p_array) {
 				} else if (Variant::can_convert_strict(src_val.get_type(), _p->typed.type)) {
 					Variant *ptr = &src_val;
 					Callable::CallError ce;
-					new_array.write[i] = Variant::construct(_p->typed.type, (const Variant **)&ptr, 1, ce, true);
+					Variant::construct(_p->typed.type, new_array.write[i], (const Variant **)&ptr, 1, ce);
 					if (ce.error != Callable::CallError::CALL_OK) {
 						ERR_FAIL_MSG("Unable to convert array index " + itos(i) + " from '" + Variant::get_type_name(src_val.get_type()) + "' to '" + Variant::get_type_name(_p->typed.type) + "'.");
 					}
diff --git a/core/array.h b/core/variant/array.h
index 34367088e4..b37d600abd 100644
--- a/core/array.h
+++ b/core/variant/array.h
@@ -61,6 +61,7 @@ public:
 	void clear();
 
 	bool operator==(const Array &p_array) const;
+	bool operator!=(const Array &p_array) const;
 
 	uint32_t hash() const;
 	void operator=(const Array &p_array);
@@ -98,6 +99,11 @@ public:
 
 	Array slice(int p_begin, int p_end, int p_step = 1, bool p_deep = false) const;
 
+	bool operator<(const Array &p_array) const;
+	bool operator<=(const Array &p_array) const;
+	bool operator>(const Array &p_array) const;
+	bool operator>=(const Array &p_array) const;
+
 	Variant min() const;
 	Variant max() const;
 
diff --git a/core/binder_common.h b/core/variant/binder_common.h
index 0fbfa56230..e72f76c5e1 100644
--- a/core/binder_common.h
+++ b/core/variant/binder_common.h
@@ -31,14 +31,14 @@
 #ifndef BINDER_COMMON_H
 #define BINDER_COMMON_H
 
-#include "core/list.h"
-#include "core/method_ptrcall.h"
-#include "core/object.h"
-#include "core/simple_type.h"
-#include "core/type_info.h"
+#include "core/object/object.h"
+#include "core/templates/list.h"
+#include "core/templates/simple_type.h"
 #include "core/typedefs.h"
-#include "core/variant.h"
-#include "core/variant_internal.h"
+#include "core/variant/method_ptrcall.h"
+#include "core/variant/type_info.h"
+#include "core/variant/variant.h"
+#include "core/variant/variant_internal.h"
 
 #include <stdio.h>
 
diff --git a/core/callable.cpp b/core/variant/callable.cpp
index c368565687..e504fd05e3 100644
--- a/core/callable.cpp
+++ b/core/variant/callable.cpp
@@ -31,10 +31,10 @@
 #include "callable.h"
 
 #include "callable_bind.h"
-#include "core/script_language.h"
-#include "message_queue.h"
-#include "object.h"
-#include "reference.h"
+#include "core/object/message_queue.h"
+#include "core/object/object.h"
+#include "core/object/reference.h"
+#include "core/object/script_language.h"
 
 void Callable::call_deferred(const Variant **p_arguments, int p_argcount) const {
 	MessageQueue::get_singleton()->push_callable(*this, p_arguments, p_argcount);
diff --git a/core/callable.h b/core/variant/callable.h
index 936272a681..40621fbde3 100644
--- a/core/callable.h
+++ b/core/variant/callable.h
@@ -31,9 +31,9 @@
 #ifndef CALLABLE_H
 #define CALLABLE_H
 
-#include "core/list.h"
-#include "core/object_id.h"
-#include "core/string_name.h"
+#include "core/object/object_id.h"
+#include "core/string/string_name.h"
+#include "core/templates/list.h"
 
 class Object;
 class Variant;
diff --git a/core/callable_bind.cpp b/core/variant/callable_bind.cpp
index da08d3ccbd..da08d3ccbd 100644
--- a/core/callable_bind.cpp
+++ b/core/variant/callable_bind.cpp
diff --git a/core/callable_bind.h b/core/variant/callable_bind.h
index 21b9228be3..fc5659e412 100644
--- a/core/callable_bind.h
+++ b/core/variant/callable_bind.h
@@ -31,8 +31,8 @@
 #ifndef CALLABLE_BIND_H
 #define CALLABLE_BIND_H
 
-#include "core/callable.h"
-#include "core/variant.h"
+#include "core/variant/callable.h"
+#include "core/variant/variant.h"
 
 class CallableCustomBind : public CallableCustom {
 	Callable callable;
diff --git a/core/container_type_validate.h b/core/variant/container_type_validate.h
index 8a361aa0ef..4d3a5f683b 100644
--- a/core/container_type_validate.h
+++ b/core/variant/container_type_validate.h
@@ -31,8 +31,8 @@
 #ifndef CONTAINER_TYPE_VALIDATE_H
 #define CONTAINER_TYPE_VALIDATE_H
 
-#include "core/script_language.h"
-#include "core/variant.h"
+#include "core/object/script_language.h"
+#include "core/variant/variant.h"
 
 struct ContainerTypeValidate {
 	Variant::Type type = Variant::NIL;
diff --git a/core/dictionary.cpp b/core/variant/dictionary.cpp
index 052e1bdae1..2bc1f7a86d 100644
--- a/core/dictionary.cpp
+++ b/core/variant/dictionary.cpp
@@ -30,9 +30,9 @@
 
 #include "dictionary.h"
 
-#include "core/ordered_hash_map.h"
-#include "core/safe_refcount.h"
-#include "core/variant.h"
+#include "core/templates/ordered_hash_map.h"
+#include "core/templates/safe_refcount.h"
+#include "core/variant/variant.h"
 
 struct DictionaryPrivate {
 	SafeRefCount refcount;
diff --git a/core/dictionary.h b/core/variant/dictionary.h
index a01d96ba01..bbe94122ad 100644
--- a/core/dictionary.h
+++ b/core/variant/dictionary.h
@@ -31,9 +31,9 @@
 #ifndef DICTIONARY_H
 #define DICTIONARY_H
 
-#include "core/array.h"
-#include "core/list.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
+#include "core/templates/list.h"
+#include "core/variant/array.h"
 
 class Variant;
 
diff --git a/core/method_ptrcall.h b/core/variant/method_ptrcall.h
index 022ed2a5d6..936de145f8 100644
--- a/core/method_ptrcall.h
+++ b/core/variant/method_ptrcall.h
@@ -32,9 +32,9 @@
 #define METHOD_PTRCALL_H
 
 #include "core/math/transform_2d.h"
-#include "core/object_id.h"
+#include "core/object/object_id.h"
 #include "core/typedefs.h"
-#include "core/variant.h"
+#include "core/variant/variant.h"
 
 #ifdef PTRCALL_ENABLED
 
diff --git a/core/type_info.h b/core/variant/type_info.h
index b9ae88d97c..ce7c2bfe14 100644
--- a/core/type_info.h
+++ b/core/variant/type_info.h
@@ -153,7 +153,7 @@ MAKE_TYPE_INFO(Transform, Variant::TRANSFORM)
 MAKE_TYPE_INFO(Color, Variant::COLOR)
 MAKE_TYPE_INFO(StringName, Variant::STRING_NAME)
 MAKE_TYPE_INFO(NodePath, Variant::NODE_PATH)
-MAKE_TYPE_INFO(RID, Variant::_RID)
+MAKE_TYPE_INFO(RID, Variant::RID)
 MAKE_TYPE_INFO(Callable, Variant::CALLABLE)
 MAKE_TYPE_INFO(Signal, Variant::SIGNAL)
 MAKE_TYPE_INFO(Dictionary, Variant::DICTIONARY)
diff --git a/core/typed_array.h b/core/variant/typed_array.h
index 86f26d7550..ff42cb687e 100644
--- a/core/typed_array.h
+++ b/core/variant/typed_array.h
@@ -31,9 +31,9 @@
 #ifndef TYPED_ARRAY_H
 #define TYPED_ARRAY_H
 
-#include "core/array.h"
-#include "core/method_ptrcall.h"
-#include "core/variant.h"
+#include "core/variant/array.h"
+#include "core/variant/method_ptrcall.h"
+#include "core/variant/variant.h"
 
 template <class T>
 class TypedArray : public Array {
@@ -105,7 +105,7 @@ MAKE_TYPED_ARRAY(Transform, Variant::TRANSFORM)
 MAKE_TYPED_ARRAY(Color, Variant::COLOR)
 MAKE_TYPED_ARRAY(StringName, Variant::STRING_NAME)
 MAKE_TYPED_ARRAY(NodePath, Variant::NODE_PATH)
-MAKE_TYPED_ARRAY(RID, Variant::_RID)
+MAKE_TYPED_ARRAY(RID, Variant::RID)
 MAKE_TYPED_ARRAY(Callable, Variant::CALLABLE)
 MAKE_TYPED_ARRAY(Signal, Variant::SIGNAL)
 MAKE_TYPED_ARRAY(Dictionary, Variant::DICTIONARY)
@@ -207,7 +207,7 @@ MAKE_TYPED_ARRAY_INFO(Transform, Variant::TRANSFORM)
 MAKE_TYPED_ARRAY_INFO(Color, Variant::COLOR)
 MAKE_TYPED_ARRAY_INFO(StringName, Variant::STRING_NAME)
 MAKE_TYPED_ARRAY_INFO(NodePath, Variant::NODE_PATH)
-MAKE_TYPED_ARRAY_INFO(RID, Variant::_RID)
+MAKE_TYPED_ARRAY_INFO(RID, Variant::RID)
 MAKE_TYPED_ARRAY_INFO(Callable, Variant::CALLABLE)
 MAKE_TYPED_ARRAY_INFO(Signal, Variant::SIGNAL)
 MAKE_TYPED_ARRAY_INFO(Dictionary, Variant::DICTIONARY)
diff --git a/core/variant.cpp b/core/variant/variant.cpp
index 181ced0f32..3114a358f7 100644
--- a/core/variant.cpp
+++ b/core/variant/variant.cpp
@@ -33,10 +33,10 @@
 #include "core/core_string_names.h"
 #include "core/debugger/engine_debugger.h"
 #include "core/io/marshalls.h"
+#include "core/io/resource.h"
 #include "core/math/math_funcs.h"
-#include "core/print_string.h"
-#include "core/resource.h"
-#include "core/variant_parser.h"
+#include "core/string/print_string.h"
+#include "core/variant/variant_parser.h"
 #include "scene/gui/control.h"
 #include "scene/main/node.h"
 
@@ -109,7 +109,7 @@ String Variant::get_type_name(Variant::Type p_type) {
 			return "Color";
 
 		} break;
-		case _RID: {
+		case RID: {
 			return "RID";
 		} break;
 		case OBJECT: {
@@ -342,7 +342,7 @@ bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) {
 
 		} break;
 
-		case _RID: {
+		case RID: {
 			static const Type valid[] = {
 				OBJECT,
 				NIL
@@ -649,7 +649,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type
 
 		} break;
 
-		case _RID: {
+		case RID: {
 			static const Type valid[] = {
 				OBJECT,
 				NIL
@@ -891,8 +891,8 @@ bool Variant::is_zero() const {
 			return *reinterpret_cast<const Color *>(_data._mem) == Color();
 
 		} break;
-		case _RID: {
-			return *reinterpret_cast<const RID *>(_data._mem) == RID();
+		case RID: {
+			return *reinterpret_cast<const ::RID *>(_data._mem) == ::RID();
 		} break;
 		case OBJECT: {
 			return _get_obj().obj == nullptr;
@@ -1109,8 +1109,8 @@ void Variant::reference(const Variant &p_variant) {
 			memnew_placement(_data._mem, Color(*reinterpret_cast<const Color *>(p_variant._data._mem)));
 
 		} break;
-		case _RID: {
-			memnew_placement(_data._mem, RID(*reinterpret_cast<const RID *>(p_variant._data._mem)));
+		case RID: {
+			memnew_placement(_data._mem, ::RID(*reinterpret_cast<const ::RID *>(p_variant._data._mem)));
 		} break;
 		case OBJECT: {
 			memnew_placement(_data._mem, ObjData);
@@ -1266,7 +1266,7 @@ void Variant::zero() {
 	}
 }
 
-void Variant::clear() {
+void Variant::_clear_internal() {
 	switch (type) {
 		case STRING: {
 			reinterpret_cast<String *>(_data._mem)->~String();
@@ -1311,9 +1311,11 @@ void Variant::clear() {
 			_get_obj().obj = nullptr;
 			_get_obj().id = ObjectID();
 		} break;
-		case _RID: {
+		case RID: {
 			// not much need probably
-			reinterpret_cast<RID *>(_data._mem)->~RID();
+			// Can't seem to use destructor + scoping operator, so hack.
+			typedef ::RID RID_Class;
+			reinterpret_cast<RID_Class *>(_data._mem)->~RID_Class();
 		} break;
 		case CALLABLE: {
 			reinterpret_cast<Callable *>(_data._mem)->~Callable();
@@ -1358,8 +1360,6 @@ void Variant::clear() {
 		default: {
 		} /* not needed */
 	}
-
-	type = NIL;
 }
 
 Variant::operator signed int() const {
@@ -1849,8 +1849,8 @@ String Variant::stringify(List<const void *> &stack) const {
 			const Signal &s = *reinterpret_cast<const Signal *>(_data._mem);
 			return s;
 		} break;
-		case _RID: {
-			const RID &s = *reinterpret_cast<const RID *>(_data._mem);
+		case RID: {
+			const ::RID &s = *reinterpret_cast<const ::RID *>(_data._mem);
 			return "RID(" + itos(s.get_id()) + ")";
 		} break;
 		default: {
@@ -2041,25 +2041,25 @@ Variant::operator NodePath() const {
 	}
 }
 
-Variant::operator RID() const {
-	if (type == _RID) {
-		return *reinterpret_cast<const RID *>(_data._mem);
+Variant::operator ::RID() const {
+	if (type == RID) {
+		return *reinterpret_cast<const ::RID *>(_data._mem);
 	} else if (type == OBJECT && _get_obj().obj == nullptr) {
-		return RID();
+		return ::RID();
 	} else if (type == OBJECT && _get_obj().obj) {
 #ifdef DEBUG_ENABLED
 		if (EngineDebugger::is_active()) {
-			ERR_FAIL_COND_V_MSG(ObjectDB::get_instance(_get_obj().id) == nullptr, RID(), "Invalid pointer (object was freed).");
+			ERR_FAIL_COND_V_MSG(ObjectDB::get_instance(_get_obj().id) == nullptr, ::RID(), "Invalid pointer (object was freed).");
 		}
 #endif
 		Callable::CallError ce;
 		Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->get_rid, nullptr, 0, ce);
-		if (ce.error == Callable::CallError::CALL_OK && ret.get_type() == Variant::_RID) {
+		if (ce.error == Callable::CallError::CALL_OK && ret.get_type() == Variant::RID) {
 			return ret;
 		}
-		return RID();
+		return ::RID();
 	} else {
-		return RID();
+		return ::RID();
 	}
 }
 
@@ -2263,9 +2263,9 @@ Variant::operator Vector<Color>() const {
 
 /* helpers */
 
-Variant::operator Vector<RID>() const {
+Variant::operator Vector<::RID>() const {
 	Array va = operator Array();
-	Vector<RID> rids;
+	Vector<::RID> rids;
 	rids.resize(va.size());
 	for (int i = 0; i < rids.size(); i++) {
 		rids.write[i] = va[i];
@@ -2520,9 +2520,9 @@ Variant::Variant(const NodePath &p_node_path) {
 	memnew_placement(_data._mem, NodePath(p_node_path));
 }
 
-Variant::Variant(const RID &p_rid) {
-	type = _RID;
-	memnew_placement(_data._mem, RID(p_rid));
+Variant::Variant(const ::RID &p_rid) {
+	type = RID;
+	memnew_placement(_data._mem, ::RID(p_rid));
 }
 
 Variant::Variant(const Object *p_object) {
@@ -2580,7 +2580,7 @@ Variant::Variant(const Vector<Plane> &p_array) {
 	}
 }
 
-Variant::Variant(const Vector<RID> &p_array) {
+Variant::Variant(const Vector<::RID> &p_array) {
 	type = ARRAY;
 
 	Array *rid_array = memnew_placement(_data._mem, Array);
@@ -2753,8 +2753,8 @@ void Variant::operator=(const Variant &p_variant) {
 		case COLOR: {
 			*reinterpret_cast<Color *>(_data._mem) = *reinterpret_cast<const Color *>(p_variant._data._mem);
 		} break;
-		case _RID: {
-			*reinterpret_cast<RID *>(_data._mem) = *reinterpret_cast<const RID *>(p_variant._data._mem);
+		case RID: {
+			*reinterpret_cast<::RID *>(_data._mem) = *reinterpret_cast<const ::RID *>(p_variant._data._mem);
 		} break;
 		case OBJECT: {
 			if (_get_obj().id.is_reference()) {
@@ -2955,8 +2955,8 @@ uint32_t Variant::hash() const {
 			return hash_djb2_one_float(reinterpret_cast<const Color *>(_data._mem)->a, hash);
 
 		} break;
-		case _RID: {
-			return hash_djb2_one_64(reinterpret_cast<const RID *>(_data._mem)->get_id());
+		case RID: {
+			return hash_djb2_one_64(reinterpret_cast<const ::RID *>(_data._mem)->get_id());
 		} break;
 		case OBJECT: {
 			return hash_djb2_one_64(make_uint64_t(_get_obj().obj));
@@ -3519,3 +3519,16 @@ String vformat(const String &p_text, const Variant &p1, const Variant &p2, const
 
 	return fmt;
 }
+
+void Variant::register_types() {
+	_register_variant_operators();
+	_register_variant_methods();
+	_register_variant_setters_getters();
+	_register_variant_constructors();
+}
+void Variant::unregister_types() {
+	_unregister_variant_operators();
+	_unregister_variant_methods();
+	_unregister_variant_setters_getters();
+	_unregister_variant_constructors();
+}
diff --git a/core/variant.h b/core/variant/variant.h
index 84e5427b21..ee08373b27 100644
--- a/core/variant.h
+++ b/core/variant/variant.h
@@ -31,13 +31,10 @@
 #ifndef VARIANT_H
 #define VARIANT_H
 
-#include "core/array.h"
-#include "core/callable.h"
-#include "core/color.h"
-#include "core/dictionary.h"
 #include "core/io/ip_address.h"
 #include "core/math/aabb.h"
 #include "core/math/basis.h"
+#include "core/math/color.h"
 #include "core/math/face3.h"
 #include "core/math/plane.h"
 #include "core/math/quat.h"
@@ -45,10 +42,13 @@
 #include "core/math/transform_2d.h"
 #include "core/math/vector3.h"
 #include "core/math/vector3i.h"
-#include "core/node_path.h"
-#include "core/object_id.h"
-#include "core/rid.h"
-#include "core/ustring.h"
+#include "core/object/object_id.h"
+#include "core/string/node_path.h"
+#include "core/string/ustring.h"
+#include "core/templates/rid.h"
+#include "core/variant/array.h"
+#include "core/variant/callable.h"
+#include "core/variant/dictionary.h"
 
 class Object;
 class Node; // helper
@@ -97,7 +97,7 @@ public:
 		COLOR,
 		STRING_NAME,
 		NODE_PATH,
-		_RID,
+		RID,
 		OBJECT,
 		CALLABLE,
 		SIGNAL,
@@ -207,7 +207,66 @@ private:
 	} _data alignas(8);
 
 	void reference(const Variant &p_variant);
-	void clear();
+
+	void _clear_internal();
+
+	_FORCE_INLINE_ void clear() {
+		static const bool needs_deinit[Variant::VARIANT_MAX] = {
+			false, //NIL,
+			false, //BOOL,
+			false, //INT,
+			false, //FLOAT,
+			true, //STRING,
+			false, //VECTOR2,
+			false, //VECTOR2I,
+			false, //RECT2,
+			false, //RECT2I,
+			false, //VECTOR3,
+			false, //VECTOR3I,
+			true, //TRANSFORM2D,
+			false, //PLANE,
+			false, //QUAT,
+			true, //AABB,
+			true, //BASIS,
+			true, //TRANSFORM,
+
+			// misc types
+			false, //COLOR,
+			true, //STRING_NAME,
+			true, //NODE_PATH,
+			false, //RID,
+			true, //OBJECT,
+			true, //CALLABLE,
+			true, //SIGNAL,
+			true, //DICTIONARY,
+			true, //ARRAY,
+
+			// typed arrays
+			true, //PACKED_BYTE_ARRAY,
+			true, //PACKED_INT32_ARRAY,
+			true, //PACKED_INT64_ARRAY,
+			true, //PACKED_FLOAT32_ARRAY,
+			true, //PACKED_FLOAT64_ARRAY,
+			true, //PACKED_STRING_ARRAY,
+			true, //PACKED_VECTOR2_ARRAY,
+			true, //PACKED_VECTOR3_ARRAY,
+			true, //PACKED_COLOR_ARRAY,
+		};
+
+		if (unlikely(needs_deinit[type])) { //make it fast for types that dont need deinit
+			_clear_internal();
+		}
+		type = NIL;
+	}
+
+	static void _register_variant_operators();
+	static void _unregister_variant_operators();
+	static void _register_variant_methods();
+	static void _unregister_variant_methods();
+	static void _register_variant_setters_getters();
+	static void _unregister_variant_setters_getters();
+	static void _register_variant_constructors();
+	static void _unregister_variant_constructors();
 
 public:
 	_FORCE_INLINE_ Type get_type() const {
@@ -266,7 +325,7 @@ public:
 
 	operator Color() const;
 	operator NodePath() const;
-	operator RID() const;
+	operator ::RID() const;
 
 	operator Object *() const;
 	operator Node *() const;
@@ -291,7 +350,7 @@ public:
 
 	operator Vector<Variant>() const;
 	operator Vector<StringName>() const;
-	operator Vector<RID>() const;
+	operator Vector<::RID>() const;
 	operator Vector<Vector2>() const;
 
 	// some core type enums to convert to
@@ -338,7 +397,7 @@ public:
 	Variant(const Transform &p_transform);
 	Variant(const Color &p_color);
 	Variant(const NodePath &p_node_path);
-	Variant(const RID &p_rid);
+	Variant(const ::RID &p_rid);
 	Variant(const Object *p_object);
 	Variant(const Callable &p_callable);
 	Variant(const Signal &p_signal);
@@ -358,7 +417,7 @@ public:
 
 	Variant(const Vector<Variant> &p_array);
 	Variant(const Vector<StringName> &p_array);
-	Variant(const Vector<RID> &p_array); // helper
+	Variant(const Vector<::RID> &p_array); // helper
 	Variant(const Vector<Vector2> &p_array); // helper
 
 	Variant(const IP_Address &p_address);
@@ -381,7 +440,6 @@ public:
 		OP_NEGATE,
 		OP_POSITIVE,
 		OP_MODULE,
-		OP_STRING_CONCAT,
 		//bitwise
 		OP_SHIFT_LEFT,
 		OP_SHIFT_RIGHT,
@@ -409,6 +467,14 @@ public:
 		return res;
 	}
 
+	static Variant::Type get_operator_return_type(Operator p_operator, Type p_type_a, Type p_type_b);
+	typedef void (*ValidatedOperatorEvaluator)(const Variant *left, const Variant *right, Variant *r_ret);
+	static ValidatedOperatorEvaluator get_validated_operator_evaluator(Operator p_operator, Type p_type_a, Type p_type_b);
+#ifdef PTRCALL_ENABLED
+	typedef void (*PTROperatorEvaluator)(const void *left, const void *right, void *r_ret);
+	static PTROperatorEvaluator get_ptr_operator_evaluator(Operator p_operator, Type p_type_a, Type p_type_b);
+#endif
+
 	void zero();
 	Variant duplicate(bool deep = false) const;
 	static void blend(const Variant &a, const Variant &b, float c, Variant &r_dst);
@@ -460,7 +526,19 @@ public:
 	static String get_call_error_text(Object *p_base, const StringName &p_method, const Variant **p_argptrs, int p_argcount, const Callable::CallError &ce);
 	static String get_callable_error_text(const Callable &p_callable, const Variant **p_argptrs, int p_argcount, const Callable::CallError &ce);
 
-	static Variant construct(const Variant::Type, const Variant **p_args, int p_argcount, Callable::CallError &r_error, bool p_strict = true);
+	// constructor
+	typedef void (*ValidatedConstructor)(Variant &r_base, const Variant **p_args);
+	typedef void (*PTRConstructor)(void *base, const void **p_args);
+
+	static int get_constructor_count(Variant::Type p_type);
+	static ValidatedConstructor get_validated_constructor(Variant::Type p_type, int p_constructor);
+	static PTRConstructor get_ptr_constructor(Variant::Type p_type, int p_constructor);
+	static int get_constructor_argument_count(Variant::Type p_type, int p_constructor);
+	static Variant::Type get_constructor_argument_type(Variant::Type p_type, int p_constructor, int p_argument);
+	static String get_constructor_argument_name(Variant::Type p_type, int p_constructor, int p_argument);
+	static void construct(Variant::Type, Variant &base, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
+
+	static void get_constructor_list(Type p_type, List<MethodInfo> *r_list); //convenience
 
 	void get_method_list(List<MethodInfo> *p_list) const;
 	bool has_method(const StringName &p_method) const;
@@ -470,8 +548,66 @@ public:
 	static Vector<StringName> get_method_argument_names(Variant::Type p_type, const StringName &p_method);
 	static bool is_method_const(Variant::Type p_type, const StringName &p_method);
 
-	void set_named(const StringName &p_index, const Variant &p_value, bool *r_valid = nullptr);
-	Variant get_named(const StringName &p_index, bool *r_valid = nullptr) const;
+	void set_named(const StringName &p_member, const Variant &p_value, bool &r_valid);
+	Variant get_named(const StringName &p_member, bool &r_valid) const;
+
+	typedef void (*ValidatedSetter)(Variant *base, const Variant *value);
+	typedef void (*ValidatedGetter)(const Variant *base, Variant *value);
+
+	static bool has_member(Variant::Type p_type, const StringName &p_member);
+	static Variant::Type get_member_type(Variant::Type p_type, const StringName &p_member);
+	static void get_member_list(Type p_type, List<StringName> *r_members);
+
+	static ValidatedSetter get_member_validated_setter(Variant::Type p_type, const StringName &p_member);
+	static ValidatedGetter get_member_validated_getter(Variant::Type p_type, const StringName &p_member);
+
+	typedef void (*PTRSetter)(void *base, const void *value);
+	typedef void (*PTRGetter)(const void *base, void *value);
+
+	static PTRSetter get_member_ptr_setter(Variant::Type p_type, const StringName &p_member);
+	static PTRGetter get_member_ptr_getter(Variant::Type p_type, const StringName &p_member);
+
+	static bool has_indexing(Variant::Type p_type);
+	static Variant::Type get_indexed_element_type(Variant::Type p_type);
+
+	typedef void (*ValidatedIndexedSetter)(Variant *base, int64_t index, const Variant *value, bool &oob);
+	typedef void (*ValidatedIndexedGetter)(const Variant *base, int64_t index, Variant *value, bool &oob);
+
+	static ValidatedIndexedSetter get_member_validated_indexed_setter(Variant::Type p_type);
+	static ValidatedIndexedGetter get_member_validated_indexed_getter(Variant::Type p_type);
+
+	typedef void (*PTRIndexedSetter)(void *base, int64_t index, const void *value);
+	typedef void (*PTRIndexedGetter)(const void *base, int64_t index, void *value);
+
+	static PTRIndexedSetter get_member_ptr_indexed_setter(Variant::Type p_type);
+	static PTRIndexedGetter get_member_ptr_indexed_getter(Variant::Type p_type);
+
+	void set_indexed(int64_t p_index, const Variant &p_value, bool &r_valid, bool &r_oob);
+	Variant get_indexed(int64_t p_index, bool &r_valid, bool &r_oob) const;
+
+	uint64_t get_indexed_size() const;
+
+	static bool is_keyed(Variant::Type p_type);
+
+	typedef void (*ValidatedKeyedSetter)(Variant *base, const Variant *key, const Variant *value, bool &valid);
+	typedef void (*ValidatedKeyedGetter)(const Variant *base, const Variant *key, Variant *value, bool &valid);
+	typedef bool (*ValidatedKeyedChecker)(const Variant *base, const Variant *key, bool &valid);
+
+	static ValidatedKeyedSetter get_member_validated_keyed_setter(Variant::Type p_type);
+	static ValidatedKeyedGetter get_member_validated_keyed_getter(Variant::Type p_type);
+	static ValidatedKeyedChecker get_member_validated_keyed_checker(Variant::Type p_type);
+
+	typedef void (*PTRKeyedSetter)(void *base, const void *key, const void *value);
+	typedef void (*PTRKeyedGetter)(const void *base, const void *key, void *value);
+	typedef bool (*PTRKeyedChecker)(const void *base, const void *key);
+
+	static PTRKeyedSetter get_member_ptr_keyed_setter(Variant::Type p_type);
+	static PTRKeyedGetter get_member_ptr_keyed_getter(Variant::Type p_type);
+	static PTRKeyedChecker get_member_ptr_keyed_checker(Variant::Type p_type);
+
+	void set_keyed(const Variant &p_key, const Variant &p_value, bool &r_valid);
+	Variant get_keyed(const Variant &p_key, bool &r_valid) const;
+	bool has_key(const Variant &p_key, bool &r_valid) const;
 
 	void set(const Variant &p_index, const Variant &p_value, bool *r_valid = nullptr);
 	Variant get(const Variant &p_index, bool *r_valid = nullptr) const;
@@ -495,7 +631,6 @@ public:
 	String stringify(List<const void *> &stack) const;
 
 	void static_assign(const Variant &p_variant);
-	static void get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_list);
 	static void get_constants_for_type(Variant::Type p_type, List<StringName> *p_constants);
 	static bool has_constant(Variant::Type p_type, const StringName &p_value);
 	static Variant get_constant_value(Variant::Type p_type, const StringName &p_value, bool *r_valid = nullptr);
@@ -508,12 +643,13 @@ public:
 
 	void operator=(const Variant &p_variant); // only this is enough for all the other types
 
+	static void register_types();
+	static void unregister_types();
+
 	Variant(const Variant &p_variant);
 	_FORCE_INLINE_ Variant() {}
 	_FORCE_INLINE_ ~Variant() {
-		if (type != Variant::NIL) {
-			clear();
-		}
+		clear();
 	}
 };
 
diff --git a/core/variant_call.cpp b/core/variant/variant_call.cpp
index d2b626a942..929a8e2cc8 100644
--- a/core/variant_call.cpp
+++ b/core/variant/variant_call.cpp
@@ -30,14 +30,13 @@
 
 #include "variant.h"
 
-#include "core/class_db.h"
-#include "core/color_names.inc"
 #include "core/core_string_names.h"
 #include "core/crypto/crypto_core.h"
 #include "core/debugger/engine_debugger.h"
 #include "core/io/compression.h"
-#include "core/oa_hash_map.h"
+#include "core/object/class_db.h"
 #include "core/os/os.h"
+#include "core/templates/oa_hash_map.h"
 
 _FORCE_INLINE_ void sarray_add_str(Vector<String> &arr) {
 }
@@ -62,6 +61,27 @@ _FORCE_INLINE_ Vector<String> sarray(P... p_args) {
 typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
 typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
 
+template <class T>
+struct TypeAdjust {
+	_FORCE_INLINE_ static void adjust(Variant *r_ret) {
+		VariantTypeChanger<typename GetSimpleTypeT<T>::type_t>::change(r_ret);
+	}
+};
+
+template <> //do nothing for variant
+struct TypeAdjust<Variant> {
+	_FORCE_INLINE_ static void adjust(Variant *r_ret) {
+	}
+};
+
+template <> //do nothing for variant
+struct TypeAdjust<Object *> {
+	_FORCE_INLINE_ static void adjust(Variant *r_ret) {
+		VariantInternal::clear(r_ret);
+		*r_ret = (Object *)nullptr;
+	}
+};
+
 struct _VariantCall {
 	template <class T, class... P>
 	class InternalMethod : public Variant::InternalMethod {
@@ -167,6 +187,7 @@ struct _VariantCall {
 		}
 
 		virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
+			TypeAdjust<R>::adjust(r_ret);
 			call_with_validated_variant_args_ret(base, method, p_args, r_ret);
 		}
 #ifdef PTRCALL_ENABLED
@@ -232,6 +253,7 @@ struct _VariantCall {
 		}
 
 		virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
+			TypeAdjust<R>::adjust(r_ret);
 			call_with_validated_variant_args_retc(base, method, p_args, r_ret);
 		}
 #ifdef PTRCALL_ENABLED
@@ -334,6 +356,7 @@ struct _VariantCall {
 		}
 
 		virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
+			TypeAdjust<R>::adjust(r_ret);
 			call_with_validated_variant_args_static_retc(base, method, p_args, r_ret);
 		}
 #ifdef PTRCALL_ENABLED
@@ -671,190 +694,6 @@ struct _VariantCall {
 		signal->emit(p_args, p_argcount);
 	}
 
-	struct ConstructData {
-		int arg_count;
-		Vector<Variant::Type> arg_types;
-		Vector<String> arg_names;
-		VariantConstructFunc func;
-	};
-
-	struct ConstructFunc {
-		List<ConstructData> constructors;
-	};
-
-	static ConstructFunc *construct_funcs;
-
-	static void Vector2_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Vector2(*p_args[0], *p_args[1]);
-	}
-
-	static void Vector2i_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Vector2i(*p_args[0], *p_args[1]);
-	}
-
-	static void Rect2_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Rect2(*p_args[0], *p_args[1]);
-	}
-
-	static void Rect2_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Rect2(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
-	}
-
-	static void Rect2i_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Rect2i(*p_args[0], *p_args[1]);
-	}
-
-	static void Rect2i_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Rect2i(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
-	}
-
-	static void Transform2D_init2(Variant &r_ret, const Variant **p_args) {
-		Transform2D m(*p_args[0], *p_args[1]);
-		r_ret = m;
-	}
-
-	static void Transform2D_init3(Variant &r_ret, const Variant **p_args) {
-		Transform2D m;
-		m[0] = *p_args[0];
-		m[1] = *p_args[1];
-		m[2] = *p_args[2];
-		r_ret = m;
-	}
-
-	static void Vector3_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Vector3(*p_args[0], *p_args[1], *p_args[2]);
-	}
-
-	static void Vector3i_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Vector3i(*p_args[0], *p_args[1], *p_args[2]);
-	}
-
-	static void Plane_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Plane(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
-	}
-
-	static void Plane_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Plane(*p_args[0], *p_args[1], *p_args[2]);
-	}
-
-	static void Plane_init3(Variant &r_ret, const Variant **p_args) {
-		r_ret = Plane(p_args[0]->operator Vector3(), p_args[1]->operator real_t());
-	}
-	static void Plane_init4(Variant &r_ret, const Variant **p_args) {
-		r_ret = Plane(p_args[0]->operator Vector3(), p_args[1]->operator Vector3());
-	}
-
-	static void Quat_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Quat(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
-	}
-
-	static void Quat_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Quat(((Vector3)(*p_args[0])), ((real_t)(*p_args[1])));
-	}
-
-	static void Quat_init3(Variant &r_ret, const Variant **p_args) {
-		r_ret = Quat(((Vector3)(*p_args[0])));
-	}
-
-	static void Color_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = Color(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
-	}
-
-	static void Color_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Color(*p_args[0], *p_args[1], *p_args[2]);
-	}
-
-	static void Color_init3(Variant &r_ret, const Variant **p_args) {
-		r_ret = Color::html(*p_args[0]);
-	}
-
-	static void Color_init4(Variant &r_ret, const Variant **p_args) {
-		r_ret = Color::hex(*p_args[0]);
-	}
-
-	static void Color_init5(Variant &r_ret, const Variant **p_args) {
-		r_ret = Color(((Color)(*p_args[0])), *p_args[1]);
-	}
-
-	static void AABB_init1(Variant &r_ret, const Variant **p_args) {
-		r_ret = ::AABB(*p_args[0], *p_args[1]);
-	}
-
-	static void Basis_init1(Variant &r_ret, const Variant **p_args) {
-		Basis m;
-		m.set_axis(0, *p_args[0]);
-		m.set_axis(1, *p_args[1]);
-		m.set_axis(2, *p_args[2]);
-		r_ret = m;
-	}
-
-	static void Basis_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Basis(p_args[0]->operator Vector3(), p_args[1]->operator real_t());
-	}
-
-	static void Transform_init1(Variant &r_ret, const Variant **p_args) {
-		Transform t;
-		t.basis.set_axis(0, *p_args[0]);
-		t.basis.set_axis(1, *p_args[1]);
-		t.basis.set_axis(2, *p_args[2]);
-		t.origin = *p_args[3];
-		r_ret = t;
-	}
-
-	static void Transform_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Transform(p_args[0]->operator Basis(), p_args[1]->operator Vector3());
-	}
-
-	static void Callable_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Callable(p_args[0]->operator ObjectID(), p_args[1]->operator String());
-	}
-
-	static void Signal_init2(Variant &r_ret, const Variant **p_args) {
-		r_ret = Signal(p_args[0]->operator ObjectID(), p_args[1]->operator String());
-	}
-
-	static void add_constructor(VariantConstructFunc p_func, const Variant::Type p_type,
-			const String &p_name1 = "", const Variant::Type p_type1 = Variant::NIL,
-			const String &p_name2 = "", const Variant::Type p_type2 = Variant::NIL,
-			const String &p_name3 = "", const Variant::Type p_type3 = Variant::NIL,
-			const String &p_name4 = "", const Variant::Type p_type4 = Variant::NIL) {
-		ConstructData cd;
-		cd.func = p_func;
-		cd.arg_count = 0;
-
-		if (p_name1 == "") {
-			goto end;
-		}
-		cd.arg_count++;
-		cd.arg_names.push_back(p_name1);
-		cd.arg_types.push_back(p_type1);
-
-		if (p_name2 == "") {
-			goto end;
-		}
-		cd.arg_count++;
-		cd.arg_names.push_back(p_name2);
-		cd.arg_types.push_back(p_type2);
-
-		if (p_name3 == "") {
-			goto end;
-		}
-		cd.arg_count++;
-		cd.arg_names.push_back(p_name3);
-		cd.arg_types.push_back(p_type3);
-
-		if (p_name4 == "") {
-			goto end;
-		}
-		cd.arg_count++;
-		cd.arg_names.push_back(p_name4);
-		cd.arg_types.push_back(p_type4);
-
-	end:
-
-		construct_funcs[p_type].constructors.push_back(cd);
-	}
-
 	struct ConstantData {
 		Map<StringName, int> value;
 #ifdef DEBUG_ENABLED
@@ -883,7 +722,6 @@ struct _VariantCall {
 	}
 };
 
-_VariantCall::ConstructFunc *_VariantCall::construct_funcs = nullptr;
 _VariantCall::ConstantData *_VariantCall::constant_data = nullptr;
 _VariantCall::MethodMap *_VariantCall::type_internal_methods = nullptr;
 List<StringName> *_VariantCall::type_internal_method_names = nullptr;
@@ -936,213 +774,6 @@ void Variant::call_ptr(const StringName &p_method, const Variant **p_args, int p
 
 #define VCALL(m_type, m_method) _VariantCall::_call_##m_type##_##m_method
 
-Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, int p_argcount, Callable::CallError &r_error, bool p_strict) {
-	r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
-	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, Variant());
-
-	r_error.error = Callable::CallError::CALL_OK;
-	if (p_argcount == 0) { //generic construct
-
-		switch (p_type) {
-			case NIL:
-				return Variant();
-
-			// atomic types
-			case BOOL:
-				return Variant(false);
-			case INT:
-				return 0;
-			case FLOAT:
-				return 0.0f;
-			case STRING:
-				return String();
-
-			// math types
-			case VECTOR2:
-				return Vector2();
-			case VECTOR2I:
-				return Vector2i();
-			case RECT2:
-				return Rect2();
-			case RECT2I:
-				return Rect2i();
-			case VECTOR3:
-				return Vector3();
-			case VECTOR3I:
-				return Vector3i();
-			case TRANSFORM2D:
-				return Transform2D();
-			case PLANE:
-				return Plane();
-			case QUAT:
-				return Quat();
-			case AABB:
-				return ::AABB();
-			case BASIS:
-				return Basis();
-			case TRANSFORM:
-				return Transform();
-
-			// misc types
-			case COLOR:
-				return Color();
-			case STRING_NAME:
-				return StringName();
-			case NODE_PATH:
-				return NodePath();
-			case _RID:
-				return RID();
-			case OBJECT:
-				return (Object *)nullptr;
-			case CALLABLE:
-				return Callable();
-			case SIGNAL:
-				return Signal();
-			case DICTIONARY:
-				return Dictionary();
-			case ARRAY:
-				return Array();
-			case PACKED_BYTE_ARRAY:
-				return PackedByteArray();
-			case PACKED_INT32_ARRAY:
-				return PackedInt32Array();
-			case PACKED_INT64_ARRAY:
-				return PackedInt64Array();
-			case PACKED_FLOAT32_ARRAY:
-				return PackedFloat32Array();
-			case PACKED_FLOAT64_ARRAY:
-				return PackedFloat64Array();
-			case PACKED_STRING_ARRAY:
-				return PackedStringArray();
-			case PACKED_VECTOR2_ARRAY:
-				return PackedVector2Array();
-			case PACKED_VECTOR3_ARRAY:
-				return PackedVector3Array();
-			case PACKED_COLOR_ARRAY:
-				return PackedColorArray();
-			default:
-				return Variant();
-		}
-
-	} else if (p_argcount == 1 && p_args[0]->type == p_type) {
-		return *p_args[0]; //copy construct
-	} else if (p_argcount == 1 && (!p_strict || Variant::can_convert(p_args[0]->type, p_type))) {
-		//near match construct
-
-		switch (p_type) {
-			case NIL: {
-				return Variant();
-			} break;
-			case BOOL: {
-				return Variant(bool(*p_args[0]));
-			}
-			case INT: {
-				return (int64_t(*p_args[0]));
-			}
-			case FLOAT: {
-				return double(*p_args[0]);
-			}
-			case STRING: {
-				return String(*p_args[0]);
-			}
-			case VECTOR2: {
-				return Vector2(*p_args[0]);
-			}
-			case VECTOR2I: {
-				return Vector2i(*p_args[0]);
-			}
-			case RECT2:
-				return (Rect2(*p_args[0]));
-			case RECT2I:
-				return (Rect2i(*p_args[0]));
-			case VECTOR3:
-				return (Vector3(*p_args[0]));
-			case VECTOR3I:
-				return (Vector3i(*p_args[0]));
-			case TRANSFORM2D:
-				return (Transform2D(p_args[0]->operator Transform2D()));
-			case PLANE:
-				return (Plane(*p_args[0]));
-			case QUAT:
-				return (p_args[0]->operator Quat());
-			case AABB:
-				return (::AABB(*p_args[0]));
-			case BASIS:
-				return (Basis(p_args[0]->operator Basis()));
-			case TRANSFORM:
-				return (Transform(p_args[0]->operator Transform()));
-
-			// misc types
-			case COLOR:
-				return p_args[0]->type == Variant::STRING ? Color::html(*p_args[0]) : Color::hex(*p_args[0]);
-			case STRING_NAME:
-				return (StringName(p_args[0]->operator StringName()));
-			case NODE_PATH:
-				return (NodePath(p_args[0]->operator NodePath()));
-			case _RID:
-				return (RID(*p_args[0]));
-			case OBJECT:
-				return ((Object *)(p_args[0]->operator Object *()));
-			case CALLABLE:
-				return ((Callable)(p_args[0]->operator Callable()));
-			case SIGNAL:
-				return ((Signal)(p_args[0]->operator Signal()));
-			case DICTIONARY:
-				return p_args[0]->operator Dictionary();
-			case ARRAY:
-				return p_args[0]->operator Array();
-
-			// arrays
-			case PACKED_BYTE_ARRAY:
-				return (PackedByteArray(*p_args[0]));
-			case PACKED_INT32_ARRAY:
-				return (PackedInt32Array(*p_args[0]));
-			case PACKED_INT64_ARRAY:
-				return (PackedInt64Array(*p_args[0]));
-			case PACKED_FLOAT32_ARRAY:
-				return (PackedFloat32Array(*p_args[0]));
-			case PACKED_FLOAT64_ARRAY:
-				return (PackedFloat64Array(*p_args[0]));
-			case PACKED_STRING_ARRAY:
-				return (PackedStringArray(*p_args[0]));
-			case PACKED_VECTOR2_ARRAY:
-				return (PackedVector2Array(*p_args[0]));
-			case PACKED_VECTOR3_ARRAY:
-				return (PackedVector3Array(*p_args[0]));
-			case PACKED_COLOR_ARRAY:
-				return (PackedColorArray(*p_args[0]));
-			default:
-				return Variant();
-		}
-	} else if (p_argcount >= 1) {
-		_VariantCall::ConstructFunc &c = _VariantCall::construct_funcs[p_type];
-
-		for (List<_VariantCall::ConstructData>::Element *E = c.constructors.front(); E; E = E->next()) {
-			const _VariantCall::ConstructData &cd = E->get();
-
-			if (cd.arg_count != p_argcount) {
-				continue;
-			}
-
-			//validate parameters
-			for (int i = 0; i < cd.arg_count; i++) {
-				if (!Variant::can_convert(p_args[i]->type, cd.arg_types[i])) {
-					r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT; //no such constructor
-					r_error.argument = i;
-					r_error.expected = cd.arg_types[i];
-					return Variant();
-				}
-			}
-
-			Variant v;
-			cd.func(v, p_args);
-			return v;
-		}
-	}
-	r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD; //no such constructor
-	return Variant();
-}
-
 bool Variant::has_method(const StringName &p_method) const {
 	if (type == OBJECT) {
 		Object *obj = get_validated_object();
@@ -1247,43 +878,6 @@ void Variant::get_method_list(List<MethodInfo> *p_list) const {
 	}
 }
 
-void Variant::get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_list) {
-	ERR_FAIL_INDEX(p_type, VARIANT_MAX);
-
-	//custom constructors
-	for (const List<_VariantCall::ConstructData>::Element *E = _VariantCall::construct_funcs[p_type].constructors.front(); E; E = E->next()) {
-		const _VariantCall::ConstructData &cd = E->get();
-		MethodInfo mi;
-		mi.name = Variant::get_type_name(p_type);
-		mi.return_val.type = p_type;
-		for (int i = 0; i < cd.arg_count; i++) {
-			PropertyInfo pi;
-			pi.name = cd.arg_names[i];
-			pi.type = cd.arg_types[i];
-			mi.arguments.push_back(pi);
-		}
-		p_list->push_back(mi);
-	}
-	//default constructors
-	for (int i = 0; i < VARIANT_MAX; i++) {
-		if (i == p_type) {
-			continue;
-		}
-		if (!Variant::can_convert(Variant::Type(i), p_type)) {
-			continue;
-		}
-
-		MethodInfo mi;
-		mi.name = Variant::get_type_name(p_type);
-		PropertyInfo pi;
-		pi.name = "from";
-		pi.type = Variant::Type(i);
-		mi.arguments.push_back(pi);
-		mi.return_val.type = p_type;
-		p_list->push_back(mi);
-	}
-}
-
 void Variant::get_constants_for_type(Variant::Type p_type, List<StringName> *p_constants) {
 	ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
 
@@ -1351,10 +945,9 @@ Variant::InternalMethod *Variant::get_internal_method(Type p_type, const StringN
 	return nullptr;
 }
 
-void register_variant_methods() {
+void Variant::_register_variant_methods() {
 	_VariantCall::type_internal_methods = memnew_arr(_VariantCall::MethodMap, Variant::VARIANT_MAX);
 	_VariantCall::type_internal_method_names = memnew_arr(List<StringName>, Variant::VARIANT_MAX);
-	_VariantCall::construct_funcs = memnew_arr(_VariantCall::ConstructFunc, Variant::VARIANT_MAX);
 	_VariantCall::constant_data = memnew_arr(_VariantCall::ConstantData, Variant::VARIANT_MAX);
 
 	/* String */
@@ -1626,7 +1219,7 @@ void register_variant_methods() {
 
 	/* RID */
 
-	bind_method(RID, get_id, sarray(), varray());
+	bind_method(::RID, get_id, sarray(), varray());
 
 	/* NodePath */
 
@@ -1947,52 +1540,11 @@ void register_variant_methods() {
 	bind_method(PackedColorArray, to_byte_array, sarray(), varray());
 	bind_method(PackedColorArray, sort, sarray(), varray());
 
-	/* Register constructors */
-
-	_VariantCall::add_constructor(_VariantCall::Vector2_init1, Variant::VECTOR2, "x", Variant::FLOAT, "y", Variant::FLOAT);
-	_VariantCall::add_constructor(_VariantCall::Vector2i_init1, Variant::VECTOR2I, "x", Variant::INT, "y", Variant::INT);
-
-	_VariantCall::add_constructor(_VariantCall::Rect2_init1, Variant::RECT2, "position", Variant::VECTOR2, "size", Variant::VECTOR2);
-	_VariantCall::add_constructor(_VariantCall::Rect2_init2, Variant::RECT2, "x", Variant::FLOAT, "y", Variant::FLOAT, "width", Variant::FLOAT, "height", Variant::FLOAT);
-
-	_VariantCall::add_constructor(_VariantCall::Rect2i_init1, Variant::RECT2I, "position", Variant::VECTOR2I, "size", Variant::VECTOR2I);
-	_VariantCall::add_constructor(_VariantCall::Rect2i_init2, Variant::RECT2I, "x", Variant::INT, "y", Variant::INT, "width", Variant::INT, "height", Variant::INT);
-
-	_VariantCall::add_constructor(_VariantCall::Transform2D_init2, Variant::TRANSFORM2D, "rotation", Variant::FLOAT, "position", Variant::VECTOR2);
-	_VariantCall::add_constructor(_VariantCall::Transform2D_init3, Variant::TRANSFORM2D, "x_axis", Variant::VECTOR2, "y_axis", Variant::VECTOR2, "origin", Variant::VECTOR2);
-
-	_VariantCall::add_constructor(_VariantCall::Vector3_init1, Variant::VECTOR3, "x", Variant::FLOAT, "y", Variant::FLOAT, "z", Variant::FLOAT);
-	_VariantCall::add_constructor(_VariantCall::Vector3i_init1, Variant::VECTOR3I, "x", Variant::INT, "y", Variant::INT, "z", Variant::INT);
-
-	_VariantCall::add_constructor(_VariantCall::Plane_init1, Variant::PLANE, "a", Variant::FLOAT, "b", Variant::FLOAT, "c", Variant::FLOAT, "d", Variant::FLOAT);
-	_VariantCall::add_constructor(_VariantCall::Plane_init2, Variant::PLANE, "v1", Variant::VECTOR3, "v2", Variant::VECTOR3, "v3", Variant::VECTOR3);
-	_VariantCall::add_constructor(_VariantCall::Plane_init3, Variant::PLANE, "normal", Variant::VECTOR3, "d", Variant::FLOAT);
-
-	_VariantCall::add_constructor(_VariantCall::Quat_init1, Variant::QUAT, "x", Variant::FLOAT, "y", Variant::FLOAT, "z", Variant::FLOAT, "w", Variant::FLOAT);
-	_VariantCall::add_constructor(_VariantCall::Quat_init2, Variant::QUAT, "axis", Variant::VECTOR3, "angle", Variant::FLOAT);
-	_VariantCall::add_constructor(_VariantCall::Quat_init3, Variant::QUAT, "euler", Variant::VECTOR3);
-
-	_VariantCall::add_constructor(_VariantCall::Color_init1, Variant::COLOR, "r", Variant::FLOAT, "g", Variant::FLOAT, "b", Variant::FLOAT, "a", Variant::FLOAT);
-	_VariantCall::add_constructor(_VariantCall::Color_init2, Variant::COLOR, "r", Variant::FLOAT, "g", Variant::FLOAT, "b", Variant::FLOAT);
-	// init3 and init4 are the constructors for HTML hex strings and integers respectively which don't need binding here, so we skip to init5.
-	_VariantCall::add_constructor(_VariantCall::Color_init5, Variant::COLOR, "c", Variant::COLOR, "a", Variant::FLOAT);
-
-	_VariantCall::add_constructor(_VariantCall::AABB_init1, Variant::AABB, "position", Variant::VECTOR3, "size", Variant::VECTOR3);
-
-	_VariantCall::add_constructor(_VariantCall::Basis_init1, Variant::BASIS, "x_axis", Variant::VECTOR3, "y_axis", Variant::VECTOR3, "z_axis", Variant::VECTOR3);
-	_VariantCall::add_constructor(_VariantCall::Basis_init2, Variant::BASIS, "axis", Variant::VECTOR3, "phi", Variant::FLOAT);
-
-	_VariantCall::add_constructor(_VariantCall::Transform_init1, Variant::TRANSFORM, "x_axis", Variant::VECTOR3, "y_axis", Variant::VECTOR3, "z_axis", Variant::VECTOR3, "origin", Variant::VECTOR3);
-	_VariantCall::add_constructor(_VariantCall::Transform_init2, Variant::TRANSFORM, "basis", Variant::BASIS, "origin", Variant::VECTOR3);
-
-	_VariantCall::add_constructor(_VariantCall::Callable_init2, Variant::CALLABLE, "object", Variant::OBJECT, "method_name", Variant::STRING_NAME);
-	_VariantCall::add_constructor(_VariantCall::Signal_init2, Variant::SIGNAL, "object", Variant::OBJECT, "signal_name", Variant::STRING_NAME);
-
 	/* Register constants */
 
-	_populate_named_colors();
-	for (Map<String, Color>::Element *color = _named_colors.front(); color; color = color->next()) {
-		_VariantCall::add_variant_constant(Variant::COLOR, color->key(), color->value());
+	int ncc = Color::get_named_color_count();
+	for (int i = 0; i < ncc; i++) {
+		_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);
@@ -2072,7 +1624,7 @@ void register_variant_methods() {
 	_VariantCall::add_variant_constant(Variant::QUAT, "IDENTITY", Quat(0, 0, 0, 1));
 }
 
-void unregister_variant_methods() {
+void Variant::_unregister_variant_methods() {
 	//clear methods
 	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
 		for (List<StringName>::Element *E = _VariantCall::type_internal_method_names[i].front(); E; E = E->next()) {
@@ -2085,6 +1637,5 @@ void unregister_variant_methods() {
 
 	memdelete_arr(_VariantCall::type_internal_methods);
 	memdelete_arr(_VariantCall::type_internal_method_names);
-	memdelete_arr(_VariantCall::construct_funcs);
 	memdelete_arr(_VariantCall::constant_data);
 }
diff --git a/core/variant/variant_construct.cpp b/core/variant/variant_construct.cpp
new file mode 100644
index 0000000000..b777323e82
--- /dev/null
+++ b/core/variant/variant_construct.cpp
@@ -0,0 +1,832 @@
+/*************************************************************************/
+/*  variant_construct.cpp                                                */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "variant.h"
+
+#include "core/core_string_names.h"
+#include "core/crypto/crypto_core.h"
+#include "core/debugger/engine_debugger.h"
+#include "core/io/compression.h"
+#include "core/object/class_db.h"
+#include "core/os/os.h"
+#include "core/templates/local_vector.h"
+#include "core/templates/oa_hash_map.h"
+
+_FORCE_INLINE_ void sarray_add_str(Vector<String> &arr) {
+}
+
+_FORCE_INLINE_ void sarray_add_str(Vector<String> &arr, const String &p_str) {
+	arr.push_back(p_str);
+}
+
+template <class... P>
+_FORCE_INLINE_ void sarray_add_str(Vector<String> &arr, const String &p_str, P... p_args) {
+	arr.push_back(p_str);
+	sarray_add_str(arr, p_args...);
+}
+
+template <class... P>
+_FORCE_INLINE_ Vector<String> sarray(P... p_args) {
+	Vector<String> arr;
+	sarray_add_str(arr, p_args...);
+	return arr;
+}
+
+template <class T, class... P>
+class VariantConstructor {
+	template <size_t... Is>
+	static _FORCE_INLINE_ void construct_helper(T &base, const Variant **p_args, Callable::CallError &r_error, IndexSequence<Is...>) {
+		r_error.error = Callable::CallError::CALL_OK;
+
+#ifdef DEBUG_METHODS_ENABLED
+		base = T(VariantCasterAndValidate<P>::cast(p_args, Is, r_error)...);
+#else
+		base = T(VariantCaster<P>::cast(*p_args[Is])...);
+#endif
+	}
+
+	template <size_t... Is>
+	static _FORCE_INLINE_ void validated_construct_helper(T &base, const Variant **p_args, IndexSequence<Is...>) {
+		base = T((*VariantGetInternalPtr<P>::get_ptr(p_args[Is]))...);
+	}
+
+	template <size_t... Is>
+	static _FORCE_INLINE_ void ptr_construct_helper(void *base, const void **p_args, IndexSequence<Is...>) {
+		PtrToArg<T>::encode(T(PtrToArg<P>::convert(p_args[Is])...), base);
+	}
+
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		r_error.error = Callable::CallError::CALL_OK;
+		VariantTypeChanger<T>::change(&r_ret);
+		construct_helper(*VariantGetInternalPtr<T>::get_ptr(&r_ret), p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantTypeChanger<T>::change(&r_ret);
+		validated_construct_helper(*VariantGetInternalPtr<T>::get_ptr(&r_ret), p_args, BuildIndexSequence<sizeof...(P)>{});
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		ptr_construct_helper(base, p_args, BuildIndexSequence<sizeof...(P)>{});
+	}
+
+	static int get_argument_count() {
+		return sizeof...(P);
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return call_get_argument_type<P...>(p_arg);
+	}
+
+	static Variant::Type get_base_type() {
+		return GetTypeInfo<T>::VARIANT_TYPE;
+	}
+};
+
+class VariantConstructorObject {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		VariantInternal::clear(&r_ret);
+		if (p_args[0]->get_type() == Variant::NIL) {
+			VariantInternal::object_assign_null(&r_ret);
+			r_error.error = Callable::CallError::CALL_OK;
+		} else if (p_args[0]->get_type() == Variant::OBJECT) {
+			VariantInternal::object_assign(&r_ret, p_args[0]);
+			r_error.error = Callable::CallError::CALL_OK;
+		} else {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 0;
+			r_error.expected = Variant::OBJECT;
+		}
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantInternal::clear(&r_ret);
+		VariantInternal::object_assign(&r_ret, p_args[0]);
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		PtrToArg<Object *>::encode(PtrToArg<Object *>::convert(p_args[0]), base);
+	}
+
+	static int get_argument_count() {
+		return 1;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return Variant::OBJECT;
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::OBJECT;
+	}
+};
+
+class VariantConstructorNilObject {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		if (p_args[0]->get_type() != Variant::NIL) {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 0;
+			r_error.expected = Variant::NIL;
+		}
+
+		VariantInternal::clear(&r_ret);
+		VariantInternal::object_assign_null(&r_ret);
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantInternal::clear(&r_ret);
+		VariantInternal::object_assign_null(&r_ret);
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		PtrToArg<Object *>::encode(nullptr, base);
+	}
+
+	static int get_argument_count() {
+		return 1;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return Variant::NIL;
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::OBJECT;
+	}
+};
+
+class VariantConstructorCallableArgs {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		ObjectID object_id;
+		StringName method;
+
+		if (p_args[0]->get_type() == Variant::NIL) {
+			// leave as is
+		} else if (p_args[0]->get_type() == Variant::OBJECT) {
+			object_id = VariantInternal::get_object_id(p_args[0]);
+		} else {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 0;
+			r_error.expected = Variant::OBJECT;
+			return;
+		}
+
+		if (p_args[1]->get_type() == Variant::STRING_NAME) {
+			method = *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]);
+		} else if (p_args[1]->get_type() == Variant::STRING) {
+			method = *VariantGetInternalPtr<String>::get_ptr(p_args[1]);
+		} else {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 1;
+			r_error.expected = Variant::STRING_NAME;
+			return;
+		}
+
+		VariantTypeChanger<Callable>::change(&r_ret);
+		*VariantGetInternalPtr<Callable>::get_ptr(&r_ret) = Callable(object_id, method);
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantTypeChanger<Callable>::change(&r_ret);
+		*VariantGetInternalPtr<Callable>::get_ptr(&r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		PtrToArg<Callable>::encode(Callable(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
+	}
+
+	static int get_argument_count() {
+		return 2;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		if (p_arg == 0) {
+			return Variant::OBJECT;
+		} else {
+			return Variant::STRING_NAME;
+		}
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::CALLABLE;
+	}
+};
+
+class VariantConstructorSignalArgs {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		ObjectID object_id;
+		StringName method;
+
+		if (p_args[0]->get_type() == Variant::NIL) {
+			// leave as is
+		} else if (p_args[0]->get_type() == Variant::OBJECT) {
+			object_id = VariantInternal::get_object_id(p_args[0]);
+		} else {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 0;
+			r_error.expected = Variant::OBJECT;
+			return;
+		}
+
+		if (p_args[1]->get_type() == Variant::STRING_NAME) {
+			method = *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]);
+		} else if (p_args[1]->get_type() == Variant::STRING) {
+			method = *VariantGetInternalPtr<String>::get_ptr(p_args[1]);
+		} else {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 1;
+			r_error.expected = Variant::STRING_NAME;
+			return;
+		}
+
+		VariantTypeChanger<Signal>::change(&r_ret);
+		*VariantGetInternalPtr<Signal>::get_ptr(&r_ret) = Signal(object_id, method);
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantTypeChanger<Signal>::change(&r_ret);
+		*VariantGetInternalPtr<Signal>::get_ptr(&r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		PtrToArg<Signal>::encode(Signal(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
+	}
+
+	static int get_argument_count() {
+		return 2;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		if (p_arg == 0) {
+			return Variant::OBJECT;
+		} else {
+			return Variant::STRING_NAME;
+		}
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::SIGNAL;
+	}
+};
+
+template <class T>
+class VariantConstructorToArray {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		if (p_args[0]->get_type() != GetTypeInfo<T>::VARIANT_TYPE) {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 0;
+			r_error.expected = GetTypeInfo<T>::VARIANT_TYPE;
+			return;
+		}
+
+		VariantTypeChanger<Array>::change(&r_ret);
+		Array &dst_arr = *VariantGetInternalPtr<Array>::get_ptr(&r_ret);
+		const T &src_arr = *VariantGetInternalPtr<T>::get_ptr(p_args[0]);
+
+		int size = src_arr.size();
+		dst_arr.resize(size);
+		for (int i = 0; i < size; i++) {
+			dst_arr[i] = src_arr[i];
+		}
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantTypeChanger<Array>::change(&r_ret);
+		Array &dst_arr = *VariantGetInternalPtr<Array>::get_ptr(&r_ret);
+		const T &src_arr = *VariantGetInternalPtr<T>::get_ptr(p_args[0]);
+
+		int size = src_arr.size();
+		dst_arr.resize(size);
+		for (int i = 0; i < size; i++) {
+			dst_arr[i] = src_arr[i];
+		}
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		Array dst_arr;
+		T src_arr = PtrToArg<T>::convert(p_args[0]);
+
+		int size = src_arr.size();
+		dst_arr.resize(size);
+		for (int i = 0; i < size; i++) {
+			dst_arr[i] = src_arr[i];
+		}
+
+		PtrToArg<Array>::encode(dst_arr, base);
+	}
+
+	static int get_argument_count() {
+		return 1;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return GetTypeInfo<T>::VARIANT_TYPE;
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::ARRAY;
+	}
+};
+
+template <class T>
+class VariantConstructorFromArray {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		if (p_args[0]->get_type() != Variant::ARRAY) {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 0;
+			r_error.expected = Variant::ARRAY;
+			return;
+		}
+
+		VariantTypeChanger<T>::change(&r_ret);
+		const Array &src_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
+		T &dst_arr = *VariantGetInternalPtr<T>::get_ptr(&r_ret);
+
+		int size = src_arr.size();
+		dst_arr.resize(size);
+		for (int i = 0; i < size; i++) {
+			dst_arr.write[i] = src_arr[i];
+		}
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantTypeChanger<T>::change(&r_ret);
+		const Array &src_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
+		T &dst_arr = *VariantGetInternalPtr<T>::get_ptr(&r_ret);
+
+		int size = src_arr.size();
+		dst_arr.resize(size);
+		for (int i = 0; i < size; i++) {
+			dst_arr.write[i] = src_arr[i];
+		}
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		Array src_arr = PtrToArg<Array>::convert(p_args[0]);
+		T dst_arr;
+
+		int size = src_arr.size();
+		dst_arr.resize(size);
+		for (int i = 0; i < size; i++) {
+			dst_arr.write[i] = src_arr[i];
+		}
+
+		PtrToArg<T>::encode(dst_arr, base);
+	}
+
+	static int get_argument_count() {
+		return 1;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return Variant::ARRAY;
+	}
+
+	static Variant::Type get_base_type() {
+		return GetTypeInfo<T>::VARIANT_TYPE;
+	}
+};
+
+class VariantConstructorNil {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		if (p_args[0]->get_type() != Variant::NIL) {
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+			r_error.argument = 0;
+			r_error.expected = Variant::NIL;
+			return;
+		}
+
+		r_error.error = Callable::CallError::CALL_OK;
+		VariantInternal::clear(&r_ret);
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantInternal::clear(&r_ret);
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		PtrToArg<Variant>::encode(Variant(), base);
+	}
+
+	static int get_argument_count() {
+		return 1;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return Variant::NIL;
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::NIL;
+	}
+};
+
+template <class T>
+class VariantConstructNoArgs {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		VariantTypeChanger<T>::change_and_reset(&r_ret);
+		r_error.error = Callable::CallError::CALL_OK;
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantTypeChanger<T>::change_and_reset(&r_ret);
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		PtrToArg<T>::encode(T(), base);
+	}
+
+	static int get_argument_count() {
+		return 0;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return Variant::NIL;
+	}
+
+	static Variant::Type get_base_type() {
+		return GetTypeInfo<T>::VARIANT_TYPE;
+	}
+};
+
+class VariantConstructNoArgsNil {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		VariantInternal::clear(&r_ret);
+		r_error.error = Callable::CallError::CALL_OK;
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantInternal::clear(&r_ret);
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		ERR_FAIL_MSG("can't ptrcall nil constructor");
+	}
+
+	static int get_argument_count() {
+		return 0;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return Variant::NIL;
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::NIL;
+	}
+};
+
+class VariantConstructNoArgsObject {
+public:
+	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+		VariantInternal::clear(&r_ret);
+		VariantInternal::object_assign_null(&r_ret);
+		r_error.error = Callable::CallError::CALL_OK;
+	}
+
+	static void validated_construct(Variant &r_ret, const Variant **p_args) {
+		VariantInternal::clear(&r_ret);
+		VariantInternal::object_assign_null(&r_ret);
+	}
+	static void ptr_construct(void *base, const void **p_args) {
+		PtrToArg<Object *>::encode(nullptr, base);
+	}
+
+	static int get_argument_count() {
+		return 0;
+	}
+
+	static Variant::Type get_argument_type(int p_arg) {
+		return Variant::NIL;
+	}
+
+	static Variant::Type get_base_type() {
+		return Variant::OBJECT;
+	}
+};
+
+struct VariantConstructData {
+	void (*construct)(Variant &r_base, const Variant **p_args, Callable::CallError &r_error);
+	Variant::ValidatedConstructor validated_construct;
+	Variant::PTRConstructor ptr_construct;
+	Variant::Type (*get_argument_type)(int);
+	int argument_count;
+	Vector<String> arg_names;
+};
+
+static LocalVector<VariantConstructData> construct_data[Variant::VARIANT_MAX];
+
+template <class T>
+static void add_constructor(const Vector<String> &arg_names) {
+	ERR_FAIL_COND_MSG(arg_names.size() != T::get_argument_count(), "Argument names size mismatch for " + Variant::get_type_name(T::get_base_type()) + ".");
+
+	VariantConstructData cd;
+	cd.construct = T::construct;
+	cd.validated_construct = T::validated_construct;
+	cd.ptr_construct = T::ptr_construct;
+	cd.get_argument_type = T::get_argument_type;
+	cd.argument_count = T::get_argument_count();
+	cd.arg_names = arg_names;
+	construct_data[T::get_base_type()].push_back(cd);
+}
+
+void Variant::_register_variant_constructors() {
+	add_constructor<VariantConstructNoArgsNil>(sarray());
+	add_constructor<VariantConstructorNil>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<bool>>(sarray());
+	add_constructor<VariantConstructor<bool, bool>>(sarray("from"));
+	add_constructor<VariantConstructor<bool, int64_t>>(sarray("from"));
+	add_constructor<VariantConstructor<bool, double>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<int64_t>>(sarray());
+	add_constructor<VariantConstructor<int64_t, int64_t>>(sarray("from"));
+	add_constructor<VariantConstructor<int64_t, double>>(sarray("from"));
+	add_constructor<VariantConstructor<int64_t, bool>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<double>>(sarray());
+	add_constructor<VariantConstructor<double, double>>(sarray("from"));
+	add_constructor<VariantConstructor<double, int64_t>>(sarray("from"));
+	add_constructor<VariantConstructor<double, bool>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<String>>(sarray());
+	add_constructor<VariantConstructor<String, String>>(sarray("from"));
+	add_constructor<VariantConstructor<String, StringName>>(sarray("from"));
+	add_constructor<VariantConstructor<String, NodePath>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<Vector2>>(sarray());
+	add_constructor<VariantConstructor<Vector2, Vector2>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector2, Vector2i>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector2, double, double>>(sarray("x", "y"));
+
+	add_constructor<VariantConstructNoArgs<Vector2i>>(sarray());
+	add_constructor<VariantConstructor<Vector2i, Vector2i>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector2i, Vector2>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector2i, int64_t, int64_t>>(sarray("x", "y"));
+
+	add_constructor<VariantConstructNoArgs<Rect2>>(sarray());
+	add_constructor<VariantConstructor<Rect2, Rect2>>(sarray("from"));
+	add_constructor<VariantConstructor<Rect2, Rect2i>>(sarray("from"));
+	add_constructor<VariantConstructor<Rect2, Vector2, Vector2>>(sarray("position", "size"));
+	add_constructor<VariantConstructor<Rect2, double, double, double, double>>(sarray("x", "y", "width", "height"));
+
+	add_constructor<VariantConstructNoArgs<Rect2i>>(sarray());
+	add_constructor<VariantConstructor<Rect2i, Rect2i>>(sarray("from"));
+	add_constructor<VariantConstructor<Rect2i, Rect2>>(sarray("from"));
+	add_constructor<VariantConstructor<Rect2i, Vector2i, Vector2i>>(sarray("position", "size"));
+	add_constructor<VariantConstructor<Rect2i, int64_t, int64_t, int64_t, int64_t>>(sarray("x", "y", "width", "height"));
+
+	add_constructor<VariantConstructNoArgs<Vector3>>(sarray());
+	add_constructor<VariantConstructor<Vector3, Vector3>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector3, Vector3i>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector3, double, double, double>>(sarray("x", "y", "z"));
+
+	add_constructor<VariantConstructNoArgs<Vector3i>>(sarray());
+	add_constructor<VariantConstructor<Vector3i, Vector3i>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector3i, Vector3>>(sarray("from"));
+	add_constructor<VariantConstructor<Vector3i, int64_t, int64_t, int64_t>>(sarray("x", "y", "z"));
+
+	add_constructor<VariantConstructNoArgs<Transform2D>>(sarray());
+	add_constructor<VariantConstructor<Transform2D, Transform2D>>(sarray("from"));
+	add_constructor<VariantConstructor<Transform2D, float, Vector2>>(sarray("rotation", "position"));
+	add_constructor<VariantConstructor<Transform2D, Vector2, Vector2, Vector2>>(sarray("x_axis", "y_axis", "origin"));
+
+	add_constructor<VariantConstructNoArgs<Plane>>(sarray());
+	add_constructor<VariantConstructor<Plane, Plane>>(sarray("from"));
+	add_constructor<VariantConstructor<Plane, Vector3, double>>(sarray("normal", "d"));
+	add_constructor<VariantConstructor<Plane, Vector3, Vector3>>(sarray("point", "normal"));
+	add_constructor<VariantConstructor<Plane, Vector3, Vector3, Vector3>>(sarray("point1", "point2", "point3"));
+	add_constructor<VariantConstructor<Plane, double, double, double, double>>(sarray("a", "b", "c", "d"));
+
+	add_constructor<VariantConstructNoArgs<Quat>>(sarray());
+	add_constructor<VariantConstructor<Quat, Quat>>(sarray("from"));
+	add_constructor<VariantConstructor<Quat, Basis>>(sarray("from"));
+	add_constructor<VariantConstructor<Quat, Vector3>>(sarray("euler"));
+	add_constructor<VariantConstructor<Quat, Vector3, double>>(sarray("axis", "angle"));
+	add_constructor<VariantConstructor<Quat, Vector3, Vector3>>(sarray("arc_from", "arc_to"));
+	add_constructor<VariantConstructor<Quat, double, double, double, double>>(sarray("x", "y", "z", "w"));
+
+	add_constructor<VariantConstructNoArgs<::AABB>>(sarray());
+	add_constructor<VariantConstructor<::AABB, ::AABB>>(sarray("from"));
+	add_constructor<VariantConstructor<::AABB, Vector3, Vector3>>(sarray("position", "size"));
+
+	add_constructor<VariantConstructNoArgs<Basis>>(sarray());
+	add_constructor<VariantConstructor<Basis, Basis>>(sarray("from"));
+	add_constructor<VariantConstructor<Basis, Quat>>(sarray("from"));
+	add_constructor<VariantConstructor<Basis, Vector3>>(sarray("euler"));
+	add_constructor<VariantConstructor<Basis, Vector3, double>>(sarray("axis", "phi"));
+	add_constructor<VariantConstructor<Basis, Vector3, Vector3, Vector3>>(sarray("x_axis", "y_axis", "z_axis"));
+
+	add_constructor<VariantConstructNoArgs<Transform>>(sarray());
+	add_constructor<VariantConstructor<Transform, Transform>>(sarray("from"));
+	add_constructor<VariantConstructor<Transform, Basis, Vector3>>(sarray("basis", "origin"));
+	add_constructor<VariantConstructor<Transform, Vector3, Vector3, Vector3, Vector3>>(sarray("x_axis", "y_axis", "z_axis", "origin"));
+
+	add_constructor<VariantConstructNoArgs<Color>>(sarray());
+	add_constructor<VariantConstructor<Color, Color>>(sarray("from"));
+	add_constructor<VariantConstructor<Color, Color, double>>(sarray("from", "alpha"));
+	add_constructor<VariantConstructor<Color, double, double, double>>(sarray("r", "g", "b"));
+	add_constructor<VariantConstructor<Color, double, double, double, double>>(sarray("r", "g", "b", "a"));
+
+	add_constructor<VariantConstructNoArgs<StringName>>(sarray());
+	add_constructor<VariantConstructor<StringName, StringName>>(sarray("from"));
+	add_constructor<VariantConstructor<StringName, String>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<NodePath>>(sarray());
+	add_constructor<VariantConstructor<NodePath, NodePath>>(sarray("from"));
+	add_constructor<VariantConstructor<NodePath, String>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<::RID>>(sarray());
+	add_constructor<VariantConstructor<::RID, ::RID>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgsObject>(sarray());
+	add_constructor<VariantConstructorObject>(sarray("from"));
+	add_constructor<VariantConstructorNilObject>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<Callable>>(sarray());
+	add_constructor<VariantConstructor<Callable, Callable>>(sarray("from"));
+	add_constructor<VariantConstructorCallableArgs>(sarray("object", "method"));
+
+	add_constructor<VariantConstructNoArgs<Signal>>(sarray());
+	add_constructor<VariantConstructor<Signal, Signal>>(sarray("from"));
+	add_constructor<VariantConstructorSignalArgs>(sarray("object", "signal"));
+
+	add_constructor<VariantConstructNoArgs<Dictionary>>(sarray());
+	add_constructor<VariantConstructor<Dictionary, Dictionary>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<Array>>(sarray());
+	add_constructor<VariantConstructor<Array, Array>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedByteArray>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedInt32Array>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedInt64Array>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedFloat32Array>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedFloat64Array>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedStringArray>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedVector2Array>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedVector3Array>>(sarray("from"));
+	add_constructor<VariantConstructorToArray<PackedColorArray>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedByteArray>>(sarray());
+	add_constructor<VariantConstructor<PackedByteArray, PackedByteArray>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedByteArray>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedInt32Array>>(sarray());
+	add_constructor<VariantConstructor<PackedInt32Array, PackedInt32Array>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedInt32Array>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedInt64Array>>(sarray());
+	add_constructor<VariantConstructor<PackedInt64Array, PackedInt64Array>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedInt64Array>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedFloat32Array>>(sarray());
+	add_constructor<VariantConstructor<PackedFloat32Array, PackedFloat32Array>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedFloat32Array>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedFloat64Array>>(sarray());
+	add_constructor<VariantConstructor<PackedFloat64Array, PackedFloat64Array>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedFloat64Array>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedStringArray>>(sarray());
+	add_constructor<VariantConstructor<PackedStringArray, PackedStringArray>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedStringArray>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedVector2Array>>(sarray());
+	add_constructor<VariantConstructor<PackedVector2Array, PackedVector2Array>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedVector2Array>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedVector3Array>>(sarray());
+	add_constructor<VariantConstructor<PackedVector3Array, PackedVector3Array>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedVector3Array>>(sarray("from"));
+
+	add_constructor<VariantConstructNoArgs<PackedColorArray>>(sarray());
+	add_constructor<VariantConstructor<PackedColorArray, PackedColorArray>>(sarray("from"));
+	add_constructor<VariantConstructorFromArray<PackedColorArray>>(sarray("from"));
+}
+
+void Variant::_unregister_variant_constructors() {
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		construct_data[i].clear();
+	}
+}
+
+void Variant::construct(Variant::Type p_type, Variant &base, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+	uint32_t s = construct_data[p_type].size();
+	for (uint32_t i = 0; i < s; i++) {
+		int argc = construct_data[p_type][i].argument_count;
+		if (argc != p_argcount) {
+			continue;
+		}
+		bool args_match = true;
+		for (int j = 0; j < argc; j++) {
+			if (!Variant::can_convert_strict(p_args[j]->get_type(), construct_data[p_type][i].get_argument_type(j))) {
+				args_match = false;
+				break;
+			}
+		}
+
+		if (!args_match) {
+			continue;
+		}
+
+		construct_data[p_type][i].construct(base, p_args, r_error);
+		return;
+	}
+
+	r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
+}
+
+int Variant::get_constructor_count(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, -1);
+	return construct_data[p_type].size();
+}
+
+Variant::ValidatedConstructor Variant::get_validated_constructor(Variant::Type p_type, int p_constructor) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+	ERR_FAIL_INDEX_V(p_constructor, (int)construct_data[p_type].size(), nullptr);
+	return construct_data[p_type][p_constructor].validated_construct;
+}
+
+Variant::PTRConstructor Variant::get_ptr_constructor(Variant::Type p_type, int p_constructor) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+	ERR_FAIL_INDEX_V(p_constructor, (int)construct_data[p_type].size(), nullptr);
+	return construct_data[p_type][p_constructor].ptr_construct;
+}
+
+int Variant::get_constructor_argument_count(Variant::Type p_type, int p_constructor) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, -1);
+	ERR_FAIL_INDEX_V(p_constructor, (int)construct_data[p_type].size(), -1);
+	return construct_data[p_type][p_constructor].argument_count;
+}
+
+Variant::Type Variant::get_constructor_argument_type(Variant::Type p_type, int p_constructor, int p_argument) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Variant::VARIANT_MAX);
+	ERR_FAIL_INDEX_V(p_constructor, (int)construct_data[p_type].size(), Variant::VARIANT_MAX);
+	return construct_data[p_type][p_constructor].get_argument_type(p_argument);
+}
+
+String Variant::get_constructor_argument_name(Variant::Type p_type, int p_constructor, int p_argument) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, String());
+	ERR_FAIL_INDEX_V(p_constructor, (int)construct_data[p_type].size(), String());
+	return construct_data[p_type][p_constructor].arg_names[p_argument];
+}
+
+void VariantInternal::object_assign(Variant *v, const Variant *o) {
+	if (o->_get_obj().obj && o->_get_obj().id.is_reference()) {
+		Reference *reference = static_cast<Reference *>(o->_get_obj().obj);
+		if (!reference->reference()) {
+			v->_get_obj().obj = nullptr;
+			v->_get_obj().id = ObjectID();
+			return;
+		}
+	}
+
+	v->_get_obj().obj = const_cast<Object *>(o->_get_obj().obj);
+	v->_get_obj().id = o->_get_obj().id;
+}
+
+void Variant::get_constructor_list(Type p_type, List<MethodInfo> *r_list) {
+	ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
+
+	MethodInfo mi;
+	mi.return_val.type = p_type;
+	mi.name = get_type_name(p_type);
+
+	for (int i = 0; i < get_constructor_count(p_type); i++) {
+		int ac = get_constructor_argument_count(p_type, i);
+		mi.arguments.clear();
+		for (int j = 0; j < ac; j++) {
+			PropertyInfo arg;
+			arg.name = get_constructor_argument_name(p_type, i, j);
+			arg.type = get_constructor_argument_type(p_type, i, j);
+			mi.arguments.push_back(arg);
+		}
+		r_list->push_back(mi);
+	}
+}
diff --git a/core/variant_internal.h b/core/variant/variant_internal.h
index 7893c6d382..3ac7f32dec 100644
--- a/core/variant_internal.h
+++ b/core/variant/variant_internal.h
@@ -83,8 +83,8 @@ public:
 	_FORCE_INLINE_ static const StringName *get_string_name(const Variant *v) { return reinterpret_cast<const StringName *>(v->_data._mem); }
 	_FORCE_INLINE_ static NodePath *get_node_path(Variant *v) { return reinterpret_cast<NodePath *>(v->_data._mem); }
 	_FORCE_INLINE_ static const NodePath *get_node_path(const Variant *v) { return reinterpret_cast<const NodePath *>(v->_data._mem); }
-	_FORCE_INLINE_ static RID *get_rid(Variant *v) { return reinterpret_cast<RID *>(v->_data._mem); }
-	_FORCE_INLINE_ static const RID *get_rid(const Variant *v) { return reinterpret_cast<const RID *>(v->_data._mem); }
+	_FORCE_INLINE_ static ::RID *get_rid(Variant *v) { return reinterpret_cast<::RID *>(v->_data._mem); }
+	_FORCE_INLINE_ static const ::RID *get_rid(const Variant *v) { return reinterpret_cast<const ::RID *>(v->_data._mem); }
 	_FORCE_INLINE_ static Callable *get_callable(Variant *v) { return reinterpret_cast<Callable *>(v->_data._mem); }
 	_FORCE_INLINE_ static const Callable *get_callable(const Variant *v) { return reinterpret_cast<const Callable *>(v->_data._mem); }
 	_FORCE_INLINE_ static Signal *get_signal(Variant *v) { return reinterpret_cast<Signal *>(v->_data._mem); }
@@ -116,6 +116,106 @@ public:
 
 	_FORCE_INLINE_ static Object **get_object(Variant *v) { return (Object **)&v->_get_obj().obj; }
 	_FORCE_INLINE_ static const Object **get_object(const Variant *v) { return (const Object **)&v->_get_obj().obj; }
+
+	_FORCE_INLINE_ static const ObjectID get_object_id(const Variant *v) { return v->_get_obj().id; }
+
+	template <class T>
+	_FORCE_INLINE_ static void init_generic(Variant *v) {
+		v->type = GetTypeInfo<T>::VARIANT_TYPE;
+	}
+
+	_FORCE_INLINE_ static void init_string(Variant *v) {
+		memnew_placement(v->_data._mem, String);
+		v->type = Variant::STRING;
+	}
+
+	_FORCE_INLINE_ static void init_transform2d(Variant *v) {
+		v->_data._transform2d = memnew(Transform2D);
+		v->type = Variant::TRANSFORM2D;
+	}
+	_FORCE_INLINE_ static void init_aabb(Variant *v) {
+		v->_data._aabb = memnew(AABB);
+		v->type = Variant::AABB;
+	}
+	_FORCE_INLINE_ static void init_basis(Variant *v) {
+		v->_data._basis = memnew(Basis);
+		v->type = Variant::BASIS;
+	}
+	_FORCE_INLINE_ static void init_transform(Variant *v) {
+		v->_data._transform = memnew(Transform);
+		v->type = Variant::TRANSFORM;
+	}
+	_FORCE_INLINE_ static void init_string_name(Variant *v) {
+		memnew_placement(v->_data._mem, StringName);
+		v->type = Variant::STRING_NAME;
+	}
+	_FORCE_INLINE_ static void init_node_path(Variant *v) {
+		memnew_placement(v->_data._mem, NodePath);
+		v->type = Variant::NODE_PATH;
+	}
+	_FORCE_INLINE_ static void init_callable(Variant *v) {
+		memnew_placement(v->_data._mem, Callable);
+		v->type = Variant::CALLABLE;
+	}
+	_FORCE_INLINE_ static void init_signal(Variant *v) {
+		memnew_placement(v->_data._mem, Signal);
+		v->type = Variant::SIGNAL;
+	}
+	_FORCE_INLINE_ static void init_dictionary(Variant *v) {
+		memnew_placement(v->_data._mem, Dictionary);
+		v->type = Variant::DICTIONARY;
+	}
+	_FORCE_INLINE_ static void init_array(Variant *v) {
+		memnew_placement(v->_data._mem, Array);
+		v->type = Variant::ARRAY;
+	}
+	_FORCE_INLINE_ static void init_byte_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<uint8_t>::create(Vector<uint8_t>());
+		v->type = Variant::PACKED_BYTE_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_int32_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<int32_t>::create(Vector<int32_t>());
+		v->type = Variant::PACKED_INT32_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_int64_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<int64_t>::create(Vector<int64_t>());
+		v->type = Variant::PACKED_INT64_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_float32_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<float>::create(Vector<float>());
+		v->type = Variant::PACKED_FLOAT32_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_float64_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<double>::create(Vector<double>());
+		v->type = Variant::PACKED_FLOAT64_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_string_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<String>::create(Vector<String>());
+		v->type = Variant::PACKED_STRING_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_vector2_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<Vector2>::create(Vector<Vector2>());
+		v->type = Variant::PACKED_VECTOR2_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_vector3_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<Vector3>::create(Vector<Vector3>());
+		v->type = Variant::PACKED_VECTOR3_ARRAY;
+	}
+	_FORCE_INLINE_ static void init_color_array(Variant *v) {
+		v->_data.packed_array = Variant::PackedArrayRef<Color>::create(Vector<Color>());
+		v->type = Variant::PACKED_COLOR_ARRAY;
+	}
+
+	_FORCE_INLINE_ static void clear(Variant *v) {
+		v->clear();
+	}
+
+	static void object_assign(Variant *v, const Variant *o); //needs to use reference, do away
+
+	_FORCE_INLINE_ static void object_assign_null(Variant *v) {
+		v->_get_obj().obj = nullptr;
+		v->_get_obj().id = ObjectID();
+	}
 };
 
 template <class T>
@@ -305,9 +405,9 @@ struct VariantGetInternalPtr<NodePath> {
 };
 
 template <>
-struct VariantGetInternalPtr<RID> {
-	static RID *get_ptr(Variant *v) { return VariantInternal::get_rid(v); }
-	static const RID *get_ptr(const Variant *v) { return VariantInternal::get_rid(v); }
+struct VariantGetInternalPtr<::RID> {
+	static ::RID *get_ptr(Variant *v) { return VariantInternal::get_rid(v); }
+	static const ::RID *get_ptr(const Variant *v) { return VariantInternal::get_rid(v); }
 };
 
 template <>
@@ -532,9 +632,9 @@ struct VariantInternalAccessor<NodePath> {
 };
 
 template <>
-struct VariantInternalAccessor<RID> {
-	static _FORCE_INLINE_ const RID &get(const Variant *v) { return *VariantInternal::get_rid(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const RID &p_value) { *VariantInternal::get_rid(v) = p_value; }
+struct VariantInternalAccessor<::RID> {
+	static _FORCE_INLINE_ const ::RID &get(const Variant *v) { return *VariantInternal::get_rid(v); }
+	static _FORCE_INLINE_ void set(Variant *v, const ::RID &p_value) { *VariantInternal::get_rid(v) = p_value; }
 };
 
 template <>
@@ -649,4 +749,383 @@ struct VariantInternalAccessor<Vector<Variant>> {
 	}
 };
 
+template <class T>
+struct VariantInitializer {
+};
+
+template <>
+struct VariantInitializer<bool> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<bool>(v); }
+};
+
+#define INITIALIZER_INT(m_type)                                                                    \
+	template <>                                                                                    \
+	struct VariantInitializer<m_type> {                                                            \
+		static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<int64_t>(v); } \
+	};
+
+INITIALIZER_INT(uint8_t)
+INITIALIZER_INT(int8_t)
+INITIALIZER_INT(uint16_t)
+INITIALIZER_INT(int16_t)
+INITIALIZER_INT(uint32_t)
+INITIALIZER_INT(int32_t)
+INITIALIZER_INT(uint64_t)
+INITIALIZER_INT(int64_t)
+INITIALIZER_INT(char32_t)
+INITIALIZER_INT(Error)
+INITIALIZER_INT(ObjectID)
+
+template <>
+struct VariantInitializer<double> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<double>(v); }
+};
+
+template <>
+struct VariantInitializer<float> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<double>(v); }
+};
+
+template <>
+struct VariantInitializer<String> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string(v); }
+};
+
+template <>
+struct VariantInitializer<Vector2> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Vector2>(v); }
+};
+
+template <>
+struct VariantInitializer<Vector2i> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Vector2i>(v); }
+};
+
+template <>
+struct VariantInitializer<Rect2> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Rect2>(v); }
+};
+
+template <>
+struct VariantInitializer<Rect2i> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Rect2i>(v); }
+};
+
+template <>
+struct VariantInitializer<Vector3> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Vector3>(v); }
+};
+
+template <>
+struct VariantInitializer<Vector3i> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Vector3i>(v); }
+};
+
+template <>
+struct VariantInitializer<Transform2D> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_transform2d(v); }
+};
+
+template <>
+struct VariantInitializer<Plane> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Plane>(v); }
+};
+
+template <>
+struct VariantInitializer<Quat> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Quat>(v); }
+};
+
+template <>
+struct VariantInitializer<AABB> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_aabb(v); }
+};
+
+template <>
+struct VariantInitializer<Basis> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_basis(v); }
+};
+
+template <>
+struct VariantInitializer<Transform> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_transform(v); }
+};
+
+template <>
+struct VariantInitializer<Color> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<Color>(v); }
+};
+
+template <>
+struct VariantInitializer<StringName> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string_name(v); }
+};
+
+template <>
+struct VariantInitializer<NodePath> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_node_path(v); }
+};
+
+template <>
+struct VariantInitializer<::RID> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<::RID>(v); }
+};
+
+template <>
+struct VariantInitializer<Callable> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_callable(v); }
+};
+
+template <>
+struct VariantInitializer<Signal> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_signal(v); }
+};
+
+template <>
+struct VariantInitializer<Dictionary> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_dictionary(v); }
+};
+
+template <>
+struct VariantInitializer<Array> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedByteArray> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_byte_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedInt32Array> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_int32_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedInt64Array> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_int64_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedFloat32Array> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_float32_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedFloat64Array> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_float64_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedStringArray> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedVector2Array> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_vector2_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedVector3Array> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_vector3_array(v); }
+};
+
+template <>
+struct VariantInitializer<PackedColorArray> {
+	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_color_array(v); }
+};
+
+template <class T>
+struct VariantZeroAssigner {
+};
+
+template <>
+struct VariantZeroAssigner<bool> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_bool(v) = false; }
+};
+
+template <>
+struct VariantZeroAssigner<int64_t> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_int(v) = 0; }
+};
+
+template <>
+struct VariantZeroAssigner<double> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
+};
+
+template <>
+struct VariantZeroAssigner<float> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
+};
+
+template <>
+struct VariantZeroAssigner<String> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<Vector2> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector2(v) = Vector2(); }
+};
+
+template <>
+struct VariantZeroAssigner<Vector2i> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector2i(v) = Vector2i(); }
+};
+
+template <>
+struct VariantZeroAssigner<Rect2> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_rect2(v) = Rect2(); }
+};
+
+template <>
+struct VariantZeroAssigner<Rect2i> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_rect2i(v) = Rect2i(); }
+};
+
+template <>
+struct VariantZeroAssigner<Vector3> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector3(v) = Vector3(); }
+};
+
+template <>
+struct VariantZeroAssigner<Vector3i> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector3i(v) = Vector3i(); }
+};
+
+template <>
+struct VariantZeroAssigner<Transform2D> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_transform2d(v) = Transform2D(); }
+};
+
+template <>
+struct VariantZeroAssigner<Plane> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_plane(v) = Plane(); }
+};
+
+template <>
+struct VariantZeroAssigner<Quat> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_quat(v) = Quat(); }
+};
+
+template <>
+struct VariantZeroAssigner<AABB> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_aabb(v) = AABB(); }
+};
+
+template <>
+struct VariantZeroAssigner<Basis> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_basis(v) = Basis(); }
+};
+
+template <>
+struct VariantZeroAssigner<Transform> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_transform(v) = Transform(); }
+};
+
+template <>
+struct VariantZeroAssigner<Color> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_color(v) = Color(); }
+};
+
+template <>
+struct VariantZeroAssigner<StringName> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<NodePath> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<::RID> {
+	static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_rid(v) = RID(); }
+};
+
+template <>
+struct VariantZeroAssigner<Callable> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<Signal> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<Dictionary> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<Array> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedByteArray> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedInt32Array> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedInt64Array> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedFloat32Array> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedFloat64Array> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedStringArray> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedVector2Array> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedVector3Array> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <>
+struct VariantZeroAssigner<PackedColorArray> {
+	static _FORCE_INLINE_ void zero(Variant *v) {}
+};
+
+template <class T>
+struct VariantTypeChanger {
+	static _FORCE_INLINE_ void change(Variant *v) {
+		if (v->get_type() != GetTypeInfo<T>::VARIANT_TYPE || GetTypeInfo<T>::VARIANT_TYPE >= Variant::PACKED_BYTE_ARRAY) { //second condition removed by optimizer
+			VariantInternal::clear(v);
+			VariantInitializer<T>::init(v);
+		}
+	}
+	static _FORCE_INLINE_ void change_and_reset(Variant *v) {
+		if (v->get_type() != GetTypeInfo<T>::VARIANT_TYPE || GetTypeInfo<T>::VARIANT_TYPE >= Variant::PACKED_BYTE_ARRAY) { //second condition removed by optimizer
+			VariantInternal::clear(v);
+			VariantInitializer<T>::init(v);
+		}
+
+		VariantZeroAssigner<T>::zero(v);
+	}
+};
+
 #endif // VARIANT_INTERNAL_H
diff --git a/core/variant/variant_op.cpp b/core/variant/variant_op.cpp
new file mode 100644
index 0000000000..8e55c1d6cd
--- /dev/null
+++ b/core/variant/variant_op.cpp
@@ -0,0 +1,2190 @@
+/*************************************************************************/
+/*  variant_op.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "variant.h"
+
+#include "core/core_string_names.h"
+#include "core/debugger/engine_debugger.h"
+#include "core/object/class_db.h"
+
+template <class R, class A, class B>
+class OperatorEvaluatorAdd {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a + b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) + *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) + PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorSub {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a - b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) - *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) - PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorMul {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a * b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) * *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) * PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorXForm {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a.xform(b);
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = VariantGetInternalPtr<A>::get_ptr(left)->xform(*VariantGetInternalPtr<B>::get_ptr(right));
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left).xform(PtrToArg<B>::convert(right)), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorXFormInv {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = b.xform_inv(a);
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = VariantGetInternalPtr<B>::get_ptr(right)->xform_inv(*VariantGetInternalPtr<A>::get_ptr(left));
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<B>::convert(right).xform_inv(PtrToArg<A>::convert(left)), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorDiv {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a / b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) / *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorDivNZ {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		if (b == 0) {
+			r_valid = false;
+			*r_ret = "Division by zero error";
+			return;
+		}
+		*r_ret = a / b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) / *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorMod {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a % b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) % *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorModNZ {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		if (b == 0) {
+			r_valid = false;
+			*r_ret = "Module by zero error";
+			return;
+		}
+		*r_ret = a % b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) % *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A>
+class OperatorEvaluatorNeg {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		*r_ret = -a;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = -*VariantGetInternalPtr<A>::get_ptr(left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(-PtrToArg<A>::convert(left), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A>
+class OperatorEvaluatorPos {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		*r_ret = a;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorShiftLeft {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a << b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) << *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) << PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorShiftRight {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a >> b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) >> *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) >> PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorBitOr {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a | b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) | *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) | PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorBitAnd {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a & b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) & *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) & PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A, class B>
+class OperatorEvaluatorBitXor {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a ^ b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) ^ *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) ^ PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class R, class A>
+class OperatorEvaluatorBitNeg {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		*r_ret = ~a;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<R>::change(r_ret);
+		*VariantGetInternalPtr<R>::get_ptr(r_ret) = ~*VariantGetInternalPtr<A>::get_ptr(left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(~PtrToArg<A>::convert(left), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorEqual {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a == b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) == *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+//equalobject
+class OperatorEvaluatorEqualObject {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Object *a = p_left.get_validated_object();
+		const Object *b = p_right.get_validated_object();
+		*r_ret = a == b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Object *a = left->get_validated_object();
+		const Object *b = right->get_validated_object();
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a == b;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == PtrToArg<Object *>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorEqualObjectNil {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Object *a = p_left.get_validated_object();
+		*r_ret = a == nullptr;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Object *a = left->get_validated_object();
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a == nullptr;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorEqualNilObject {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Object *b = p_right.get_validated_object();
+		*r_ret = nullptr == b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Object *b = right->get_validated_object();
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = nullptr == b;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(nullptr == PtrToArg<Object *>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorNotEqual {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a != b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) != *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) != PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorNotEqualObject {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		Object *a = p_left.get_validated_object();
+		Object *b = p_right.get_validated_object();
+		*r_ret = a != b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		Object *a = left->get_validated_object();
+		Object *b = right->get_validated_object();
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a != b;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != PtrToArg<Object *>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorNotEqualObjectNil {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		Object *a = p_left.get_validated_object();
+		*r_ret = a != nullptr;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		Object *a = left->get_validated_object();
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a != nullptr;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != nullptr, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorNotEqualNilObject {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		Object *b = p_right.get_validated_object();
+		*r_ret = nullptr != b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		Object *b = right->get_validated_object();
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = nullptr != b;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(nullptr != PtrToArg<Object *>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorLess {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a < b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) < *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) < PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorLessEqual {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a <= b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) <= *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) <= PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorGreater {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a > b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) > *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) > PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorGreaterEqual {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a >= b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) >= *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) >= PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorAnd {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a && b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) && *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) && PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorOr {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = a || b;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) || *VariantGetInternalPtr<B>::get_ptr(right);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) || PtrToArg<B>::convert(right), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+#define XOR_OP(m_a, m_b) (((m_a) || (m_b)) && !((m_a) && (m_b)))
+template <class A, class B>
+class OperatorEvaluatorXor {
+public:
+	_FORCE_INLINE_ static bool xor_op(const A &a, const B &b) {
+		return ((a) || (b)) && !((a) && (b));
+	}
+
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+		*r_ret = xor_op(a, b);
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = xor_op(*VariantGetInternalPtr<A>::get_ptr(left), *VariantGetInternalPtr<B>::get_ptr(right));
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(xor_op(PtrToArg<A>::convert(left), PtrToArg<B>::convert(right)), r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A>
+class OperatorEvaluatorNot {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		*r_ret = !a;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<A>::get_ptr(left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(!PtrToArg<A>::convert(left));
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+//// CUSTOM ////
+
+class OperatorEvaluatorAddArray {
+public:
+	_FORCE_INLINE_ static void _add_arrays(Array &sum, const Array &array_a, const Array &array_b) {
+		int asize = array_a.size();
+		int bsize = array_b.size();
+		sum.resize(asize + bsize);
+		for (int i = 0; i < asize; i++) {
+			sum[i] = array_a[i];
+		}
+		for (int i = 0; i < bsize; i++) {
+			sum[i + asize] = array_b[i];
+		}
+	}
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Array &array_a = *VariantGetInternalPtr<Array>::get_ptr(&p_left);
+		const Array &array_b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
+		Array sum;
+		_add_arrays(sum, array_a, array_b);
+		*r_ret = sum;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<Array>::change(r_ret);
+		_add_arrays(*VariantGetInternalPtr<Array>::get_ptr(r_ret), *VariantGetInternalPtr<Array>::get_ptr(left), *VariantGetInternalPtr<Array>::get_ptr(right));
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		Array ret;
+		_add_arrays(ret, PtrToArg<Array>::convert(left), PtrToArg<Array>::convert(right));
+		PtrToArg<Array>::encode(ret, r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return Variant::ARRAY; }
+};
+
+template <class T>
+class OperatorEvaluatorAppendArray {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Vector<T> &array_a = *VariantGetInternalPtr<Vector<T>>::get_ptr(&p_left);
+		const Vector<T> &array_b = *VariantGetInternalPtr<Vector<T>>::get_ptr(&p_right);
+		Vector<T> sum = array_a;
+		sum.append_array(array_b);
+		*r_ret = sum;
+		r_valid = true;
+	}
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<Vector<T>>::change(r_ret);
+		*VariantGetInternalPtr<Vector<T>>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector<T>>::get_ptr(left);
+		VariantGetInternalPtr<Vector<T>>::get_ptr(r_ret)->append_array(*VariantGetInternalPtr<Vector<T>>::get_ptr(right));
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		Vector<T> sum = PtrToArg<Vector<T>>::convert(left);
+		sum.append_array(PtrToArg<Vector<T>>::convert(right));
+		PtrToArg<Vector<T>>::encode(sum, r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return GetTypeInfo<Vector<T>>::VARIANT_TYPE; }
+};
+
+class OperatorEvaluatorStringModNil {
+public:
+	_FORCE_INLINE_ static String do_mod(const String &s, bool *r_valid) {
+		Array values;
+		values.push_back(Variant());
+
+		String a = s.sprintf(values, r_valid);
+		if (r_valid) {
+			*r_valid = !*r_valid;
+		}
+		return a;
+	}
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const String &a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
+		*r_ret = do_mod(a, &r_valid);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<String>::change(r_ret);
+		*VariantGetInternalPtr<String>::get_ptr(r_ret) = do_mod(*VariantGetInternalPtr<String>::get_ptr(left), nullptr);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<String>::encode(do_mod(PtrToArg<String>::convert(left), nullptr), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::STRING; }
+};
+
+class OperatorEvaluatorStringModArray {
+public:
+	_FORCE_INLINE_ static String do_mod(const String &s, const Array &p_values, bool *r_valid) {
+		String a = s.sprintf(p_values, r_valid);
+		if (r_valid) {
+			*r_valid = !*r_valid;
+		}
+		return a;
+	}
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const String &a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
+		*r_ret = do_mod(a, *VariantGetInternalPtr<Array>::get_ptr(&p_right), &r_valid);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<String>::change(r_ret);
+		*VariantGetInternalPtr<String>::get_ptr(r_ret) = do_mod(*VariantGetInternalPtr<String>::get_ptr(left), *VariantGetInternalPtr<Array>::get_ptr(right), nullptr);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<String>::encode(do_mod(PtrToArg<String>::convert(left), PtrToArg<Array>::convert(right), nullptr), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::STRING; }
+};
+
+class OperatorEvaluatorStringModObject {
+public:
+	_FORCE_INLINE_ static String do_mod(const String &s, const Object *p_object, bool *r_valid) {
+		Array values;
+		values.push_back(p_object);
+		String a = s.sprintf(values, r_valid);
+		if (r_valid) {
+			*r_valid = !*r_valid;
+		}
+
+		return a;
+	}
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const String &a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
+		*r_ret = do_mod(a, p_right.get_validated_object(), &r_valid);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<String>::change(r_ret);
+		*VariantGetInternalPtr<String>::get_ptr(r_ret) = do_mod(*VariantGetInternalPtr<String>::get_ptr(left), right->get_validated_object(), nullptr);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<String>::encode(do_mod(PtrToArg<String>::convert(left), PtrToArg<Object *>::convert(right), nullptr), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::STRING; }
+};
+
+template <class T>
+class OperatorEvaluatorStringModT {
+public:
+	_FORCE_INLINE_ static String do_mod(const String &s, const T &p_value, bool *r_valid) {
+		Array values;
+		values.push_back(p_value);
+		String a = s.sprintf(values, r_valid);
+		if (r_valid) {
+			*r_valid = !*r_valid;
+		}
+		return a;
+	}
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const String &a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
+		*r_ret = do_mod(a, *VariantGetInternalPtr<T>::get_ptr(&p_right), &r_valid);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<String>::change(r_ret);
+		*VariantGetInternalPtr<String>::get_ptr(r_ret) = do_mod(*VariantGetInternalPtr<String>::get_ptr(left), *VariantGetInternalPtr<T>::get_ptr(right), nullptr);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<String>::encode(do_mod(PtrToArg<String>::convert(left), PtrToArg<T>::convert(right), nullptr), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::STRING; }
+};
+
+template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
+class OperatorEvaluatorAlwaysTrue {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		*r_ret = true;
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = true;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(true, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
+class OperatorEvaluatorAlwaysFalse {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		*r_ret = false;
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = false;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(false, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+///// OR ///////
+
+_FORCE_INLINE_ static bool _operate_or(bool p_left, bool p_right) {
+	return p_left || p_right;
+}
+_FORCE_INLINE_ static bool _operate_and(bool p_left, bool p_right) {
+	return p_left && p_right;
+}
+_FORCE_INLINE_ static bool _operate_xor(bool p_left, bool p_right) {
+	return (p_left || p_right) && !(p_left && p_right);
+}
+
+_FORCE_INLINE_ static bool _operate_get_nil(const Variant *p_ptr) {
+	return p_ptr->get_validated_object() != nullptr;
+}
+
+_FORCE_INLINE_ static bool _operate_get_bool(const Variant *p_ptr) {
+	return *VariantGetInternalPtr<bool>::get_ptr(p_ptr);
+}
+
+_FORCE_INLINE_ static bool _operate_get_int(const Variant *p_ptr) {
+	return *VariantGetInternalPtr<int64_t>::get_ptr(p_ptr) != 0;
+}
+
+_FORCE_INLINE_ static bool _operate_get_float(const Variant *p_ptr) {
+	return *VariantGetInternalPtr<double>::get_ptr(p_ptr) != 0.0;
+}
+
+_FORCE_INLINE_ static bool _operate_get_object(const Variant *p_ptr) {
+	return p_ptr->get_validated_object() != nullptr;
+}
+
+#ifndef PTRCALL_ENABLED
+
+#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op)                                                                    \
+	class m_class_name {                                                                                                     \
+	public:                                                                                                                  \
+		static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {                 \
+			*r_ret = m_op(_operate_get_##m_left(&p_left), _operate_get_##m_right(&p_right));                                 \
+			r_valid = true;                                                                                                  \
+		}                                                                                                                    \
+                                                                                                                             \
+		static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {                          \
+			VariantTypeChanger<bool>::change(r_ret);                                                                         \
+			*VariantGetInternalPtr<bool>::get_ptr(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \
+		}                                                                                                                    \
+                                                                                                                             \
+		static Variant::Type                                                                                                 \
+		get_return_type() {                                                                                                  \
+			return Variant::BOOL;                                                                                            \
+		}                                                                                                                    \
+	};
+
+#else
+
+_FORCE_INLINE_ static bool _operate_get_ptr_nil(const void *p_ptr) {
+	return false;
+}
+
+_FORCE_INLINE_ static bool _operate_get_ptr_bool(const void *p_ptr) {
+	return PtrToArg<bool>::convert(p_ptr);
+}
+
+_FORCE_INLINE_ static bool _operate_get_ptr_int(const void *p_ptr) {
+	return PtrToArg<int64_t>::convert(p_ptr) != 0;
+}
+
+_FORCE_INLINE_ static bool _operate_get_ptr_float(const void *p_ptr) {
+	return PtrToArg<double>::convert(p_ptr) != 0.0;
+}
+
+_FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) {
+	return PtrToArg<Object *>::convert(p_ptr) != nullptr;
+}
+
+#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op)                                                                    \
+	class m_class_name {                                                                                                     \
+	public:                                                                                                                  \
+		static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {                 \
+			*r_ret = m_op(_operate_get_##m_left(&p_left), _operate_get_##m_right(&p_right));                                 \
+			r_valid = true;                                                                                                  \
+		}                                                                                                                    \
+                                                                                                                             \
+		static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {                          \
+			VariantTypeChanger<bool>::change(r_ret);                                                                         \
+			*VariantGetInternalPtr<bool>::get_ptr(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \
+		}                                                                                                                    \
+                                                                                                                             \
+		static void ptr_evaluate(const void *left, const void *right, void *r_ret) {                                         \
+			PtrToArg<bool>::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret);         \
+		}                                                                                                                    \
+                                                                                                                             \
+		static Variant::Type get_return_type() {                                                                             \
+			return Variant::BOOL;                                                                                            \
+		}                                                                                                                    \
+	};
+
+#endif
+
+// OR
+
+//nil
+OP_EVALUATOR(OperatorEvaluatorNilXBoolOr, nil, bool, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorBoolXNilOr, bool, nil, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorNilXIntOr, nil, int, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorIntXNilOr, int, nil, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorNilXFloatOr, nil, float, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorFloatXNilOr, float, nil, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorObjectXNilOr, object, nil, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorNilXObjectOr, nil, object, _operate_or)
+
+//bool
+OP_EVALUATOR(OperatorEvaluatorBoolXBoolOr, bool, bool, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXIntOr, bool, int, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorIntXBoolOr, int, bool, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXFloatOr, bool, float, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorFloatXBoolOr, float, bool, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXObjectOr, bool, object, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorObjectXBoolOr, object, bool, _operate_or)
+
+//int
+
+OP_EVALUATOR(OperatorEvaluatorIntXIntOr, int, int, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorIntXFloatOr, int, float, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorFloatXIntOr, float, int, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorIntXObjectOr, int, object, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorObjectXIntOr, object, int, _operate_or)
+
+//float
+
+OP_EVALUATOR(OperatorEvaluatorFloatXFloatOr, float, float, _operate_or)
+
+OP_EVALUATOR(OperatorEvaluatorFloatXObjectOr, float, object, _operate_or)
+OP_EVALUATOR(OperatorEvaluatorObjectXFloatOr, object, float, _operate_or)
+
+//object
+
+OP_EVALUATOR(OperatorEvaluatorObjectXObjectOr, object, object, _operate_or)
+
+// AND
+
+//nil
+OP_EVALUATOR(OperatorEvaluatorNilXBoolAnd, nil, bool, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorBoolXNilAnd, bool, nil, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorNilXIntAnd, nil, int, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorIntXNilAnd, int, nil, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorNilXFloatAnd, nil, float, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorFloatXNilAnd, float, nil, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorObjectXNilAnd, object, nil, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorNilXObjectAnd, nil, object, _operate_and)
+
+//bool
+OP_EVALUATOR(OperatorEvaluatorBoolXBoolAnd, bool, bool, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXIntAnd, bool, int, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorIntXBoolAnd, int, bool, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXFloatAnd, bool, float, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorFloatXBoolAnd, float, bool, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXObjectAnd, bool, object, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorObjectXBoolAnd, object, bool, _operate_and)
+
+//int
+
+OP_EVALUATOR(OperatorEvaluatorIntXIntAnd, int, int, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorIntXFloatAnd, int, float, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorFloatXIntAnd, float, int, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorIntXObjectAnd, int, object, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorObjectXIntAnd, object, int, _operate_and)
+
+//float
+
+OP_EVALUATOR(OperatorEvaluatorFloatXFloatAnd, float, float, _operate_and)
+
+OP_EVALUATOR(OperatorEvaluatorFloatXObjectAnd, float, object, _operate_and)
+OP_EVALUATOR(OperatorEvaluatorObjectXFloatAnd, object, float, _operate_and)
+
+//object
+
+OP_EVALUATOR(OperatorEvaluatorObjectXObjectAnd, object, object, _operate_and)
+
+// XOR
+
+//nil
+OP_EVALUATOR(OperatorEvaluatorNilXBoolXor, nil, bool, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorBoolXNilXor, bool, nil, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorNilXIntXor, nil, int, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorIntXNilXor, int, nil, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorNilXFloatXor, nil, float, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorFloatXNilXor, float, nil, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorObjectXNilXor, object, nil, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorNilXObjectXor, nil, object, _operate_xor)
+
+//bool
+OP_EVALUATOR(OperatorEvaluatorBoolXBoolXor, bool, bool, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXIntXor, bool, int, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorIntXBoolXor, int, bool, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXFloatXor, bool, float, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorFloatXBoolXor, float, bool, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorBoolXObjectXor, bool, object, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorObjectXBoolXor, object, bool, _operate_xor)
+
+//int
+
+OP_EVALUATOR(OperatorEvaluatorIntXIntXor, int, int, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorIntXFloatXor, int, float, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorFloatXIntXor, float, int, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorIntXObjectXor, int, object, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorObjectXIntXor, object, int, _operate_xor)
+
+//float
+
+OP_EVALUATOR(OperatorEvaluatorFloatXFloatXor, float, float, _operate_xor)
+
+OP_EVALUATOR(OperatorEvaluatorFloatXObjectXor, float, object, _operate_xor)
+OP_EVALUATOR(OperatorEvaluatorObjectXFloatXor, object, float, _operate_xor)
+
+//object
+
+OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor)
+
+class OperatorEvaluatorNotBool {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		*r_ret = !*VariantGetInternalPtr<bool>::get_ptr(&p_left);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<bool>::get_ptr(left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(!PtrToArg<bool>::convert(left), r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorNotInt {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		*r_ret = !*VariantGetInternalPtr<int64_t>::get_ptr(&p_left);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<int64_t>::get_ptr(left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(!PtrToArg<int64_t>::convert(left), r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorNotFloat {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		*r_ret = !*VariantGetInternalPtr<double>::get_ptr(&p_left);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<double>::get_ptr(left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(!PtrToArg<double>::convert(left), r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorNotObject {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		*r_ret = p_left.get_validated_object() == nullptr;
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = left->get_validated_object() == nullptr;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
+	}
+#endif
+
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+////
+
+class OperatorEvaluatorInStringFind {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const String &str_a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
+		const String &str_b = *VariantGetInternalPtr<String>::get_ptr(&p_right);
+
+		*r_ret = str_b.find(str_a) != -1;
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const String &str_a = *VariantGetInternalPtr<String>::get_ptr(left);
+		const String &str_b = *VariantGetInternalPtr<String>::get_ptr(right);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = str_b.find(str_a) != -1;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<String>::convert(right).find(PtrToArg<String>::convert(left)) != -1, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A, class B>
+class OperatorEvaluatorInArrayFind {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
+
+		*r_ret = b.find(a) != -1;
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(left);
+		const B &b = *VariantGetInternalPtr<B>::get_ptr(right);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(a) != -1;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<B>::convert(right).find(PtrToArg<A>::convert(left)) != -1, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorInArrayFindNil {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
+		*r_ret = b.find(Variant()) != -1;
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(right);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(Variant()) != -1;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(Variant()) != -1, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorInArrayFindObject {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
+		*r_ret = b.find(p_left) != -1;
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(right);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(*left) != -1;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(PtrToArg<Object *>::convert(left)) != -1, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+template <class A>
+class OperatorEvaluatorInDictionaryHas {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
+
+		*r_ret = b.has(a);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
+		const A &a = *VariantGetInternalPtr<A>::get_ptr(left);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(a);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<A>::convert(left)), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorInDictionaryHasNil {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
+
+		*r_ret = b.has(Variant());
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(Variant());
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(Variant()), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorInDictionaryHasObject {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
+
+		*r_ret = b.has(p_left);
+		r_valid = true;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(*left);
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<Object *>::convert(left)), r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorObjectHasPropertyString {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		Object *b = p_right.get_validated_object();
+		if (!b) {
+			*r_ret = "Invalid base object for 'in'";
+			r_valid = false;
+			return;
+		}
+
+		const String &a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
+
+		b->get(a, &r_valid);
+		*r_ret = r_valid;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		Object *l = right->get_validated_object();
+		ERR_FAIL_COND(l == nullptr);
+		const String &a = *VariantGetInternalPtr<String>::get_ptr(left);
+
+		bool valid;
+		l->get(a, &valid);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = valid;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		bool valid;
+		PtrToArg<Object *>::convert(right)->get(PtrToArg<String>::convert(left), &valid);
+		PtrToArg<bool>::encode(valid, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+class OperatorEvaluatorObjectHasPropertyStringName {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		Object *b = p_right.get_validated_object();
+		if (!b) {
+			*r_ret = "Invalid base object for 'in'";
+			r_valid = false;
+			return;
+		}
+
+		const StringName &a = *VariantGetInternalPtr<StringName>::get_ptr(&p_left);
+
+		b->get(a, &r_valid);
+		*r_ret = r_valid;
+	}
+
+	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		Object *l = right->get_validated_object();
+		ERR_FAIL_COND(l == nullptr);
+		const StringName &a = *VariantGetInternalPtr<StringName>::get_ptr(left);
+
+		bool valid;
+		l->get(a, &valid);
+		VariantTypeChanger<bool>::change(r_ret);
+		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = valid;
+	}
+#ifdef PTRCALL_ENABLED
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		bool valid;
+		PtrToArg<Object *>::convert(right)->get(PtrToArg<StringName>::convert(left), &valid);
+		PtrToArg<bool>::encode(valid, r_ret);
+	}
+#endif
+	static Variant::Type get_return_type() { return Variant::BOOL; }
+};
+
+typedef void (*VariantEvaluatorFunction)(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid);
+
+static Variant::Type operator_return_type_table[Variant::OP_MAX][Variant::VARIANT_MAX][Variant::VARIANT_MAX];
+static VariantEvaluatorFunction operator_evaluator_table[Variant::OP_MAX][Variant::VARIANT_MAX][Variant::VARIANT_MAX];
+static Variant::ValidatedOperatorEvaluator validated_operator_evaluator_table[Variant::OP_MAX][Variant::VARIANT_MAX][Variant::VARIANT_MAX];
+#ifdef PTRCALL_ENABLED
+static Variant::PTROperatorEvaluator ptr_operator_evaluator_table[Variant::OP_MAX][Variant::VARIANT_MAX][Variant::VARIANT_MAX];
+#endif
+
+template <class T>
+void register_op(Variant::Operator p_op, Variant::Type p_type_a, Variant::Type p_type_b) {
+	operator_return_type_table[p_op][p_type_a][p_type_b] = T::get_return_type();
+	operator_evaluator_table[p_op][p_type_a][p_type_b] = T::evaluate;
+	validated_operator_evaluator_table[p_op][p_type_a][p_type_b] = T::validated_evaluate;
+#ifdef PTRCALL_ENABLED
+	ptr_operator_evaluator_table[p_op][p_type_a][p_type_b] = T::ptr_evaluate;
+#endif
+}
+
+void Variant::_register_variant_operators() {
+	zeromem(operator_return_type_table, sizeof(operator_return_type_table));
+	zeromem(operator_evaluator_table, sizeof(operator_evaluator_table));
+	zeromem(validated_operator_evaluator_table, sizeof(validated_operator_evaluator_table));
+#ifdef PTRCALL_ENABLED
+	zeromem(ptr_operator_evaluator_table, sizeof(ptr_operator_evaluator_table));
+#endif
+
+	register_op<OperatorEvaluatorAdd<int64_t, int64_t, int64_t>>(Variant::OP_ADD, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorAdd<double, int64_t, double>>(Variant::OP_ADD, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorAdd<double, double, int64_t>>(Variant::OP_ADD, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorAdd<double, double, double>>(Variant::OP_ADD, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorAdd<String, String, String>>(Variant::OP_ADD, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorAdd<Vector2, Vector2, Vector2>>(Variant::OP_ADD, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorAdd<Vector2i, Vector2i, Vector2i>>(Variant::OP_ADD, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorAdd<Vector3, Vector3, Vector3>>(Variant::OP_ADD, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorAdd<Vector3i, Vector3i, Vector3i>>(Variant::OP_ADD, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorAdd<Quat, Quat, Quat>>(Variant::OP_ADD, Variant::QUAT, Variant::QUAT);
+	register_op<OperatorEvaluatorAdd<Color, Color, Color>>(Variant::OP_ADD, Variant::COLOR, Variant::COLOR);
+	register_op<OperatorEvaluatorAddArray>(Variant::OP_ADD, Variant::ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorAppendArray<uint8_t>>(Variant::OP_ADD, Variant::PACKED_BYTE_ARRAY, Variant::PACKED_BYTE_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<int32_t>>(Variant::OP_ADD, Variant::PACKED_INT32_ARRAY, Variant::PACKED_INT32_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<int64_t>>(Variant::OP_ADD, Variant::PACKED_INT64_ARRAY, Variant::PACKED_INT64_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<float>>(Variant::OP_ADD, Variant::PACKED_FLOAT32_ARRAY, Variant::PACKED_FLOAT32_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<double>>(Variant::OP_ADD, Variant::PACKED_FLOAT64_ARRAY, Variant::PACKED_FLOAT64_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<String>>(Variant::OP_ADD, Variant::PACKED_STRING_ARRAY, Variant::PACKED_STRING_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<Vector2>>(Variant::OP_ADD, Variant::PACKED_VECTOR2_ARRAY, Variant::PACKED_VECTOR2_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<Vector3>>(Variant::OP_ADD, Variant::PACKED_VECTOR3_ARRAY, Variant::PACKED_VECTOR3_ARRAY);
+	register_op<OperatorEvaluatorAppendArray<Color>>(Variant::OP_ADD, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY);
+
+	register_op<OperatorEvaluatorSub<int64_t, int64_t, int64_t>>(Variant::OP_SUBTRACT, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorSub<double, int64_t, double>>(Variant::OP_SUBTRACT, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorSub<double, double, int64_t>>(Variant::OP_SUBTRACT, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorSub<double, double, double>>(Variant::OP_SUBTRACT, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorSub<Vector2, Vector2, Vector2>>(Variant::OP_SUBTRACT, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorSub<Vector2i, Vector2i, Vector2i>>(Variant::OP_SUBTRACT, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorSub<Vector3, Vector3, Vector3>>(Variant::OP_SUBTRACT, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorSub<Vector3i, Vector3i, Vector3i>>(Variant::OP_SUBTRACT, Variant::VECTOR3I, Variant::VECTOR3I);
+
+	register_op<OperatorEvaluatorMul<int64_t, int64_t, int64_t>>(Variant::OP_MULTIPLY, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorMul<double, int64_t, double>>(Variant::OP_MULTIPLY, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorMul<Vector2, int64_t, Vector2>>(Variant::OP_MULTIPLY, Variant::INT, Variant::VECTOR2);
+	register_op<OperatorEvaluatorMul<Vector2i, int64_t, Vector2i>>(Variant::OP_MULTIPLY, Variant::INT, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorMul<Vector3, int64_t, Vector3>>(Variant::OP_MULTIPLY, Variant::INT, Variant::VECTOR3);
+	register_op<OperatorEvaluatorMul<Vector3i, int64_t, Vector3i>>(Variant::OP_MULTIPLY, Variant::INT, Variant::VECTOR3I);
+
+	register_op<OperatorEvaluatorMul<double, double, double>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorMul<double, double, int64_t>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorMul<Vector2, double, Vector2>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::VECTOR2);
+	register_op<OperatorEvaluatorMul<Vector2i, double, Vector2i>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorMul<Vector3, double, Vector3>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::VECTOR3);
+	register_op<OperatorEvaluatorMul<Vector3i, double, Vector3i>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::VECTOR3I);
+
+	register_op<OperatorEvaluatorMul<Vector2, Vector2, Vector2>>(Variant::OP_MULTIPLY, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorMul<Vector2, Vector2, int64_t>>(Variant::OP_MULTIPLY, Variant::VECTOR2, Variant::INT);
+	register_op<OperatorEvaluatorMul<Vector2, Vector2, double>>(Variant::OP_MULTIPLY, Variant::VECTOR2, Variant::FLOAT);
+
+	register_op<OperatorEvaluatorMul<Vector2i, Vector2i, Vector2i>>(Variant::OP_MULTIPLY, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorMul<Vector2i, Vector2i, int64_t>>(Variant::OP_MULTIPLY, Variant::VECTOR2I, Variant::INT);
+	register_op<OperatorEvaluatorMul<Vector2i, Vector2i, double>>(Variant::OP_MULTIPLY, Variant::VECTOR2I, Variant::FLOAT);
+
+	register_op<OperatorEvaluatorMul<Vector3, Vector3, Vector3>>(Variant::OP_MULTIPLY, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorMul<Vector3, Vector3, int64_t>>(Variant::OP_MULTIPLY, Variant::VECTOR3, Variant::INT);
+	register_op<OperatorEvaluatorMul<Vector3, Vector3, double>>(Variant::OP_MULTIPLY, Variant::VECTOR3, Variant::FLOAT);
+
+	register_op<OperatorEvaluatorMul<Vector3i, Vector3i, Vector3i>>(Variant::OP_MULTIPLY, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorMul<Vector3i, Vector3i, int64_t>>(Variant::OP_MULTIPLY, Variant::VECTOR3I, Variant::INT);
+	register_op<OperatorEvaluatorMul<Vector3i, Vector3i, double>>(Variant::OP_MULTIPLY, Variant::VECTOR3I, Variant::FLOAT);
+
+	register_op<OperatorEvaluatorMul<Quat, Quat, Quat>>(Variant::OP_MULTIPLY, Variant::QUAT, Variant::QUAT);
+	register_op<OperatorEvaluatorMul<Quat, Quat, int64_t>>(Variant::OP_MULTIPLY, Variant::QUAT, Variant::INT);
+	register_op<OperatorEvaluatorMul<Quat, Quat, double>>(Variant::OP_MULTIPLY, Variant::QUAT, Variant::FLOAT);
+
+	register_op<OperatorEvaluatorMul<Color, Color, Color>>(Variant::OP_MULTIPLY, Variant::COLOR, Variant::COLOR);
+	register_op<OperatorEvaluatorMul<Color, Color, int64_t>>(Variant::OP_MULTIPLY, Variant::COLOR, Variant::INT);
+	register_op<OperatorEvaluatorMul<Color, Color, double>>(Variant::OP_MULTIPLY, Variant::COLOR, Variant::FLOAT);
+
+	register_op<OperatorEvaluatorMul<Transform2D, Transform2D, Transform2D>>(Variant::OP_MULTIPLY, Variant::TRANSFORM2D, Variant::TRANSFORM2D);
+	register_op<OperatorEvaluatorXForm<Vector2, Transform2D, Vector2>>(Variant::OP_MULTIPLY, Variant::TRANSFORM2D, Variant::VECTOR2);
+	register_op<OperatorEvaluatorXFormInv<Vector2, Vector2, Transform2D>>(Variant::OP_MULTIPLY, Variant::VECTOR2, Variant::TRANSFORM2D);
+	register_op<OperatorEvaluatorXForm<Rect2, Transform2D, Rect2>>(Variant::OP_MULTIPLY, Variant::TRANSFORM2D, Variant::RECT2);
+	register_op<OperatorEvaluatorXFormInv<Rect2, Rect2, Transform2D>>(Variant::OP_MULTIPLY, Variant::RECT2, Variant::TRANSFORM2D);
+	register_op<OperatorEvaluatorXForm<Vector<Vector2>, Transform2D, Vector<Vector2>>>(Variant::OP_MULTIPLY, Variant::TRANSFORM2D, Variant::PACKED_VECTOR2_ARRAY);
+	register_op<OperatorEvaluatorXFormInv<Vector<Vector2>, Vector<Vector2>, Transform2D>>(Variant::OP_MULTIPLY, Variant::PACKED_VECTOR2_ARRAY, Variant::TRANSFORM2D);
+
+	register_op<OperatorEvaluatorMul<Transform, Transform, Transform>>(Variant::OP_MULTIPLY, Variant::TRANSFORM, Variant::TRANSFORM);
+	register_op<OperatorEvaluatorXForm<Vector3, Transform, Vector3>>(Variant::OP_MULTIPLY, Variant::TRANSFORM, Variant::VECTOR3);
+	register_op<OperatorEvaluatorXFormInv<Vector3, Vector3, Transform>>(Variant::OP_MULTIPLY, Variant::VECTOR3, Variant::TRANSFORM);
+	register_op<OperatorEvaluatorXForm<::AABB, Transform, ::AABB>>(Variant::OP_MULTIPLY, Variant::TRANSFORM, Variant::AABB);
+	register_op<OperatorEvaluatorXFormInv<::AABB, ::AABB, Transform>>(Variant::OP_MULTIPLY, Variant::AABB, Variant::TRANSFORM);
+	register_op<OperatorEvaluatorXForm<Vector<Vector3>, Transform, Vector<Vector3>>>(Variant::OP_MULTIPLY, Variant::TRANSFORM, Variant::PACKED_VECTOR3_ARRAY);
+	register_op<OperatorEvaluatorXFormInv<Vector<Vector3>, Vector<Vector3>, Transform>>(Variant::OP_MULTIPLY, Variant::PACKED_VECTOR3_ARRAY, Variant::TRANSFORM);
+
+	register_op<OperatorEvaluatorMul<Basis, Basis, Basis>>(Variant::OP_MULTIPLY, Variant::BASIS, Variant::BASIS);
+	register_op<OperatorEvaluatorXForm<Vector3, Basis, Vector3>>(Variant::OP_MULTIPLY, Variant::BASIS, Variant::VECTOR3);
+	register_op<OperatorEvaluatorXFormInv<Vector3, Vector3, Basis>>(Variant::OP_MULTIPLY, Variant::VECTOR3, Variant::BASIS);
+
+	register_op<OperatorEvaluatorMul<Quat, Quat, Quat>>(Variant::OP_MULTIPLY, Variant::QUAT, Variant::QUAT);
+	register_op<OperatorEvaluatorMul<Quat, Quat, int64_t>>(Variant::OP_MULTIPLY, Variant::QUAT, Variant::INT);
+	register_op<OperatorEvaluatorMul<Quat, int64_t, Quat>>(Variant::OP_MULTIPLY, Variant::INT, Variant::QUAT);
+	register_op<OperatorEvaluatorMul<Quat, Quat, double>>(Variant::OP_MULTIPLY, Variant::QUAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorMul<Quat, double, Quat>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::QUAT);
+	register_op<OperatorEvaluatorXForm<Vector3, Quat, Vector3>>(Variant::OP_MULTIPLY, Variant::QUAT, Variant::VECTOR3);
+	register_op<OperatorEvaluatorXFormInv<Vector3, Vector3, Quat>>(Variant::OP_MULTIPLY, Variant::VECTOR3, Variant::QUAT);
+
+	register_op<OperatorEvaluatorMul<Color, Color, Color>>(Variant::OP_MULTIPLY, Variant::COLOR, Variant::COLOR);
+	register_op<OperatorEvaluatorMul<Color, Color, int64_t>>(Variant::OP_MULTIPLY, Variant::COLOR, Variant::INT);
+	register_op<OperatorEvaluatorMul<Color, int64_t, Color>>(Variant::OP_MULTIPLY, Variant::INT, Variant::COLOR);
+	register_op<OperatorEvaluatorMul<Color, Color, double>>(Variant::OP_MULTIPLY, Variant::COLOR, Variant::FLOAT);
+	register_op<OperatorEvaluatorMul<Color, double, Color>>(Variant::OP_MULTIPLY, Variant::FLOAT, Variant::COLOR);
+
+	register_op<OperatorEvaluatorDivNZ<int64_t, int64_t, int64_t>>(Variant::OP_DIVIDE, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorDiv<double, double, int64_t>>(Variant::OP_DIVIDE, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorDiv<double, int64_t, double>>(Variant::OP_DIVIDE, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorDiv<double, double, double>>(Variant::OP_DIVIDE, Variant::FLOAT, Variant::FLOAT);
+
+	register_op<OperatorEvaluatorDiv<Vector2, Vector2, Vector2>>(Variant::OP_DIVIDE, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorDiv<Vector2, Vector2, double>>(Variant::OP_DIVIDE, Variant::VECTOR2, Variant::FLOAT);
+	register_op<OperatorEvaluatorDiv<Vector2, Vector2, int64_t>>(Variant::OP_DIVIDE, Variant::VECTOR2, Variant::INT);
+
+	register_op<OperatorEvaluatorDiv<Vector2i, Vector2i, Vector2i>>(Variant::OP_DIVIDE, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorDivNZ<Vector2i, Vector2i, double>>(Variant::OP_DIVIDE, Variant::VECTOR2I, Variant::FLOAT);
+	register_op<OperatorEvaluatorDivNZ<Vector2i, Vector2i, int64_t>>(Variant::OP_DIVIDE, Variant::VECTOR2I, Variant::INT);
+
+	register_op<OperatorEvaluatorDiv<Vector2, Vector2, Vector2>>(Variant::OP_DIVIDE, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorDiv<Vector2, Vector2, double>>(Variant::OP_DIVIDE, Variant::VECTOR2, Variant::FLOAT);
+	register_op<OperatorEvaluatorDiv<Vector2, Vector2, int64_t>>(Variant::OP_DIVIDE, Variant::VECTOR2, Variant::INT);
+
+	register_op<OperatorEvaluatorDiv<Vector3, Vector3, Vector3>>(Variant::OP_DIVIDE, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorDiv<Vector3, Vector3, double>>(Variant::OP_DIVIDE, Variant::VECTOR3, Variant::FLOAT);
+	register_op<OperatorEvaluatorDiv<Vector3, Vector3, int64_t>>(Variant::OP_DIVIDE, Variant::VECTOR3, Variant::INT);
+
+	register_op<OperatorEvaluatorDiv<Vector3i, Vector3i, Vector3i>>(Variant::OP_DIVIDE, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorDivNZ<Vector3i, Vector3i, double>>(Variant::OP_DIVIDE, Variant::VECTOR3I, Variant::FLOAT);
+	register_op<OperatorEvaluatorDivNZ<Vector3i, Vector3i, int64_t>>(Variant::OP_DIVIDE, Variant::VECTOR3I, Variant::INT);
+
+	register_op<OperatorEvaluatorDiv<Quat, Quat, double>>(Variant::OP_DIVIDE, Variant::QUAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorDiv<Quat, Quat, int64_t>>(Variant::OP_DIVIDE, Variant::QUAT, Variant::INT);
+
+	register_op<OperatorEvaluatorDiv<Color, Color, Color>>(Variant::OP_DIVIDE, Variant::COLOR, Variant::COLOR);
+	register_op<OperatorEvaluatorDiv<Color, Color, double>>(Variant::OP_DIVIDE, Variant::COLOR, Variant::FLOAT);
+	register_op<OperatorEvaluatorDiv<Color, Color, int64_t>>(Variant::OP_DIVIDE, Variant::COLOR, Variant::INT);
+
+	register_op<OperatorEvaluatorModNZ<int64_t, int64_t, int64_t>>(Variant::OP_MODULE, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorMod<Vector2i, Vector2i, Vector2i>>(Variant::OP_MODULE, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorModNZ<Vector2i, Vector2i, int64_t>>(Variant::OP_MODULE, Variant::VECTOR2I, Variant::INT);
+
+	register_op<OperatorEvaluatorMod<Vector3i, Vector3i, Vector3i>>(Variant::OP_MODULE, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorModNZ<Vector3i, Vector3i, int64_t>>(Variant::OP_MODULE, Variant::VECTOR3I, Variant::INT);
+
+	register_op<OperatorEvaluatorStringModNil>(Variant::OP_MODULE, Variant::STRING, Variant::NIL);
+
+	register_op<OperatorEvaluatorStringModT<bool>>(Variant::OP_MODULE, Variant::STRING, Variant::BOOL);
+	register_op<OperatorEvaluatorStringModT<int64_t>>(Variant::OP_MODULE, Variant::STRING, Variant::INT);
+	register_op<OperatorEvaluatorStringModT<double>>(Variant::OP_MODULE, Variant::STRING, Variant::FLOAT);
+	register_op<OperatorEvaluatorStringModT<String>>(Variant::OP_MODULE, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorStringModT<Vector2>>(Variant::OP_MODULE, Variant::STRING, Variant::VECTOR2);
+	register_op<OperatorEvaluatorStringModT<Vector2i>>(Variant::OP_MODULE, Variant::STRING, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorStringModT<Rect2>>(Variant::OP_MODULE, Variant::STRING, Variant::RECT2);
+	register_op<OperatorEvaluatorStringModT<Rect2i>>(Variant::OP_MODULE, Variant::STRING, Variant::RECT2I);
+	register_op<OperatorEvaluatorStringModT<Vector3>>(Variant::OP_MODULE, Variant::STRING, Variant::VECTOR3);
+	register_op<OperatorEvaluatorStringModT<Vector3i>>(Variant::OP_MODULE, Variant::STRING, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorStringModT<Transform2D>>(Variant::OP_MODULE, Variant::STRING, Variant::TRANSFORM2D);
+	register_op<OperatorEvaluatorStringModT<Plane>>(Variant::OP_MODULE, Variant::STRING, Variant::PLANE);
+	register_op<OperatorEvaluatorStringModT<Quat>>(Variant::OP_MODULE, Variant::STRING, Variant::QUAT);
+	register_op<OperatorEvaluatorStringModT<::AABB>>(Variant::OP_MODULE, Variant::STRING, Variant::AABB);
+	register_op<OperatorEvaluatorStringModT<Basis>>(Variant::OP_MODULE, Variant::STRING, Variant::BASIS);
+	register_op<OperatorEvaluatorStringModT<Transform>>(Variant::OP_MODULE, Variant::STRING, Variant::TRANSFORM);
+
+	register_op<OperatorEvaluatorStringModT<Color>>(Variant::OP_MODULE, Variant::STRING, Variant::COLOR);
+	register_op<OperatorEvaluatorStringModT<StringName>>(Variant::OP_MODULE, Variant::STRING, Variant::STRING_NAME);
+	register_op<OperatorEvaluatorStringModT<NodePath>>(Variant::OP_MODULE, Variant::STRING, Variant::NODE_PATH);
+	register_op<OperatorEvaluatorStringModObject>(Variant::OP_MODULE, Variant::STRING, Variant::OBJECT);
+	register_op<OperatorEvaluatorStringModT<Callable>>(Variant::OP_MODULE, Variant::STRING, Variant::CALLABLE);
+	register_op<OperatorEvaluatorStringModT<Signal>>(Variant::OP_MODULE, Variant::STRING, Variant::SIGNAL);
+	register_op<OperatorEvaluatorStringModT<Dictionary>>(Variant::OP_MODULE, Variant::STRING, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorStringModArray>(Variant::OP_MODULE, Variant::STRING, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorStringModT<PackedByteArray>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_BYTE_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedInt32Array>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_INT32_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedInt64Array>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_INT64_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedFloat32Array>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_FLOAT32_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedFloat64Array>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_FLOAT64_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedStringArray>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_STRING_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedVector2Array>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_VECTOR2_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedVector3Array>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_VECTOR3_ARRAY);
+	register_op<OperatorEvaluatorStringModT<PackedColorArray>>(Variant::OP_MODULE, Variant::STRING, Variant::PACKED_COLOR_ARRAY);
+
+	register_op<OperatorEvaluatorNeg<int64_t, int64_t>>(Variant::OP_NEGATE, Variant::INT, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<double, double>>(Variant::OP_NEGATE, Variant::FLOAT, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<Vector2, Vector2>>(Variant::OP_NEGATE, Variant::VECTOR2, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<Vector2i, Vector2i>>(Variant::OP_NEGATE, Variant::VECTOR2I, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<Vector3, Vector3>>(Variant::OP_NEGATE, Variant::VECTOR3, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<Vector3i, Vector3i>>(Variant::OP_NEGATE, Variant::VECTOR3I, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<Quat, Quat>>(Variant::OP_NEGATE, Variant::QUAT, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<Plane, Plane>>(Variant::OP_NEGATE, Variant::PLANE, Variant::NIL);
+	register_op<OperatorEvaluatorNeg<Color, Color>>(Variant::OP_NEGATE, Variant::COLOR, Variant::NIL);
+
+	register_op<OperatorEvaluatorPos<int64_t, int64_t>>(Variant::OP_POSITIVE, Variant::INT, Variant::NIL);
+	register_op<OperatorEvaluatorPos<double, double>>(Variant::OP_POSITIVE, Variant::FLOAT, Variant::NIL);
+	register_op<OperatorEvaluatorPos<Vector2, Vector2>>(Variant::OP_POSITIVE, Variant::VECTOR2, Variant::NIL);
+	register_op<OperatorEvaluatorPos<Vector2i, Vector2i>>(Variant::OP_POSITIVE, Variant::VECTOR2I, Variant::NIL);
+	register_op<OperatorEvaluatorPos<Vector3, Vector3>>(Variant::OP_POSITIVE, Variant::VECTOR3, Variant::NIL);
+	register_op<OperatorEvaluatorPos<Vector3i, Vector3i>>(Variant::OP_POSITIVE, Variant::VECTOR3I, Variant::NIL);
+	register_op<OperatorEvaluatorPos<Quat, Quat>>(Variant::OP_POSITIVE, Variant::QUAT, Variant::NIL);
+	register_op<OperatorEvaluatorPos<Plane, Plane>>(Variant::OP_POSITIVE, Variant::PLANE, Variant::NIL);
+	register_op<OperatorEvaluatorPos<Color, Color>>(Variant::OP_POSITIVE, Variant::COLOR, Variant::NIL);
+
+	register_op<OperatorEvaluatorShiftLeft<int64_t, int64_t, int64_t>>(Variant::OP_SHIFT_LEFT, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorShiftRight<int64_t, int64_t, int64_t>>(Variant::OP_SHIFT_RIGHT, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorBitOr<int64_t, int64_t, int64_t>>(Variant::OP_BIT_OR, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorBitAnd<int64_t, int64_t, int64_t>>(Variant::OP_BIT_AND, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorBitXor<int64_t, int64_t, int64_t>>(Variant::OP_BIT_XOR, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorBitNeg<int64_t, int64_t>>(Variant::OP_BIT_NEGATE, Variant::INT, Variant::NIL);
+
+	register_op<OperatorEvaluatorBitNeg<int64_t, int64_t>>(Variant::OP_BIT_NEGATE, Variant::INT, Variant::NIL);
+
+	register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_EQUAL, Variant::NIL, Variant::NIL>>(Variant::OP_EQUAL, Variant::NIL, Variant::NIL);
+	register_op<OperatorEvaluatorEqual<bool, bool>>(Variant::OP_EQUAL, Variant::BOOL, Variant::BOOL);
+	register_op<OperatorEvaluatorEqual<int64_t, int64_t>>(Variant::OP_EQUAL, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorEqual<int64_t, double>>(Variant::OP_EQUAL, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorEqual<double, int64_t>>(Variant::OP_EQUAL, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorEqual<double, double>>(Variant::OP_EQUAL, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorEqual<String, String>>(Variant::OP_EQUAL, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorEqual<Vector2, Vector2>>(Variant::OP_EQUAL, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorEqual<Vector2i, Vector2i>>(Variant::OP_EQUAL, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorEqual<Rect2, Rect2>>(Variant::OP_EQUAL, Variant::RECT2, Variant::RECT2);
+	register_op<OperatorEvaluatorEqual<Rect2i, Rect2i>>(Variant::OP_EQUAL, Variant::RECT2I, Variant::RECT2I);
+	register_op<OperatorEvaluatorEqual<Vector3, Vector3>>(Variant::OP_EQUAL, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorEqual<Vector3i, Vector3i>>(Variant::OP_EQUAL, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorEqual<Transform2D, Transform2D>>(Variant::OP_EQUAL, Variant::TRANSFORM2D, Variant::TRANSFORM2D);
+	register_op<OperatorEvaluatorEqual<Plane, Plane>>(Variant::OP_EQUAL, Variant::PLANE, Variant::PLANE);
+	register_op<OperatorEvaluatorEqual<Quat, Quat>>(Variant::OP_EQUAL, Variant::QUAT, Variant::QUAT);
+	register_op<OperatorEvaluatorEqual<::AABB, ::AABB>>(Variant::OP_EQUAL, Variant::AABB, Variant::AABB);
+	register_op<OperatorEvaluatorEqual<Basis, Basis>>(Variant::OP_EQUAL, Variant::BASIS, Variant::BASIS);
+	register_op<OperatorEvaluatorEqual<Transform, Transform>>(Variant::OP_EQUAL, Variant::TRANSFORM, Variant::TRANSFORM);
+	register_op<OperatorEvaluatorEqual<Color, Color>>(Variant::OP_EQUAL, Variant::COLOR, Variant::COLOR);
+
+	register_op<OperatorEvaluatorEqual<StringName, String>>(Variant::OP_EQUAL, Variant::STRING_NAME, Variant::STRING);
+	register_op<OperatorEvaluatorEqual<String, StringName>>(Variant::OP_EQUAL, Variant::STRING, Variant::STRING_NAME);
+	register_op<OperatorEvaluatorEqual<StringName, StringName>>(Variant::OP_EQUAL, Variant::STRING_NAME, Variant::STRING_NAME);
+
+	register_op<OperatorEvaluatorEqual<NodePath, NodePath>>(Variant::OP_EQUAL, Variant::NODE_PATH, Variant::NODE_PATH);
+	register_op<OperatorEvaluatorEqual<::RID, ::RID>>(Variant::OP_EQUAL, Variant::RID, Variant::RID);
+
+	register_op<OperatorEvaluatorEqualObject>(Variant::OP_EQUAL, Variant::OBJECT, Variant::OBJECT);
+	register_op<OperatorEvaluatorEqualObjectNil>(Variant::OP_EQUAL, Variant::OBJECT, Variant::NIL);
+	register_op<OperatorEvaluatorEqualNilObject>(Variant::OP_EQUAL, Variant::NIL, Variant::OBJECT);
+
+	register_op<OperatorEvaluatorEqual<Callable, Callable>>(Variant::OP_EQUAL, Variant::CALLABLE, Variant::CALLABLE);
+	register_op<OperatorEvaluatorEqual<Signal, Signal>>(Variant::OP_EQUAL, Variant::SIGNAL, Variant::SIGNAL);
+	register_op<OperatorEvaluatorEqual<Dictionary, Dictionary>>(Variant::OP_EQUAL, Variant::DICTIONARY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorEqual<Array, Array>>(Variant::OP_EQUAL, Variant::ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedByteArray, PackedByteArray>>(Variant::OP_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::PACKED_BYTE_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedInt32Array, PackedInt32Array>>(Variant::OP_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::PACKED_INT32_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedInt64Array, PackedInt64Array>>(Variant::OP_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::PACKED_INT64_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedFloat32Array, PackedFloat32Array>>(Variant::OP_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::PACKED_FLOAT32_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedFloat64Array, PackedFloat64Array>>(Variant::OP_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::PACKED_FLOAT64_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedStringArray, PackedStringArray>>(Variant::OP_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::PACKED_STRING_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedVector2Array, PackedVector2Array>>(Variant::OP_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::PACKED_VECTOR2_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedVector3Array, PackedVector3Array>>(Variant::OP_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::PACKED_VECTOR3_ARRAY);
+	register_op<OperatorEvaluatorEqual<PackedColorArray, PackedColorArray>>(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY);
+
+	register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NIL);
+	register_op<OperatorEvaluatorNotEqual<bool, bool>>(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::BOOL);
+	register_op<OperatorEvaluatorNotEqual<int64_t, int64_t>>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorNotEqual<int64_t, double>>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorNotEqual<double, int64_t>>(Variant::OP_NOT_EQUAL, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorNotEqual<double, double>>(Variant::OP_NOT_EQUAL, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorNotEqual<String, String>>(Variant::OP_NOT_EQUAL, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorNotEqual<Vector2, Vector2>>(Variant::OP_NOT_EQUAL, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorNotEqual<Vector2i, Vector2i>>(Variant::OP_NOT_EQUAL, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorNotEqual<Rect2, Rect2>>(Variant::OP_NOT_EQUAL, Variant::RECT2, Variant::RECT2);
+	register_op<OperatorEvaluatorNotEqual<Rect2i, Rect2i>>(Variant::OP_NOT_EQUAL, Variant::RECT2I, Variant::RECT2I);
+	register_op<OperatorEvaluatorNotEqual<Vector3, Vector3>>(Variant::OP_NOT_EQUAL, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorNotEqual<Vector3i, Vector3i>>(Variant::OP_NOT_EQUAL, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorNotEqual<Transform2D, Transform2D>>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM2D, Variant::TRANSFORM2D);
+	register_op<OperatorEvaluatorNotEqual<Plane, Plane>>(Variant::OP_NOT_EQUAL, Variant::PLANE, Variant::PLANE);
+	register_op<OperatorEvaluatorNotEqual<Quat, Quat>>(Variant::OP_NOT_EQUAL, Variant::QUAT, Variant::QUAT);
+	register_op<OperatorEvaluatorNotEqual<::AABB, ::AABB>>(Variant::OP_NOT_EQUAL, Variant::AABB, Variant::AABB);
+	register_op<OperatorEvaluatorNotEqual<Basis, Basis>>(Variant::OP_NOT_EQUAL, Variant::BASIS, Variant::BASIS);
+	register_op<OperatorEvaluatorNotEqual<Transform, Transform>>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM, Variant::TRANSFORM);
+	register_op<OperatorEvaluatorNotEqual<Color, Color>>(Variant::OP_NOT_EQUAL, Variant::COLOR, Variant::COLOR);
+
+	register_op<OperatorEvaluatorNotEqual<StringName, String>>(Variant::OP_NOT_EQUAL, Variant::STRING_NAME, Variant::STRING);
+	register_op<OperatorEvaluatorNotEqual<String, StringName>>(Variant::OP_NOT_EQUAL, Variant::STRING, Variant::STRING_NAME);
+	register_op<OperatorEvaluatorNotEqual<StringName, StringName>>(Variant::OP_NOT_EQUAL, Variant::STRING_NAME, Variant::STRING_NAME);
+
+	register_op<OperatorEvaluatorNotEqual<NodePath, NodePath>>(Variant::OP_NOT_EQUAL, Variant::NODE_PATH, Variant::NODE_PATH);
+	register_op<OperatorEvaluatorNotEqual<::RID, ::RID>>(Variant::OP_NOT_EQUAL, Variant::RID, Variant::RID);
+
+	register_op<OperatorEvaluatorNotEqualObject>(Variant::OP_NOT_EQUAL, Variant::OBJECT, Variant::OBJECT);
+	register_op<OperatorEvaluatorNotEqualObjectNil>(Variant::OP_NOT_EQUAL, Variant::OBJECT, Variant::NIL);
+	register_op<OperatorEvaluatorNotEqualNilObject>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::OBJECT);
+
+	register_op<OperatorEvaluatorNotEqual<Callable, Callable>>(Variant::OP_NOT_EQUAL, Variant::CALLABLE, Variant::CALLABLE);
+	register_op<OperatorEvaluatorNotEqual<Signal, Signal>>(Variant::OP_NOT_EQUAL, Variant::SIGNAL, Variant::SIGNAL);
+	register_op<OperatorEvaluatorNotEqual<Dictionary, Dictionary>>(Variant::OP_NOT_EQUAL, Variant::DICTIONARY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorNotEqual<Array, Array>>(Variant::OP_NOT_EQUAL, Variant::ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedByteArray, PackedByteArray>>(Variant::OP_NOT_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::PACKED_BYTE_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedInt32Array, PackedInt32Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::PACKED_INT32_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedInt64Array, PackedInt64Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::PACKED_INT64_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedFloat32Array, PackedFloat32Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::PACKED_FLOAT32_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedFloat64Array, PackedFloat64Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::PACKED_FLOAT64_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedStringArray, PackedStringArray>>(Variant::OP_NOT_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::PACKED_STRING_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedVector2Array, PackedVector2Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::PACKED_VECTOR2_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedVector3Array, PackedVector3Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::PACKED_VECTOR3_ARRAY);
+	register_op<OperatorEvaluatorNotEqual<PackedColorArray, PackedColorArray>>(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY);
+
+	register_op<OperatorEvaluatorLess<bool, bool>>(Variant::OP_LESS, Variant::BOOL, Variant::BOOL);
+	register_op<OperatorEvaluatorLess<int64_t, int64_t>>(Variant::OP_LESS, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorLess<int64_t, double>>(Variant::OP_LESS, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorLess<double, int64_t>>(Variant::OP_LESS, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorLess<double, double>>(Variant::OP_LESS, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorLess<String, String>>(Variant::OP_LESS, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorLess<Vector2, Vector2>>(Variant::OP_LESS, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorLess<Vector2i, Vector2i>>(Variant::OP_LESS, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorLess<Vector3, Vector3>>(Variant::OP_LESS, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorLess<Vector3i, Vector3i>>(Variant::OP_LESS, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorLess<::RID, ::RID>>(Variant::OP_LESS, Variant::RID, Variant::RID);
+	register_op<OperatorEvaluatorLess<Array, Array>>(Variant::OP_LESS, Variant::ARRAY, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorLessEqual<int64_t, int64_t>>(Variant::OP_LESS_EQUAL, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorLessEqual<int64_t, double>>(Variant::OP_LESS_EQUAL, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorLessEqual<double, int64_t>>(Variant::OP_LESS_EQUAL, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorLessEqual<double, double>>(Variant::OP_LESS_EQUAL, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorLessEqual<String, String>>(Variant::OP_LESS_EQUAL, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorLessEqual<Vector2, Vector2>>(Variant::OP_LESS_EQUAL, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorLessEqual<Vector2i, Vector2i>>(Variant::OP_LESS_EQUAL, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorLessEqual<Vector3, Vector3>>(Variant::OP_LESS_EQUAL, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorLessEqual<Vector3i, Vector3i>>(Variant::OP_LESS_EQUAL, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorLessEqual<::RID, ::RID>>(Variant::OP_LESS_EQUAL, Variant::RID, Variant::RID);
+	register_op<OperatorEvaluatorLessEqual<Array, Array>>(Variant::OP_LESS_EQUAL, Variant::ARRAY, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorGreater<bool, bool>>(Variant::OP_GREATER, Variant::BOOL, Variant::BOOL);
+	register_op<OperatorEvaluatorGreater<int64_t, int64_t>>(Variant::OP_GREATER, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorGreater<int64_t, double>>(Variant::OP_GREATER, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorGreater<double, int64_t>>(Variant::OP_GREATER, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorGreater<double, double>>(Variant::OP_GREATER, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorGreater<String, String>>(Variant::OP_GREATER, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorGreater<Vector2, Vector2>>(Variant::OP_GREATER, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorGreater<Vector2i, Vector2i>>(Variant::OP_GREATER, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorGreater<Vector3, Vector3>>(Variant::OP_GREATER, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorGreater<Vector3i, Vector3i>>(Variant::OP_GREATER, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorGreater<::RID, ::RID>>(Variant::OP_GREATER, Variant::RID, Variant::RID);
+	register_op<OperatorEvaluatorGreater<Array, Array>>(Variant::OP_GREATER, Variant::ARRAY, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorGreaterEqual<int64_t, int64_t>>(Variant::OP_GREATER_EQUAL, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorGreaterEqual<int64_t, double>>(Variant::OP_GREATER_EQUAL, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorGreaterEqual<double, int64_t>>(Variant::OP_GREATER_EQUAL, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorGreaterEqual<double, double>>(Variant::OP_GREATER_EQUAL, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorGreaterEqual<String, String>>(Variant::OP_GREATER_EQUAL, Variant::STRING, Variant::STRING);
+	register_op<OperatorEvaluatorGreaterEqual<Vector2, Vector2>>(Variant::OP_GREATER_EQUAL, Variant::VECTOR2, Variant::VECTOR2);
+	register_op<OperatorEvaluatorGreaterEqual<Vector2i, Vector2i>>(Variant::OP_GREATER_EQUAL, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorGreaterEqual<Vector3, Vector3>>(Variant::OP_GREATER_EQUAL, Variant::VECTOR3, Variant::VECTOR3);
+	register_op<OperatorEvaluatorGreaterEqual<Vector3i, Vector3i>>(Variant::OP_GREATER_EQUAL, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorGreaterEqual<::RID, ::RID>>(Variant::OP_GREATER_EQUAL, Variant::RID, Variant::RID);
+	register_op<OperatorEvaluatorGreaterEqual<Array, Array>>(Variant::OP_GREATER_EQUAL, Variant::ARRAY, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_OR, Variant::NIL, Variant::NIL>>(Variant::OP_OR, Variant::NIL, Variant::NIL);
+
+	//OR
+	register_op<OperatorEvaluatorNilXBoolOr>(Variant::OP_OR, Variant::NIL, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXNilOr>(Variant::OP_OR, Variant::BOOL, Variant::NIL);
+	register_op<OperatorEvaluatorNilXIntOr>(Variant::OP_OR, Variant::NIL, Variant::INT);
+	register_op<OperatorEvaluatorIntXNilOr>(Variant::OP_OR, Variant::INT, Variant::NIL);
+	register_op<OperatorEvaluatorNilXFloatOr>(Variant::OP_OR, Variant::NIL, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXNilOr>(Variant::OP_OR, Variant::FLOAT, Variant::NIL);
+	register_op<OperatorEvaluatorNilXObjectOr>(Variant::OP_OR, Variant::NIL, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXNilOr>(Variant::OP_OR, Variant::OBJECT, Variant::NIL);
+
+	register_op<OperatorEvaluatorBoolXBoolOr>(Variant::OP_OR, Variant::BOOL, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXIntOr>(Variant::OP_OR, Variant::BOOL, Variant::INT);
+	register_op<OperatorEvaluatorIntXBoolOr>(Variant::OP_OR, Variant::INT, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXFloatOr>(Variant::OP_OR, Variant::BOOL, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXBoolOr>(Variant::OP_OR, Variant::FLOAT, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXObjectOr>(Variant::OP_OR, Variant::BOOL, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXBoolOr>(Variant::OP_OR, Variant::OBJECT, Variant::BOOL);
+
+	register_op<OperatorEvaluatorIntXIntOr>(Variant::OP_OR, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorIntXFloatOr>(Variant::OP_OR, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXIntOr>(Variant::OP_OR, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorIntXObjectOr>(Variant::OP_OR, Variant::INT, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXIntOr>(Variant::OP_OR, Variant::OBJECT, Variant::INT);
+
+	register_op<OperatorEvaluatorFloatXFloatOr>(Variant::OP_OR, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXObjectOr>(Variant::OP_OR, Variant::FLOAT, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXFloatOr>(Variant::OP_OR, Variant::OBJECT, Variant::FLOAT);
+	register_op<OperatorEvaluatorObjectXObjectOr>(Variant::OP_OR, Variant::OBJECT, Variant::OBJECT);
+	//AND
+	register_op<OperatorEvaluatorNilXBoolAnd>(Variant::OP_AND, Variant::NIL, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXNilAnd>(Variant::OP_AND, Variant::BOOL, Variant::NIL);
+	register_op<OperatorEvaluatorNilXIntAnd>(Variant::OP_AND, Variant::NIL, Variant::INT);
+	register_op<OperatorEvaluatorIntXNilAnd>(Variant::OP_AND, Variant::INT, Variant::NIL);
+	register_op<OperatorEvaluatorNilXFloatAnd>(Variant::OP_AND, Variant::NIL, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXNilAnd>(Variant::OP_AND, Variant::FLOAT, Variant::NIL);
+	register_op<OperatorEvaluatorNilXObjectAnd>(Variant::OP_AND, Variant::NIL, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXNilAnd>(Variant::OP_AND, Variant::OBJECT, Variant::NIL);
+
+	register_op<OperatorEvaluatorBoolXBoolAnd>(Variant::OP_AND, Variant::BOOL, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXIntAnd>(Variant::OP_AND, Variant::BOOL, Variant::INT);
+	register_op<OperatorEvaluatorIntXBoolAnd>(Variant::OP_AND, Variant::INT, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXFloatAnd>(Variant::OP_AND, Variant::BOOL, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXBoolAnd>(Variant::OP_AND, Variant::FLOAT, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXObjectAnd>(Variant::OP_AND, Variant::BOOL, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXBoolAnd>(Variant::OP_AND, Variant::OBJECT, Variant::BOOL);
+
+	register_op<OperatorEvaluatorIntXIntAnd>(Variant::OP_AND, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorIntXFloatAnd>(Variant::OP_AND, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXIntAnd>(Variant::OP_AND, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorIntXObjectAnd>(Variant::OP_AND, Variant::INT, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXIntAnd>(Variant::OP_AND, Variant::OBJECT, Variant::INT);
+
+	register_op<OperatorEvaluatorFloatXFloatAnd>(Variant::OP_AND, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXObjectAnd>(Variant::OP_AND, Variant::FLOAT, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXFloatAnd>(Variant::OP_AND, Variant::OBJECT, Variant::FLOAT);
+	register_op<OperatorEvaluatorObjectXObjectAnd>(Variant::OP_AND, Variant::OBJECT, Variant::OBJECT);
+	//XOR
+	register_op<OperatorEvaluatorNilXBoolXor>(Variant::OP_XOR, Variant::NIL, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXNilXor>(Variant::OP_XOR, Variant::BOOL, Variant::NIL);
+	register_op<OperatorEvaluatorNilXIntXor>(Variant::OP_XOR, Variant::NIL, Variant::INT);
+	register_op<OperatorEvaluatorIntXNilXor>(Variant::OP_XOR, Variant::INT, Variant::NIL);
+	register_op<OperatorEvaluatorNilXFloatXor>(Variant::OP_XOR, Variant::NIL, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXNilXor>(Variant::OP_XOR, Variant::FLOAT, Variant::NIL);
+	register_op<OperatorEvaluatorNilXObjectXor>(Variant::OP_XOR, Variant::NIL, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXNilXor>(Variant::OP_XOR, Variant::OBJECT, Variant::NIL);
+
+	register_op<OperatorEvaluatorBoolXBoolXor>(Variant::OP_XOR, Variant::BOOL, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXIntXor>(Variant::OP_XOR, Variant::BOOL, Variant::INT);
+	register_op<OperatorEvaluatorIntXBoolXor>(Variant::OP_XOR, Variant::INT, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXFloatXor>(Variant::OP_XOR, Variant::BOOL, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXBoolXor>(Variant::OP_XOR, Variant::FLOAT, Variant::BOOL);
+	register_op<OperatorEvaluatorBoolXObjectXor>(Variant::OP_XOR, Variant::BOOL, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXBoolXor>(Variant::OP_XOR, Variant::OBJECT, Variant::BOOL);
+
+	register_op<OperatorEvaluatorIntXIntXor>(Variant::OP_XOR, Variant::INT, Variant::INT);
+	register_op<OperatorEvaluatorIntXFloatXor>(Variant::OP_XOR, Variant::INT, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXIntXor>(Variant::OP_XOR, Variant::FLOAT, Variant::INT);
+	register_op<OperatorEvaluatorIntXObjectXor>(Variant::OP_XOR, Variant::INT, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXIntXor>(Variant::OP_XOR, Variant::OBJECT, Variant::INT);
+
+	register_op<OperatorEvaluatorFloatXFloatXor>(Variant::OP_XOR, Variant::FLOAT, Variant::FLOAT);
+	register_op<OperatorEvaluatorFloatXObjectXor>(Variant::OP_XOR, Variant::FLOAT, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectXFloatXor>(Variant::OP_XOR, Variant::OBJECT, Variant::FLOAT);
+	register_op<OperatorEvaluatorObjectXObjectXor>(Variant::OP_XOR, Variant::OBJECT, Variant::OBJECT);
+
+	register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT, Variant::NIL, Variant::NIL>>(Variant::OP_NOT, Variant::NIL, Variant::NIL);
+	register_op<OperatorEvaluatorNotBool>(Variant::OP_NOT, Variant::BOOL, Variant::NIL);
+	register_op<OperatorEvaluatorNotInt>(Variant::OP_NOT, Variant::INT, Variant::NIL);
+	register_op<OperatorEvaluatorNotFloat>(Variant::OP_NOT, Variant::FLOAT, Variant::NIL);
+	register_op<OperatorEvaluatorNotObject>(Variant::OP_NOT, Variant::OBJECT, Variant::NIL);
+
+	register_op<OperatorEvaluatorInStringFind>(Variant::OP_IN, Variant::STRING, Variant::STRING);
+
+	register_op<OperatorEvaluatorInDictionaryHasNil>(Variant::OP_IN, Variant::NIL, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<bool>>(Variant::OP_IN, Variant::BOOL, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<int64_t>>(Variant::OP_IN, Variant::INT, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<double>>(Variant::OP_IN, Variant::FLOAT, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<String>>(Variant::OP_IN, Variant::STRING, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Vector2>>(Variant::OP_IN, Variant::VECTOR2, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Vector2i>>(Variant::OP_IN, Variant::VECTOR2I, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Rect2>>(Variant::OP_IN, Variant::RECT2, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Rect2i>>(Variant::OP_IN, Variant::RECT2I, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Vector3>>(Variant::OP_IN, Variant::VECTOR3, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Vector3i>>(Variant::OP_IN, Variant::VECTOR3I, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Transform2D>>(Variant::OP_IN, Variant::TRANSFORM2D, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Plane>>(Variant::OP_IN, Variant::PLANE, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Quat>>(Variant::OP_IN, Variant::QUAT, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<::AABB>>(Variant::OP_IN, Variant::AABB, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Basis>>(Variant::OP_IN, Variant::BASIS, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Transform>>(Variant::OP_IN, Variant::TRANSFORM, Variant::DICTIONARY);
+
+	register_op<OperatorEvaluatorInDictionaryHas<Color>>(Variant::OP_IN, Variant::COLOR, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<StringName>>(Variant::OP_IN, Variant::STRING_NAME, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<NodePath>>(Variant::OP_IN, Variant::NODE_PATH, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHasObject>(Variant::OP_IN, Variant::OBJECT, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Callable>>(Variant::OP_IN, Variant::CALLABLE, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Signal>>(Variant::OP_IN, Variant::SIGNAL, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Dictionary>>(Variant::OP_IN, Variant::DICTIONARY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<Array>>(Variant::OP_IN, Variant::ARRAY, Variant::DICTIONARY);
+
+	register_op<OperatorEvaluatorInDictionaryHas<PackedByteArray>>(Variant::OP_IN, Variant::PACKED_BYTE_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedInt32Array>>(Variant::OP_IN, Variant::PACKED_INT32_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedInt64Array>>(Variant::OP_IN, Variant::PACKED_INT64_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedFloat32Array>>(Variant::OP_IN, Variant::PACKED_FLOAT32_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedFloat64Array>>(Variant::OP_IN, Variant::PACKED_FLOAT64_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedStringArray>>(Variant::OP_IN, Variant::PACKED_STRING_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedVector2Array>>(Variant::OP_IN, Variant::PACKED_VECTOR2_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedVector3Array>>(Variant::OP_IN, Variant::PACKED_VECTOR3_ARRAY, Variant::DICTIONARY);
+	register_op<OperatorEvaluatorInDictionaryHas<PackedColorArray>>(Variant::OP_IN, Variant::PACKED_COLOR_ARRAY, Variant::DICTIONARY);
+
+	register_op<OperatorEvaluatorInArrayFindNil>(Variant::OP_IN, Variant::NIL, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<bool, Array>>(Variant::OP_IN, Variant::BOOL, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<int64_t, Array>>(Variant::OP_IN, Variant::INT, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<double, Array>>(Variant::OP_IN, Variant::FLOAT, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<String, Array>>(Variant::OP_IN, Variant::STRING, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Vector2, Array>>(Variant::OP_IN, Variant::VECTOR2, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Vector2i, Array>>(Variant::OP_IN, Variant::VECTOR2I, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Rect2, Array>>(Variant::OP_IN, Variant::RECT2, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Rect2i, Array>>(Variant::OP_IN, Variant::RECT2I, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Vector3, Array>>(Variant::OP_IN, Variant::VECTOR3, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Vector3i, Array>>(Variant::OP_IN, Variant::VECTOR3I, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Transform2D, Array>>(Variant::OP_IN, Variant::TRANSFORM2D, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Plane, Array>>(Variant::OP_IN, Variant::PLANE, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Quat, Array>>(Variant::OP_IN, Variant::QUAT, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<::AABB, Array>>(Variant::OP_IN, Variant::AABB, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Basis, Array>>(Variant::OP_IN, Variant::BASIS, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Transform, Array>>(Variant::OP_IN, Variant::TRANSFORM, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<Color, Array>>(Variant::OP_IN, Variant::COLOR, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<StringName, Array>>(Variant::OP_IN, Variant::STRING_NAME, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<NodePath, Array>>(Variant::OP_IN, Variant::NODE_PATH, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFindObject>(Variant::OP_IN, Variant::OBJECT, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Callable, Array>>(Variant::OP_IN, Variant::CALLABLE, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Signal, Array>>(Variant::OP_IN, Variant::SIGNAL, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Dictionary, Array>>(Variant::OP_IN, Variant::DICTIONARY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Array, Array>>(Variant::OP_IN, Variant::ARRAY, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<PackedByteArray, Array>>(Variant::OP_IN, Variant::PACKED_BYTE_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedInt32Array, Array>>(Variant::OP_IN, Variant::PACKED_INT32_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedInt64Array, Array>>(Variant::OP_IN, Variant::PACKED_INT64_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedFloat32Array, Array>>(Variant::OP_IN, Variant::PACKED_FLOAT32_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedFloat64Array, Array>>(Variant::OP_IN, Variant::PACKED_FLOAT64_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedStringArray, Array>>(Variant::OP_IN, Variant::PACKED_STRING_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedVector2Array, Array>>(Variant::OP_IN, Variant::PACKED_VECTOR2_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedVector3Array, Array>>(Variant::OP_IN, Variant::PACKED_VECTOR3_ARRAY, Variant::ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<PackedColorArray, Array>>(Variant::OP_IN, Variant::PACKED_COLOR_ARRAY, Variant::ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<int, PackedByteArray>>(Variant::OP_IN, Variant::INT, Variant::PACKED_BYTE_ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<float, PackedByteArray>>(Variant::OP_IN, Variant::FLOAT, Variant::PACKED_BYTE_ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<int, PackedInt32Array>>(Variant::OP_IN, Variant::INT, Variant::PACKED_INT32_ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<float, PackedInt32Array>>(Variant::OP_IN, Variant::FLOAT, Variant::PACKED_INT32_ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<int, PackedInt64Array>>(Variant::OP_IN, Variant::INT, Variant::PACKED_INT64_ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<float, PackedInt64Array>>(Variant::OP_IN, Variant::FLOAT, Variant::PACKED_INT64_ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<int, PackedFloat32Array>>(Variant::OP_IN, Variant::INT, Variant::PACKED_FLOAT32_ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<float, PackedFloat32Array>>(Variant::OP_IN, Variant::FLOAT, Variant::PACKED_FLOAT32_ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<int, PackedFloat64Array>>(Variant::OP_IN, Variant::INT, Variant::PACKED_FLOAT64_ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<float, PackedFloat64Array>>(Variant::OP_IN, Variant::FLOAT, Variant::PACKED_FLOAT64_ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<String, PackedStringArray>>(Variant::OP_IN, Variant::STRING, Variant::PACKED_STRING_ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<Vector2, PackedVector2Array>>(Variant::OP_IN, Variant::VECTOR2, Variant::PACKED_VECTOR2_ARRAY);
+	register_op<OperatorEvaluatorInArrayFind<Vector3, PackedVector3Array>>(Variant::OP_IN, Variant::VECTOR3, Variant::PACKED_VECTOR3_ARRAY);
+
+	register_op<OperatorEvaluatorInArrayFind<Color, PackedColorArray>>(Variant::OP_IN, Variant::COLOR, Variant::PACKED_COLOR_ARRAY);
+
+	register_op<OperatorEvaluatorObjectHasPropertyString>(Variant::OP_IN, Variant::STRING, Variant::OBJECT);
+	register_op<OperatorEvaluatorObjectHasPropertyStringName>(Variant::OP_IN, Variant::STRING_NAME, Variant::OBJECT);
+}
+
+void Variant::_unregister_variant_operators() {
+}
+
+void Variant::evaluate(const Operator &p_op, const Variant &p_a,
+		const Variant &p_b, Variant &r_ret, bool &r_valid) {
+	ERR_FAIL_INDEX(p_op, Variant::OP_MAX);
+	Variant::Type type_a = p_a.get_type();
+	Variant::Type type_b = p_b.get_type();
+	ERR_FAIL_INDEX(type_a, Variant::VARIANT_MAX);
+	ERR_FAIL_INDEX(type_b, Variant::VARIANT_MAX);
+
+	VariantEvaluatorFunction ev = operator_evaluator_table[p_op][type_a][type_b];
+	if (unlikely(!ev)) {
+		r_valid = false;
+		r_ret = Variant();
+		return;
+	}
+
+	ev(p_a, p_b, &r_ret, r_valid);
+}
+
+Variant::Type Variant::get_operator_return_type(Operator p_operator, Type p_type_a, Type p_type_b) {
+	ERR_FAIL_INDEX_V(p_operator, Variant::OP_MAX, Variant::NIL);
+	ERR_FAIL_INDEX_V(p_type_a, Variant::VARIANT_MAX, Variant::NIL);
+	ERR_FAIL_INDEX_V(p_type_b, Variant::VARIANT_MAX, Variant::NIL);
+
+	return operator_return_type_table[p_operator][p_type_a][p_type_b];
+}
+
+Variant::ValidatedOperatorEvaluator Variant::get_validated_operator_evaluator(Operator p_operator, Type p_type_a, Type p_type_b) {
+	ERR_FAIL_INDEX_V(p_operator, Variant::OP_MAX, nullptr);
+	ERR_FAIL_INDEX_V(p_type_a, Variant::VARIANT_MAX, nullptr);
+	ERR_FAIL_INDEX_V(p_type_b, Variant::VARIANT_MAX, nullptr);
+	return validated_operator_evaluator_table[p_operator][p_type_a][p_type_b];
+}
+#ifdef PTRCALL_ENABLED
+Variant::PTROperatorEvaluator Variant::get_ptr_operator_evaluator(Operator p_operator, Type p_type_a, Type p_type_b) {
+	ERR_FAIL_INDEX_V(p_operator, Variant::OP_MAX, nullptr);
+	ERR_FAIL_INDEX_V(p_type_a, Variant::VARIANT_MAX, nullptr);
+	ERR_FAIL_INDEX_V(p_type_b, Variant::VARIANT_MAX, nullptr);
+	return ptr_operator_evaluator_table[p_operator][p_type_a][p_type_b];
+}
+
+#endif
+
+static const char *_op_names[Variant::OP_MAX] = {
+	"==",
+	"!=",
+	"<",
+	"<=",
+	">",
+	">=",
+	"+",
+	"-",
+	"*",
+	"/",
+	"-",
+	"+",
+	"%",
+	"<<",
+	">>",
+	"&",
+	"|",
+	"^",
+	"~",
+	"and",
+	"or",
+	"xor",
+	"not",
+	"in"
+
+};
+
+String Variant::get_operator_name(Operator p_op) {
+	ERR_FAIL_INDEX_V(p_op, OP_MAX, "");
+	return _op_names[p_op];
+}
+
+Variant::operator bool() const {
+	return booleanize();
+}
+
+// We consider all uninitialized or empty types to be false based on the type's
+// zeroiness.
+bool Variant::booleanize() const {
+	return !is_zero();
+}
+
+bool Variant::in(const Variant &p_index, bool *r_valid) const {
+	bool valid;
+	Variant ret;
+	evaluate(OP_IN, p_index, *this, ret, valid);
+	if (r_valid) {
+		*r_valid = valid;
+		return false;
+	}
+	ERR_FAIL_COND_V(ret.type != BOOL, false);
+	return *VariantGetInternalPtr<bool>::get_ptr(&ret);
+}
diff --git a/core/variant_parser.cpp b/core/variant/variant_parser.cpp
index 04cd4c1b9b..5a0bbf041b 100644
--- a/core/variant_parser.cpp
+++ b/core/variant/variant_parser.cpp
@@ -33,7 +33,7 @@
 #include "core/input/input_event.h"
 #include "core/io/resource_loader.h"
 #include "core/os/keyboard.h"
-#include "core/string_buffer.h"
+#include "core/string/string_buffer.h"
 
 char32_t VariantParser::StreamFile::get_char() {
 	return f->get_8();
diff --git a/core/variant_parser.h b/core/variant/variant_parser.h
index 12329e2db6..59d18a8b9f 100644
--- a/core/variant_parser.h
+++ b/core/variant/variant_parser.h
@@ -31,9 +31,9 @@
 #ifndef VARIANT_PARSER_H
 #define VARIANT_PARSER_H
 
+#include "core/io/resource.h"
 #include "core/os/file_access.h"
-#include "core/resource.h"
-#include "core/variant.h"
+#include "core/variant/variant.h"
 
 class VariantParser {
 public:
diff --git a/core/variant/variant_setget.cpp b/core/variant/variant_setget.cpp
new file mode 100644
index 0000000000..05fe2b80d9
--- /dev/null
+++ b/core/variant/variant_setget.cpp
@@ -0,0 +1,2587 @@
+/*************************************************************************/
+/*  variant_setget.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "variant.h"
+
+#include "core/core_string_names.h"
+#include "core/debugger/engine_debugger.h"
+#include "core/object/class_db.h"
+#include "core/templates/local_vector.h"
+#include "core/variant/variant_internal.h"
+
+/**** NAMED SETTERS AND GETTERS ****/
+
+#define SETGET_STRUCT(m_base_type, m_member_type, m_member)                                                                          \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                                \
+		static void get(const Variant *base, Variant *member) {                                                                      \
+			*member = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member;                                                   \
+		}                                                                                                                            \
+		static void validated_get(const Variant *base, Variant *member) {                                                            \
+			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member;    \
+		}                                                                                                                            \
+		static void ptr_get(const void *base, void *member) {                                                                        \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                                  \
+		}                                                                                                                            \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                          \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                     \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
+				valid = true;                                                                                                        \
+			} else {                                                                                                                 \
+				valid = false;                                                                                                       \
+			}                                                                                                                        \
+		}                                                                                                                            \
+		static void validated_set(Variant *base, const Variant *value) {                                                             \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value);     \
+		}                                                                                                                            \
+		static void ptr_set(void *base, const void *member) {                                                                        \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                    \
+			b.m_member = PtrToArg<m_member_type>::convert(member);                                                                   \
+			PtrToArg<m_base_type>::encode(b, base);                                                                                  \
+		}                                                                                                                            \
+		static Variant::Type get_type() { return GetTypeInfo<m_member_type>::VARIANT_TYPE; }                                         \
+	};
+
+#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member)                                                                \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                             \
+		static void get(const Variant *base, Variant *member) {                                                                   \
+			*member = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member;                                                \
+		}                                                                                                                         \
+		static void validated_get(const Variant *base, Variant *member) {                                                         \
+			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
+		}                                                                                                                         \
+		static void ptr_get(const void *base, void *member) {                                                                     \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                               \
+		}                                                                                                                         \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                       \
+			if (value->get_type() == Variant::FLOAT) {                                                                            \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<double>::get_ptr(value);     \
+				valid = true;                                                                                                     \
+			} else if (value->get_type() == Variant::INT) {                                                                       \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<int64_t>::get_ptr(value);    \
+				valid = true;                                                                                                     \
+			} else {                                                                                                              \
+				valid = false;                                                                                                    \
+			}                                                                                                                     \
+		}                                                                                                                         \
+		static void validated_set(Variant *base, const Variant *value) {                                                          \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value);  \
+		}                                                                                                                         \
+		static void ptr_set(void *base, const void *member) {                                                                     \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                 \
+			b.m_member = PtrToArg<m_member_type>::convert(member);                                                                \
+			PtrToArg<m_base_type>::encode(b, base);                                                                               \
+		}                                                                                                                         \
+		static Variant::Type get_type() { return GetTypeInfo<m_member_type>::VARIANT_TYPE; }                                      \
+	};
+
+#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                                         \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                                \
+		static void get(const Variant *base, Variant *member) {                                                                      \
+			*member = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom;                                                   \
+		}                                                                                                                            \
+		static void validated_get(const Variant *base, Variant *member) {                                                            \
+			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom;    \
+		}                                                                                                                            \
+		static void ptr_get(const void *base, void *member) {                                                                        \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                                  \
+		}                                                                                                                            \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                          \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                     \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
+				valid = true;                                                                                                        \
+			} else {                                                                                                                 \
+				valid = false;                                                                                                       \
+			}                                                                                                                        \
+		}                                                                                                                            \
+		static void validated_set(Variant *base, const Variant *value) {                                                             \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value);     \
+		}                                                                                                                            \
+		static void ptr_set(void *base, const void *member) {                                                                        \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                    \
+			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                                   \
+			PtrToArg<m_base_type>::encode(b, base);                                                                                  \
+		}                                                                                                                            \
+		static Variant::Type get_type() { return GetTypeInfo<m_member_type>::VARIANT_TYPE; }                                         \
+	};
+
+#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                               \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                             \
+		static void get(const Variant *base, Variant *member) {                                                                   \
+			*member = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom;                                                \
+		}                                                                                                                         \
+		static void validated_get(const Variant *base, Variant *member) {                                                         \
+			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
+		}                                                                                                                         \
+		static void ptr_get(const void *base, void *member) {                                                                     \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                               \
+		}                                                                                                                         \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                       \
+			if (value->get_type() == Variant::FLOAT) {                                                                            \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<double>::get_ptr(value);     \
+				valid = true;                                                                                                     \
+			} else if (value->get_type() == Variant::INT) {                                                                       \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<int64_t>::get_ptr(value);    \
+				valid = true;                                                                                                     \
+			} else {                                                                                                              \
+				valid = false;                                                                                                    \
+			}                                                                                                                     \
+		}                                                                                                                         \
+		static void validated_set(Variant *base, const Variant *value) {                                                          \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value);  \
+		}                                                                                                                         \
+		static void ptr_set(void *base, const void *member) {                                                                     \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                 \
+			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                                \
+			PtrToArg<m_base_type>::encode(b, base);                                                                               \
+		}                                                                                                                         \
+		static Variant::Type get_type() { return GetTypeInfo<m_member_type>::VARIANT_TYPE; }                                      \
+	};
+
+#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                                \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                               \
+		static void get(const Variant *base, Variant *member) {                                                                     \
+			*member = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter();                                                \
+		}                                                                                                                           \
+		static void validated_get(const Variant *base, Variant *member) {                                                           \
+			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
+		}                                                                                                                           \
+		static void ptr_get(const void *base, void *member) {                                                                       \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                               \
+		}                                                                                                                           \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                         \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                    \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
+				valid = true;                                                                                                       \
+			} else {                                                                                                                \
+				valid = false;                                                                                                      \
+			}                                                                                                                       \
+		}                                                                                                                           \
+		static void validated_set(Variant *base, const Variant *value) {                                                            \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
+		}                                                                                                                           \
+		static void ptr_set(void *base, const void *member) {                                                                       \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                   \
+			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                                   \
+			PtrToArg<m_base_type>::encode(b, base);                                                                                 \
+		}                                                                                                                           \
+		static Variant::Type get_type() { return GetTypeInfo<m_member_type>::VARIANT_TYPE; }                                        \
+	};
+
+#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                         \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                               \
+		static void get(const Variant *base, Variant *member) {                                                                     \
+			*member = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter();                                                \
+		}                                                                                                                           \
+		static void validated_get(const Variant *base, Variant *member) {                                                           \
+			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
+		}                                                                                                                           \
+		static void ptr_get(const void *base, void *member) {                                                                       \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                               \
+		}                                                                                                                           \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                         \
+			if (value->get_type() == Variant::FLOAT) {                                                                              \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<double>::get_ptr(value));        \
+				valid = true;                                                                                                       \
+			} else if (value->get_type() == Variant::INT) {                                                                         \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<int64_t>::get_ptr(value));       \
+				valid = true;                                                                                                       \
+			} else {                                                                                                                \
+				valid = false;                                                                                                      \
+			}                                                                                                                       \
+		}                                                                                                                           \
+		static void validated_set(Variant *base, const Variant *value) {                                                            \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
+		}                                                                                                                           \
+		static void ptr_set(void *base, const void *member) {                                                                       \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                   \
+			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                                   \
+			PtrToArg<m_base_type>::encode(b, base);                                                                                 \
+		}                                                                                                                           \
+		static Variant::Type get_type() { return GetTypeInfo<m_member_type>::VARIANT_TYPE; }                                        \
+	};
+
+#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index)                                          \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                                        \
+		static void get(const Variant *base, Variant *member) {                                                                              \
+			*member = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index);                                                  \
+		}                                                                                                                                    \
+		static void validated_get(const Variant *base, Variant *member) {                                                                    \
+			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index);   \
+		}                                                                                                                                    \
+		static void ptr_get(const void *base, void *member) {                                                                                \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(m_index), member);                                 \
+		}                                                                                                                                    \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                                  \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                             \
+				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
+				valid = true;                                                                                                                \
+			} else {                                                                                                                         \
+				valid = false;                                                                                                               \
+			}                                                                                                                                \
+		}                                                                                                                                    \
+		static void validated_set(Variant *base, const Variant *value) {                                                                     \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
+		}                                                                                                                                    \
+		static void ptr_set(void *base, const void *member) {                                                                                \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                            \
+			b.m_setter(m_index, PtrToArg<m_member_type>::convert(member));                                                                   \
+			PtrToArg<m_base_type>::encode(b, base);                                                                                          \
+		}                                                                                                                                    \
+		static Variant::Type get_type() { return GetTypeInfo<m_member_type>::VARIANT_TYPE; }                                                 \
+	};
+
+SETGET_NUMBER_STRUCT(Vector2, double, x)
+SETGET_NUMBER_STRUCT(Vector2, double, y)
+
+SETGET_NUMBER_STRUCT(Vector2i, int64_t, x)
+SETGET_NUMBER_STRUCT(Vector2i, int64_t, y)
+
+SETGET_NUMBER_STRUCT(Vector3, double, x)
+SETGET_NUMBER_STRUCT(Vector3, double, y)
+SETGET_NUMBER_STRUCT(Vector3, double, z)
+
+SETGET_NUMBER_STRUCT(Vector3i, int64_t, x)
+SETGET_NUMBER_STRUCT(Vector3i, int64_t, y)
+SETGET_NUMBER_STRUCT(Vector3i, int64_t, z)
+
+SETGET_STRUCT(Rect2, Vector2, position)
+SETGET_STRUCT(Rect2, Vector2, size)
+SETGET_STRUCT_FUNC(Rect2, Vector2, end, set_end, get_end)
+
+SETGET_STRUCT(Rect2i, Vector2i, position)
+SETGET_STRUCT(Rect2i, Vector2i, size)
+SETGET_STRUCT_FUNC(Rect2i, Vector2i, end, set_end, get_end)
+
+SETGET_STRUCT(AABB, Vector3, position)
+SETGET_STRUCT(AABB, Vector3, size)
+SETGET_STRUCT_FUNC(AABB, Vector3, end, set_end, get_end)
+
+SETGET_STRUCT_CUSTOM(Transform2D, Vector2, x, elements[0])
+SETGET_STRUCT_CUSTOM(Transform2D, Vector2, y, elements[1])
+SETGET_STRUCT_CUSTOM(Transform2D, Vector2, origin, elements[2])
+
+SETGET_NUMBER_STRUCT_CUSTOM(Plane, double, x, normal.x)
+SETGET_NUMBER_STRUCT_CUSTOM(Plane, double, y, normal.y)
+SETGET_NUMBER_STRUCT_CUSTOM(Plane, double, z, normal.z)
+SETGET_STRUCT(Plane, Vector3, normal)
+SETGET_NUMBER_STRUCT(Plane, double, d)
+
+SETGET_NUMBER_STRUCT(Quat, double, x)
+SETGET_NUMBER_STRUCT(Quat, double, y)
+SETGET_NUMBER_STRUCT(Quat, double, z)
+SETGET_NUMBER_STRUCT(Quat, double, w)
+
+SETGET_STRUCT_FUNC_INDEX(Basis, Vector3, x, set_axis, get_axis, 0)
+SETGET_STRUCT_FUNC_INDEX(Basis, Vector3, y, set_axis, get_axis, 1)
+SETGET_STRUCT_FUNC_INDEX(Basis, Vector3, z, set_axis, get_axis, 2)
+
+SETGET_STRUCT(Transform, Basis, basis)
+SETGET_STRUCT(Transform, Vector3, origin)
+
+SETGET_NUMBER_STRUCT(Color, double, r)
+SETGET_NUMBER_STRUCT(Color, double, g)
+SETGET_NUMBER_STRUCT(Color, double, b)
+SETGET_NUMBER_STRUCT(Color, double, a)
+
+SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, r8, set_r8, get_r8)
+SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, g8, set_g8, get_g8)
+SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, b8, set_b8, get_b8)
+SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, a8, set_a8, get_a8)
+
+SETGET_NUMBER_STRUCT_FUNC(Color, double, h, set_h, get_h)
+SETGET_NUMBER_STRUCT_FUNC(Color, double, s, set_s, get_s)
+SETGET_NUMBER_STRUCT_FUNC(Color, double, v, set_v, get_v)
+
+struct VariantSetterGetterInfo {
+	void (*setter)(Variant *base, const Variant *value, bool &valid);
+	void (*getter)(const Variant *base, Variant *value);
+	Variant::ValidatedSetter validated_setter;
+	Variant::ValidatedGetter validated_getter;
+	Variant::PTRSetter ptr_setter;
+	Variant::PTRGetter ptr_getter;
+	Variant::Type member_type;
+};
+
+static LocalVector<VariantSetterGetterInfo> variant_setters_getters[Variant::VARIANT_MAX];
+static LocalVector<StringName> variant_setters_getters_names[Variant::VARIANT_MAX]; //one next to another to make it cache friendly
+
+template <class T>
+static void register_member(Variant::Type p_type, const StringName &p_member) {
+	VariantSetterGetterInfo sgi;
+	sgi.setter = T::set;
+	sgi.validated_setter = T::validated_set;
+	sgi.ptr_setter = T::ptr_set;
+
+	sgi.getter = T::get;
+	sgi.validated_getter = T::validated_get;
+	sgi.ptr_getter = T::ptr_get;
+
+	sgi.member_type = T::get_type();
+
+	variant_setters_getters[p_type].push_back(sgi);
+	variant_setters_getters_names[p_type].push_back(p_member);
+}
+
+void register_named_setters_getters() {
+#define REGISTER_MEMBER(m_base_type, m_member) register_member<VariantSetGet_##m_base_type##_##m_member>(GetTypeInfo<m_base_type>::VARIANT_TYPE, #m_member)
+
+	REGISTER_MEMBER(Vector2, x);
+	REGISTER_MEMBER(Vector2, y);
+
+	REGISTER_MEMBER(Vector2i, x);
+	REGISTER_MEMBER(Vector2i, y);
+
+	REGISTER_MEMBER(Vector3, x);
+	REGISTER_MEMBER(Vector3, y);
+	REGISTER_MEMBER(Vector3, z);
+
+	REGISTER_MEMBER(Vector3i, x);
+	REGISTER_MEMBER(Vector3i, y);
+	REGISTER_MEMBER(Vector3i, z);
+
+	REGISTER_MEMBER(Rect2, position);
+	REGISTER_MEMBER(Rect2, size);
+	REGISTER_MEMBER(Rect2, end);
+
+	REGISTER_MEMBER(Rect2i, position);
+	REGISTER_MEMBER(Rect2i, size);
+	REGISTER_MEMBER(Rect2i, end);
+
+	REGISTER_MEMBER(AABB, position);
+	REGISTER_MEMBER(AABB, size);
+	REGISTER_MEMBER(AABB, end);
+
+	REGISTER_MEMBER(Transform2D, x);
+	REGISTER_MEMBER(Transform2D, y);
+	REGISTER_MEMBER(Transform2D, origin);
+
+	REGISTER_MEMBER(Plane, x);
+	REGISTER_MEMBER(Plane, y);
+	REGISTER_MEMBER(Plane, z);
+	REGISTER_MEMBER(Plane, d);
+	REGISTER_MEMBER(Plane, normal);
+
+	REGISTER_MEMBER(Quat, x);
+	REGISTER_MEMBER(Quat, y);
+	REGISTER_MEMBER(Quat, z);
+	REGISTER_MEMBER(Quat, w);
+
+	REGISTER_MEMBER(Basis, x);
+	REGISTER_MEMBER(Basis, y);
+	REGISTER_MEMBER(Basis, z);
+
+	REGISTER_MEMBER(Transform, basis);
+	REGISTER_MEMBER(Transform, origin);
+
+	REGISTER_MEMBER(Color, r);
+	REGISTER_MEMBER(Color, g);
+	REGISTER_MEMBER(Color, b);
+	REGISTER_MEMBER(Color, a);
+
+	REGISTER_MEMBER(Color, r8);
+	REGISTER_MEMBER(Color, g8);
+	REGISTER_MEMBER(Color, b8);
+	REGISTER_MEMBER(Color, a8);
+
+	REGISTER_MEMBER(Color, h);
+	REGISTER_MEMBER(Color, s);
+	REGISTER_MEMBER(Color, v);
+}
+
+void unregister_named_setters_getters() {
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		variant_setters_getters[i].clear();
+		variant_setters_getters_names[i].clear();
+	}
+}
+
+bool Variant::has_member(Variant::Type p_type, const StringName &p_member) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
+
+	for (uint32_t i = 0; i < variant_setters_getters_names[p_type].size(); i++) {
+		if (variant_setters_getters_names[p_type][i] == p_member) {
+			return true;
+		}
+	}
+	return false;
+}
+
+Variant::Type Variant::get_member_type(Variant::Type p_type, const StringName &p_member) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Variant::VARIANT_MAX);
+
+	for (uint32_t i = 0; i < variant_setters_getters_names[p_type].size(); i++) {
+		if (variant_setters_getters_names[p_type][i] == p_member) {
+			return variant_setters_getters[p_type][i].member_type;
+		}
+	}
+
+	return Variant::NIL;
+}
+
+void Variant::get_member_list(Variant::Type p_type, List<StringName> *r_members) {
+	for (uint32_t i = 0; i < variant_setters_getters_names[p_type].size(); i++) {
+		r_members->push_back(variant_setters_getters_names[p_type][i]);
+	}
+}
+
+Variant::ValidatedSetter Variant::get_member_validated_setter(Variant::Type p_type, const StringName &p_member) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+
+	for (uint32_t i = 0; i < variant_setters_getters_names[p_type].size(); i++) {
+		if (variant_setters_getters_names[p_type][i] == p_member) {
+			return variant_setters_getters[p_type][i].validated_setter;
+		}
+	}
+
+	return nullptr;
+}
+Variant::ValidatedGetter Variant::get_member_validated_getter(Variant::Type p_type, const StringName &p_member) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+
+	for (uint32_t i = 0; i < variant_setters_getters_names[p_type].size(); i++) {
+		if (variant_setters_getters_names[p_type][i] == p_member) {
+			return variant_setters_getters[p_type][i].validated_getter;
+		}
+	}
+
+	return nullptr;
+}
+
+Variant::PTRSetter Variant::get_member_ptr_setter(Variant::Type p_type, const StringName &p_member) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+
+	for (uint32_t i = 0; i < variant_setters_getters_names[p_type].size(); i++) {
+		if (variant_setters_getters_names[p_type][i] == p_member) {
+			return variant_setters_getters[p_type][i].ptr_setter;
+		}
+	}
+
+	return nullptr;
+}
+
+Variant::PTRGetter Variant::get_member_ptr_getter(Variant::Type p_type, const StringName &p_member) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+
+	for (uint32_t i = 0; i < variant_setters_getters_names[p_type].size(); i++) {
+		if (variant_setters_getters_names[p_type][i] == p_member) {
+			return variant_setters_getters[p_type][i].ptr_getter;
+		}
+	}
+
+	return nullptr;
+}
+
+void Variant::set_named(const StringName &p_member, const Variant &p_value, bool &r_valid) {
+	uint32_t s = variant_setters_getters[type].size();
+	if (s) {
+		for (uint32_t i = 0; i < s; i++) {
+			if (variant_setters_getters_names[type][i] == p_member) {
+				variant_setters_getters[type][i].setter(this, &p_value, r_valid);
+				return;
+			}
+		}
+		r_valid = false;
+
+	} else if (type == Variant::OBJECT) {
+		Object *obj = get_validated_object();
+		if (!obj) {
+			r_valid = false;
+		} else {
+			obj->set(p_member, p_value, &r_valid);
+			return;
+		}
+	} else if (type == Variant::DICTIONARY) {
+		Variant *v = VariantGetInternalPtr<Dictionary>::get_ptr(this)->getptr(p_member);
+		if (v) {
+			*v = p_value;
+			r_valid = true;
+		} else {
+			r_valid = false;
+		}
+
+	} else {
+		r_valid = false;
+	}
+}
+
+Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
+	Variant ret;
+	uint32_t s = variant_setters_getters[type].size();
+	if (s) {
+		for (uint32_t i = 0; i < s; i++) {
+			if (variant_setters_getters_names[type][i] == p_member) {
+				variant_setters_getters[type][i].getter(this, &ret);
+				r_valid = true;
+				return ret;
+			}
+		}
+
+		r_valid = false;
+
+	} else if (type == Variant::OBJECT) {
+		Object *obj = get_validated_object();
+		if (!obj) {
+			r_valid = false;
+			return "Instance base is null.";
+		} else {
+			return obj->get(p_member, &r_valid);
+		}
+	} else if (type == Variant::DICTIONARY) {
+		const Variant *v = VariantGetInternalPtr<Dictionary>::get_ptr(this)->getptr(p_member);
+		if (v) {
+			r_valid = true;
+
+			return *v;
+		} else {
+			r_valid = false;
+		}
+
+	} else {
+		r_valid = false;
+	}
+
+	return ret;
+}
+
+/**** INDEXED SETTERS AND GETTERS ****/
+
+#ifdef DEBUG_ENABLED
+
+#define OOB_TEST(m_idx, m_v) \
+	ERR_FAIL_INDEX(m_idx, m_v)
+
+#else
+
+#define OOB_TEST(m_idx, m_v)
+
+#endif
+
+#ifdef DEBUG_ENABLED
+
+#define NULL_TEST(m_key) \
+	ERR_FAIL_COND(!m_key)
+
+#else
+
+#define NULL_TEST(m_key)
+
+#endif
+
+#define INDEXED_SETGET_STRUCT_TYPED(m_base_type, m_elem_type)                                                                        \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                      \
+		static void get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                             \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			*value = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];                                                    \
+			oob = false;                                                                                                             \
+		}                                                                                                                            \
+		static void validated_get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                   \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];       \
+			oob = false;                                                                                                             \
+		}                                                                                                                            \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                         \
+			/* avoid ptrconvert for performance*/                                                                                    \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                     \
+			if (index < 0)                                                                                                           \
+				index += v.size();                                                                                                   \
+			OOB_TEST(index, v.size());                                                                                               \
+			PtrToArg<m_elem_type>::encode(v[index], member);                                                                         \
+		}                                                                                                                            \
+		static void set(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob) {                                \
+			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                       \
+				oob = false;                                                                                                         \
+				valid = false;                                                                                                       \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				valid = false;                                                                                                       \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
+			oob = false;                                                                                                             \
+			valid = true;                                                                                                            \
+		}                                                                                                                            \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool &oob) {                                   \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
+			oob = false;                                                                                                             \
+		}                                                                                                                            \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                         \
+			/* avoid ptrconvert for performance*/                                                                                    \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                 \
+			if (index < 0)                                                                                                           \
+				index += v.size();                                                                                                   \
+			OOB_TEST(index, v.size());                                                                                               \
+			v.write[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
+		}                                                                                                                            \
+		static Variant::Type get_index_type() { return GetTypeInfo<m_elem_type>::VARIANT_TYPE; }                                     \
+		static uint64_t get_indexed_size(const Variant *base) { return VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); }  \
+	};
+
+#define INDEXED_SETGET_STRUCT_TYPED_NUMERIC(m_base_type, m_elem_type, m_assign_type)                                                 \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                      \
+		static void get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                             \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			*value = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];                                                    \
+			oob = false;                                                                                                             \
+		}                                                                                                                            \
+		static void validated_get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                   \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];       \
+			oob = false;                                                                                                             \
+		}                                                                                                                            \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                         \
+			/* avoid ptrconvert for performance*/                                                                                    \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                     \
+			if (index < 0)                                                                                                           \
+				index += v.size();                                                                                                   \
+			OOB_TEST(index, v.size());                                                                                               \
+			PtrToArg<m_elem_type>::encode(v[index], member);                                                                         \
+		}                                                                                                                            \
+		static void set(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob) {                                \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				valid = false;                                                                                                       \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			m_assign_type num;                                                                                                       \
+			if (value->get_type() == Variant::INT) {                                                                                 \
+				num = (m_assign_type)*VariantGetInternalPtr<int64_t>::get_ptr(value);                                                \
+			} else if (value->get_type() == Variant::FLOAT) {                                                                        \
+				num = (m_assign_type)*VariantGetInternalPtr<double>::get_ptr(value);                                                 \
+			} else {                                                                                                                 \
+				oob = false;                                                                                                         \
+				valid = false;                                                                                                       \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = num;                                                 \
+			oob = false;                                                                                                             \
+			valid = true;                                                                                                            \
+		}                                                                                                                            \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool &oob) {                                   \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
+			if (index < 0) {                                                                                                         \
+				index += size;                                                                                                       \
+			}                                                                                                                        \
+			if (index < 0 || index >= size) {                                                                                        \
+				oob = true;                                                                                                          \
+				return;                                                                                                              \
+			}                                                                                                                        \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
+			oob = false;                                                                                                             \
+		}                                                                                                                            \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                         \
+			/* avoid ptrconvert for performance*/                                                                                    \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                 \
+			if (index < 0)                                                                                                           \
+				index += v.size();                                                                                                   \
+			OOB_TEST(index, v.size());                                                                                               \
+			v.write[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
+		}                                                                                                                            \
+		static Variant::Type get_index_type() { return GetTypeInfo<m_elem_type>::VARIANT_TYPE; }                                     \
+		static uint64_t get_indexed_size(const Variant *base) { return VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); }  \
+	};
+
+#define INDEXED_SETGET_STRUCT_BULTIN_NUMERIC(m_base_type, m_elem_type, m_assign_type, m_max)                                   \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                \
+		static void get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                       \
+			if (index < 0 || index >= m_max) {                                                                                 \
+				oob = true;                                                                                                    \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			*value = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];                                              \
+			oob = false;                                                                                                       \
+		}                                                                                                                      \
+		static void validated_get(const Variant *base, int64_t index, Variant *value, bool &oob) {                             \
+			if (index < 0 || index >= m_max) {                                                                                 \
+				oob = true;                                                                                                    \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index]; \
+			oob = false;                                                                                                       \
+		}                                                                                                                      \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                   \
+			/* avoid ptrconvert for performance*/                                                                              \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                               \
+			OOB_TEST(index, m_max);                                                                                            \
+			PtrToArg<m_elem_type>::encode(v[index], member);                                                                   \
+		}                                                                                                                      \
+		static void set(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob) {                          \
+			if (index < 0 || index >= m_max) {                                                                                 \
+				oob = true;                                                                                                    \
+				valid = false;                                                                                                 \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			m_assign_type num;                                                                                                 \
+			if (value->get_type() == Variant::INT) {                                                                           \
+				num = (m_assign_type)*VariantGetInternalPtr<int64_t>::get_ptr(value);                                          \
+			} else if (value->get_type() == Variant::FLOAT) {                                                                  \
+				num = (m_assign_type)*VariantGetInternalPtr<double>::get_ptr(value);                                           \
+			} else {                                                                                                           \
+				oob = false;                                                                                                   \
+				valid = false;                                                                                                 \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = num;                                                 \
+			oob = false;                                                                                                       \
+			valid = true;                                                                                                      \
+		}                                                                                                                      \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool &oob) {                             \
+			if (index < 0 || index >= m_max) {                                                                                 \
+				oob = true;                                                                                                    \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
+			oob = false;                                                                                                       \
+		}                                                                                                                      \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                   \
+			/* avoid ptrconvert for performance*/                                                                              \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                           \
+			OOB_TEST(index, m_max);                                                                                            \
+			v[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
+		}                                                                                                                      \
+		static Variant::Type get_index_type() { return GetTypeInfo<m_elem_type>::VARIANT_TYPE; }                               \
+		static uint64_t get_indexed_size(const Variant *base) { return m_max; }                                                \
+	};
+
+#define INDEXED_SETGET_STRUCT_BULTIN_ACCESSOR(m_base_type, m_elem_type, m_accessor, m_max)                                                \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                           \
+		static void get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                                  \
+			if (index < 0 || index >= m_max) {                                                                                            \
+				oob = true;                                                                                                               \
+				return;                                                                                                                   \
+			}                                                                                                                             \
+			*value = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))m_accessor[index];                                               \
+			oob = false;                                                                                                                  \
+		}                                                                                                                                 \
+		static void validated_get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                        \
+			if (index < 0 || index >= m_max) {                                                                                            \
+				oob = true;                                                                                                               \
+				return;                                                                                                                   \
+			}                                                                                                                             \
+			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))m_accessor[index];  \
+			oob = false;                                                                                                                  \
+		}                                                                                                                                 \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                              \
+			/* avoid ptrconvert for performance*/                                                                                         \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                          \
+			OOB_TEST(index, m_max);                                                                                                       \
+			PtrToArg<m_elem_type>::encode(v m_accessor[index], member);                                                                   \
+		}                                                                                                                                 \
+		static void set(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob) {                                     \
+			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                            \
+				oob = false;                                                                                                              \
+				valid = false;                                                                                                            \
+			}                                                                                                                             \
+			if (index < 0 || index >= m_max) {                                                                                            \
+				oob = true;                                                                                                               \
+				valid = false;                                                                                                            \
+				return;                                                                                                                   \
+			}                                                                                                                             \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
+			oob = false;                                                                                                                  \
+			valid = true;                                                                                                                 \
+		}                                                                                                                                 \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool &oob) {                                        \
+			if (index < 0 || index >= m_max) {                                                                                            \
+				oob = true;                                                                                                               \
+				return;                                                                                                                   \
+			}                                                                                                                             \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
+			oob = false;                                                                                                                  \
+		}                                                                                                                                 \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                              \
+			/* avoid ptrconvert for performance*/                                                                                         \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                      \
+			OOB_TEST(index, m_max);                                                                                                       \
+			v m_accessor[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
+		}                                                                                                                                 \
+		static Variant::Type get_index_type() { return GetTypeInfo<m_elem_type>::VARIANT_TYPE; }                                          \
+		static uint64_t get_indexed_size(const Variant *base) { return m_max; }                                                           \
+	};
+
+#define INDEXED_SETGET_STRUCT_BULTIN_FUNC(m_base_type, m_elem_type, m_set, m_get, m_max)                                           \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                    \
+		static void get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                           \
+			if (index < 0 || index >= m_max) {                                                                                     \
+				oob = true;                                                                                                        \
+				return;                                                                                                            \
+			}                                                                                                                      \
+			*value = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_get(index);                                              \
+			oob = false;                                                                                                           \
+		}                                                                                                                          \
+		static void validated_get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                 \
+			if (index < 0 || index >= m_max) {                                                                                     \
+				oob = true;                                                                                                        \
+				return;                                                                                                            \
+			}                                                                                                                      \
+			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_get(index); \
+			oob = false;                                                                                                           \
+		}                                                                                                                          \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                       \
+			/* avoid ptrconvert for performance*/                                                                                  \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                   \
+			OOB_TEST(index, m_max);                                                                                                \
+			PtrToArg<m_elem_type>::encode(v.m_get(index), member);                                                                 \
+		}                                                                                                                          \
+		static void set(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob) {                              \
+			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                     \
+				oob = false;                                                                                                       \
+				valid = false;                                                                                                     \
+			}                                                                                                                      \
+			if (index < 0 || index >= m_max) {                                                                                     \
+				oob = true;                                                                                                        \
+				valid = false;                                                                                                     \
+				return;                                                                                                            \
+			}                                                                                                                      \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_set(index, *VariantGetInternalPtr<m_elem_type>::get_ptr(value));  \
+			oob = false;                                                                                                           \
+			valid = true;                                                                                                          \
+		}                                                                                                                          \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool &oob) {                                 \
+			if (index < 0 || index >= m_max) {                                                                                     \
+				oob = true;                                                                                                        \
+				return;                                                                                                            \
+			}                                                                                                                      \
+			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_set(index, *VariantGetInternalPtr<m_elem_type>::get_ptr(value));  \
+			oob = false;                                                                                                           \
+		}                                                                                                                          \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                       \
+			/* avoid ptrconvert for performance*/                                                                                  \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                               \
+			OOB_TEST(index, m_max);                                                                                                \
+			v.m_set(index, PtrToArg<m_elem_type>::convert(member));                                                                \
+		}                                                                                                                          \
+		static Variant::Type get_index_type() { return GetTypeInfo<m_elem_type>::VARIANT_TYPE; }                                   \
+		static uint64_t get_indexed_size(const Variant *base) { return m_max; }                                                    \
+	};
+
+#define INDEXED_SETGET_STRUCT_VARIANT(m_base_type)                                                    \
+	struct VariantIndexedSetGet_##m_base_type {                                                       \
+		static void get(const Variant *base, int64_t index, Variant *value, bool &oob) {              \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                 \
+			if (index < 0) {                                                                          \
+				index += size;                                                                        \
+			}                                                                                         \
+			if (index < 0 || index >= size) {                                                         \
+				oob = true;                                                                           \
+				return;                                                                               \
+			}                                                                                         \
+			*value = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];                     \
+			oob = false;                                                                              \
+		}                                                                                             \
+		static void validated_get(const Variant *base, int64_t index, Variant *value, bool &oob) {    \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                 \
+			if (index < 0) {                                                                          \
+				index += size;                                                                        \
+			}                                                                                         \
+			if (index < 0 || index >= size) {                                                         \
+				oob = true;                                                                           \
+				return;                                                                               \
+			}                                                                                         \
+			*value = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];                     \
+			oob = false;                                                                              \
+		}                                                                                             \
+		static void ptr_get(const void *base, int64_t index, void *member) {                          \
+			/* avoid ptrconvert for performance*/                                                     \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                      \
+			if (index < 0)                                                                            \
+				index += v.size();                                                                    \
+			OOB_TEST(index, v.size());                                                                \
+			PtrToArg<Variant>::encode(v[index], member);                                              \
+		}                                                                                             \
+		static void set(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob) { \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                 \
+			if (index < 0) {                                                                          \
+				index += size;                                                                        \
+			}                                                                                         \
+			if (index < 0 || index >= size) {                                                         \
+				oob = true;                                                                           \
+				valid = false;                                                                        \
+				return;                                                                               \
+			}                                                                                         \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = *value;                     \
+			oob = false;                                                                              \
+			valid = true;                                                                             \
+		}                                                                                             \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool &oob) {    \
+			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                 \
+			if (index < 0) {                                                                          \
+				index += size;                                                                        \
+			}                                                                                         \
+			if (index < 0 || index >= size) {                                                         \
+				oob = true;                                                                           \
+				return;                                                                               \
+			}                                                                                         \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = *value;                     \
+			oob = false;                                                                              \
+		}                                                                                             \
+		static void ptr_set(void *base, int64_t index, const void *member) {                          \
+			/* avoid ptrconvert for performance*/                                                     \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                  \
+			if (index < 0)                                                                            \
+				index += v.size();                                                                    \
+			OOB_TEST(index, v.size());                                                                \
+			v[index] = PtrToArg<Variant>::convert(member);                                            \
+		}                                                                                             \
+		static Variant::Type get_index_type() { return Variant::NIL; }                                \
+		static uint64_t get_indexed_size(const Variant *base) { return 0; }                           \
+	};
+
+#define INDEXED_SETGET_STRUCT_DICT(m_base_type)                                                                                     \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                     \
+		static void get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                            \
+			const Variant *ptr = VariantGetInternalPtr<m_base_type>::get_ptr(base)->getptr(index);                                  \
+			if (!ptr) {                                                                                                             \
+				oob = true;                                                                                                         \
+				return;                                                                                                             \
+			}                                                                                                                       \
+			*value = *ptr;                                                                                                          \
+			oob = false;                                                                                                            \
+		}                                                                                                                           \
+		static void validated_get(const Variant *base, int64_t index, Variant *value, bool &oob) {                                  \
+			const Variant *ptr = VariantGetInternalPtr<m_base_type>::get_ptr(base)->getptr(index);                                  \
+			if (!ptr) {                                                                                                             \
+				oob = true;                                                                                                         \
+				return;                                                                                                             \
+			}                                                                                                                       \
+			*value = *ptr;                                                                                                          \
+			oob = false;                                                                                                            \
+		}                                                                                                                           \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                        \
+			/* avoid ptrconvert for performance*/                                                                                   \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                    \
+			const Variant *ptr = v.getptr(index);                                                                                   \
+			NULL_TEST(ptr);                                                                                                         \
+			PtrToArg<Variant>::encode(*ptr, member);                                                                                \
+		}                                                                                                                           \
+		static void set(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob) {                               \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = *value;                                                   \
+			oob = false;                                                                                                            \
+			valid = true;                                                                                                           \
+		}                                                                                                                           \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool &oob) {                                  \
+			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = *value;                                                   \
+			oob = false;                                                                                                            \
+		}                                                                                                                           \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                        \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                \
+			v[index] = PtrToArg<Variant>::convert(member);                                                                          \
+		}                                                                                                                           \
+		static Variant::Type get_index_type() { return Variant::NIL; }                                                              \
+		static uint64_t get_indexed_size(const Variant *base) { return VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); } \
+	};
+
+INDEXED_SETGET_STRUCT_BULTIN_NUMERIC(Vector2, double, real_t, 2)
+INDEXED_SETGET_STRUCT_BULTIN_NUMERIC(Vector2i, int64_t, int32_t, 2)
+INDEXED_SETGET_STRUCT_BULTIN_NUMERIC(Vector3, double, real_t, 3)
+INDEXED_SETGET_STRUCT_BULTIN_NUMERIC(Vector3i, int64_t, int32_t, 3)
+INDEXED_SETGET_STRUCT_BULTIN_NUMERIC(Quat, double, real_t, 4)
+INDEXED_SETGET_STRUCT_BULTIN_NUMERIC(Color, double, float, 4)
+
+INDEXED_SETGET_STRUCT_BULTIN_ACCESSOR(Transform2D, Vector2, .elements, 3)
+INDEXED_SETGET_STRUCT_BULTIN_FUNC(Basis, Vector3, set_axis, get_axis, 3)
+
+INDEXED_SETGET_STRUCT_TYPED_NUMERIC(PackedByteArray, int64_t, uint8_t)
+INDEXED_SETGET_STRUCT_TYPED_NUMERIC(PackedInt32Array, int64_t, int32_t)
+INDEXED_SETGET_STRUCT_TYPED_NUMERIC(PackedInt64Array, int64_t, int64_t)
+INDEXED_SETGET_STRUCT_TYPED_NUMERIC(PackedFloat32Array, double, float)
+INDEXED_SETGET_STRUCT_TYPED_NUMERIC(PackedFloat64Array, double, double)
+INDEXED_SETGET_STRUCT_TYPED(PackedVector2Array, Vector2)
+INDEXED_SETGET_STRUCT_TYPED(PackedVector3Array, Vector3)
+INDEXED_SETGET_STRUCT_TYPED(PackedStringArray, String)
+INDEXED_SETGET_STRUCT_TYPED(PackedColorArray, Color)
+
+INDEXED_SETGET_STRUCT_VARIANT(Array)
+INDEXED_SETGET_STRUCT_DICT(Dictionary)
+
+struct VariantIndexedSetterGetterInfo {
+	void (*setter)(Variant *base, int64_t index, const Variant *value, bool &valid, bool &oob);
+	void (*getter)(const Variant *base, int64_t index, Variant *value, bool &oob);
+
+	Variant::ValidatedIndexedSetter validated_setter;
+	Variant::ValidatedIndexedGetter validated_getter;
+
+	Variant::PTRIndexedSetter ptr_setter;
+	Variant::PTRIndexedGetter ptr_getter;
+
+	uint64_t (*get_indexed_size)(const Variant *base);
+
+	Variant::Type index_type;
+
+	bool valid = false;
+};
+
+static VariantIndexedSetterGetterInfo variant_indexed_setters_getters[Variant::VARIANT_MAX];
+
+template <class T>
+static void register_indexed_member(Variant::Type p_type) {
+	VariantIndexedSetterGetterInfo &sgi = variant_indexed_setters_getters[p_type];
+
+	sgi.setter = T::set;
+	sgi.validated_setter = T::validated_set;
+	sgi.ptr_setter = T::ptr_set;
+
+	sgi.getter = T::get;
+	sgi.validated_getter = T::validated_get;
+	sgi.ptr_getter = T::ptr_get;
+
+	sgi.index_type = T::get_index_type();
+	sgi.get_indexed_size = T::get_indexed_size;
+
+	sgi.valid = true;
+}
+
+void register_indexed_setters_getters() {
+#define REGISTER_INDEXED_MEMBER(m_base_type) register_indexed_member<VariantIndexedSetGet_##m_base_type>(GetTypeInfo<m_base_type>::VARIANT_TYPE)
+
+	REGISTER_INDEXED_MEMBER(Vector2);
+	REGISTER_INDEXED_MEMBER(Vector2i);
+	REGISTER_INDEXED_MEMBER(Vector3);
+	REGISTER_INDEXED_MEMBER(Vector3i);
+	REGISTER_INDEXED_MEMBER(Quat);
+	REGISTER_INDEXED_MEMBER(Color);
+	REGISTER_INDEXED_MEMBER(Transform2D);
+	REGISTER_INDEXED_MEMBER(Basis);
+
+	REGISTER_INDEXED_MEMBER(PackedByteArray);
+	REGISTER_INDEXED_MEMBER(PackedInt32Array);
+	REGISTER_INDEXED_MEMBER(PackedInt64Array);
+	REGISTER_INDEXED_MEMBER(PackedFloat64Array);
+	REGISTER_INDEXED_MEMBER(PackedVector2Array);
+	REGISTER_INDEXED_MEMBER(PackedVector3Array);
+	REGISTER_INDEXED_MEMBER(PackedStringArray);
+	REGISTER_INDEXED_MEMBER(PackedColorArray);
+
+	REGISTER_INDEXED_MEMBER(Array);
+	REGISTER_INDEXED_MEMBER(Dictionary);
+}
+
+static void unregister_indexed_setters_getters() {
+}
+
+bool Variant::has_indexing(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
+	return variant_indexed_setters_getters[p_type].valid;
+}
+
+Variant::Type Variant::get_indexed_element_type(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Variant::VARIANT_MAX);
+	return variant_indexed_setters_getters[p_type].index_type;
+}
+
+Variant::ValidatedIndexedSetter Variant::get_member_validated_indexed_setter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+	return variant_indexed_setters_getters[p_type].validated_setter;
+}
+Variant::ValidatedIndexedGetter Variant::get_member_validated_indexed_getter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+	return variant_indexed_setters_getters[p_type].validated_getter;
+}
+
+Variant::PTRIndexedSetter Variant::get_member_ptr_indexed_setter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+	return variant_indexed_setters_getters[p_type].ptr_setter;
+}
+Variant::PTRIndexedGetter Variant::get_member_ptr_indexed_getter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
+	return variant_indexed_setters_getters[p_type].ptr_getter;
+}
+
+void Variant::set_indexed(int64_t p_index, const Variant &p_value, bool &r_valid, bool &r_oob) {
+	if (likely(variant_indexed_setters_getters[type].valid)) {
+		variant_indexed_setters_getters[type].setter(this, p_index, &p_value, r_valid, r_oob);
+	} else {
+		r_valid = false;
+		r_oob = false;
+	}
+}
+Variant Variant::get_indexed(int64_t p_index, bool &r_valid, bool &r_oob) const {
+	if (likely(variant_indexed_setters_getters[type].valid)) {
+		Variant ret;
+		variant_indexed_setters_getters[type].getter(this, p_index, &ret, r_oob);
+		r_valid = !r_oob;
+		return ret;
+	} else {
+		r_valid = false;
+		r_oob = false;
+		return Variant();
+	}
+}
+
+uint64_t Variant::get_indexed_size() const {
+	if (likely(variant_indexed_setters_getters[type].valid && variant_indexed_setters_getters[type].get_indexed_size)) {
+		return variant_indexed_setters_getters[type].get_indexed_size(this);
+	} else {
+		return 0;
+	}
+}
+
+struct VariantKeyedSetGetDictionary {
+	static void get(const Variant *base, const Variant *key, Variant *value, bool &r_valid) {
+		const Variant *ptr = VariantGetInternalPtr<Dictionary>::get_ptr(base)->getptr(*key);
+		if (!ptr) {
+			r_valid = false;
+			return;
+		}
+		*value = *ptr;
+		r_valid = true;
+	}
+	static void ptr_get(const void *base, const void *key, void *value) {
+		/* avoid ptrconvert for performance*/
+		const Dictionary &v = *reinterpret_cast<const Dictionary *>(base);
+		const Variant *ptr = v.getptr(PtrToArg<Variant>::convert(key));
+		NULL_TEST(ptr);
+		PtrToArg<Variant>::encode(*ptr, value);
+	}
+	static void set(Variant *base, const Variant *key, const Variant *value, bool &r_valid) {
+		(*VariantGetInternalPtr<Dictionary>::get_ptr(base))[*key] = *value;
+		r_valid = true;
+	}
+	static void ptr_set(void *base, const void *key, const void *value) {
+		Dictionary &v = *reinterpret_cast<Dictionary *>(base);
+		v[PtrToArg<Variant>::convert(key)] = PtrToArg<Variant>::convert(value);
+	}
+
+	static bool has(const Variant *base, const Variant *key, bool &r_valid) {
+		r_valid = true;
+		return VariantGetInternalPtr<Dictionary>::get_ptr(base)->has(*key);
+	}
+	static bool ptr_has(const void *base, const void *key) {
+		/* avoid ptrconvert for performance*/
+		const Dictionary &v = *reinterpret_cast<const Dictionary *>(base);
+		return v.has(PtrToArg<Variant>::convert(key));
+	}
+};
+
+struct VariantKeyedSetGetObject {
+	static void get(const Variant *base, const Variant *key, Variant *value, bool &r_valid) {
+		Object *obj = base->get_validated_object();
+
+		if (!obj) {
+			r_valid = false;
+			*value = Variant();
+			return;
+		}
+		*value = obj->getvar(*key, &r_valid);
+	}
+	static void ptr_get(const void *base, const void *key, void *value) {
+		const Object *obj = PtrToArg<Object *>::convert(base);
+		NULL_TEST(obj);
+		Variant v = obj->getvar(PtrToArg<Variant>::convert(key));
+		PtrToArg<Variant>::encode(v, value);
+	}
+	static void set(Variant *base, const Variant *key, const Variant *value, bool &r_valid) {
+		Object *obj = base->get_validated_object();
+
+		if (!obj) {
+			r_valid = false;
+			return;
+		}
+		obj->setvar(*key, *value, &r_valid);
+	}
+	static void ptr_set(void *base, const void *key, const void *value) {
+		Object *obj = PtrToArg<Object *>::convert(base);
+		NULL_TEST(obj);
+		obj->setvar(PtrToArg<Variant>::convert(key), PtrToArg<Variant>::convert(value));
+	}
+
+	static bool has(const Variant *base, const Variant *key, bool &r_valid) {
+		Object *obj = base->get_validated_object();
+		if (obj != nullptr) {
+			r_valid = false;
+			return false;
+		}
+		r_valid = true;
+		bool exists;
+		obj->getvar(*key, &exists);
+		return exists;
+	}
+	static bool ptr_has(const void *base, const void *key) {
+		const Object *obj = PtrToArg<Object *>::convert(base);
+		ERR_FAIL_COND_V(!obj, false);
+		bool valid;
+		obj->getvar(PtrToArg<Variant>::convert(key), &valid);
+		return valid;
+	}
+};
+
+/*typedef void (*ValidatedKeyedSetter)(Variant *base, const Variant *key, const Variant *value);
+typedef void (*ValidatedKeyedGetter)(const Variant *base, const Variant *key, Variant *value, bool &valid);
+typedef bool (*ValidatedKeyedChecker)(const Variant *base, const Variant *key);
+
+typedef void (*PTRKeyedSetter)(void *base, const void *key, const void *value);
+typedef void (*PTRKeyedGetter)(const void *base, const void *key, void *value);
+typedef bool (*PTRKeyedChecker)(const void *base, const void *key);*/
+
+struct VariantKeyedSetterGetterInfo {
+	Variant::ValidatedKeyedSetter validated_setter;
+	Variant::ValidatedKeyedGetter validated_getter;
+	Variant::ValidatedKeyedChecker validated_checker;
+
+	Variant::PTRKeyedSetter ptr_setter;
+	Variant::PTRKeyedGetter ptr_getter;
+	Variant::PTRKeyedChecker ptr_checker;
+
+	bool valid = false;
+};
+
+static VariantKeyedSetterGetterInfo variant_keyed_setters_getters[Variant::VARIANT_MAX];
+
+template <class T>
+static void register_keyed_member(Variant::Type p_type) {
+	VariantKeyedSetterGetterInfo &sgi = variant_keyed_setters_getters[p_type];
+
+	sgi.validated_setter = T::set;
+	sgi.ptr_setter = T::ptr_set;
+
+	sgi.validated_getter = T::get;
+	sgi.ptr_getter = T::ptr_get;
+
+	sgi.validated_checker = T::has;
+	sgi.ptr_checker = T::ptr_has;
+
+	sgi.valid = true;
+}
+
+static void register_keyed_setters_getters() {
+	register_keyed_member<VariantKeyedSetGetDictionary>(Variant::DICTIONARY);
+	register_keyed_member<VariantKeyedSetGetObject>(Variant::OBJECT);
+}
+bool Variant::is_keyed(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, false);
+	return variant_keyed_setters_getters[p_type].valid;
+}
+
+Variant::ValidatedKeyedSetter Variant::get_member_validated_keyed_setter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, nullptr);
+	return variant_keyed_setters_getters[p_type].validated_setter;
+}
+Variant::ValidatedKeyedGetter Variant::get_member_validated_keyed_getter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, nullptr);
+	return variant_keyed_setters_getters[p_type].validated_getter;
+}
+Variant::ValidatedKeyedChecker Variant::get_member_validated_keyed_checker(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, nullptr);
+	return variant_keyed_setters_getters[p_type].validated_checker;
+}
+
+Variant::PTRKeyedSetter Variant::get_member_ptr_keyed_setter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, nullptr);
+	return variant_keyed_setters_getters[p_type].ptr_setter;
+}
+Variant::PTRKeyedGetter Variant::get_member_ptr_keyed_getter(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, nullptr);
+	return variant_keyed_setters_getters[p_type].ptr_getter;
+}
+Variant::PTRKeyedChecker Variant::get_member_ptr_keyed_checker(Variant::Type p_type) {
+	ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, nullptr);
+	return variant_keyed_setters_getters[p_type].ptr_checker;
+}
+
+void Variant::set_keyed(const Variant &p_key, const Variant &p_value, bool &r_valid) {
+	if (likely(variant_keyed_setters_getters[type].valid)) {
+		variant_keyed_setters_getters[type].validated_setter(this, &p_key, &p_value, r_valid);
+	} else {
+		r_valid = false;
+	}
+}
+Variant Variant::get_keyed(const Variant &p_key, bool &r_valid) const {
+	if (likely(variant_keyed_setters_getters[type].valid)) {
+		Variant ret;
+		variant_keyed_setters_getters[type].validated_getter(this, &p_key, &ret, r_valid);
+		return ret;
+	} else {
+		r_valid = false;
+		return Variant();
+	}
+}
+bool Variant::has_key(const Variant &p_key, bool &r_valid) const {
+	if (likely(variant_keyed_setters_getters[type].valid)) {
+		return variant_keyed_setters_getters[type].validated_checker(this, &p_key, r_valid);
+	} else {
+		r_valid = false;
+		return false;
+	}
+}
+
+void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) {
+	if (type == DICTIONARY || type == OBJECT) {
+		bool valid;
+		set_keyed(p_index, p_value, valid);
+		if (r_valid) {
+			*r_valid = valid;
+		}
+	} else {
+		bool valid = false;
+		if (p_index.get_type() == STRING_NAME) {
+			set_named(*VariantGetInternalPtr<StringName>::get_ptr(&p_index), p_value, valid);
+		} else if (p_index.get_type() == INT) {
+			bool obb;
+			set_indexed(*VariantGetInternalPtr<int64_t>::get_ptr(&p_index), p_value, valid, obb);
+			if (obb) {
+				valid = false;
+			}
+		} else if (p_index.get_type() == STRING) { // less efficient version of named
+			set_named(*VariantGetInternalPtr<String>::get_ptr(&p_index), p_value, valid);
+		} else if (p_index.get_type() == FLOAT) { // less efficient version of indexed
+			bool obb;
+			set_indexed(*VariantGetInternalPtr<double>::get_ptr(&p_index), p_value, valid, obb);
+			if (obb) {
+				valid = false;
+			}
+		}
+		if (r_valid) {
+			*r_valid = valid;
+		}
+	}
+}
+
+Variant Variant::get(const Variant &p_index, bool *r_valid) const {
+	Variant ret;
+	if (type == DICTIONARY || type == OBJECT) {
+		bool valid;
+		ret = get_keyed(p_index, valid);
+		if (r_valid) {
+			*r_valid = valid;
+		}
+	} else {
+		bool valid = false;
+		if (p_index.get_type() == STRING_NAME) {
+			ret = get_named(*VariantGetInternalPtr<StringName>::get_ptr(&p_index), valid);
+		} else if (p_index.get_type() == INT) {
+			bool obb;
+			ret = get_indexed(*VariantGetInternalPtr<int64_t>::get_ptr(&p_index), valid, obb);
+			if (obb) {
+				valid = false;
+			}
+		} else if (p_index.get_type() == STRING) { // less efficient version of named
+			ret = get_named(*VariantGetInternalPtr<String>::get_ptr(&p_index), valid);
+		} else if (p_index.get_type() == FLOAT) { // less efficient version of indexed
+			bool obb;
+			ret = get_indexed(*VariantGetInternalPtr<double>::get_ptr(&p_index), valid, obb);
+			if (obb) {
+				valid = false;
+			}
+		}
+		if (r_valid) {
+			*r_valid = valid;
+		}
+	}
+
+	return ret;
+}
+
+void Variant::get_property_list(List<PropertyInfo> *p_list) const {
+	if (type == DICTIONARY) {
+		const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
+		List<Variant> keys;
+		dic->get_key_list(&keys);
+		for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
+			if (E->get().get_type() == Variant::STRING) {
+				p_list->push_back(PropertyInfo(Variant::STRING, E->get()));
+			}
+		}
+	} else if (type == OBJECT) {
+		Object *obj = get_validated_object();
+		ERR_FAIL_COND(!obj);
+		obj->get_property_list(p_list);
+
+	} else {
+		List<StringName> members;
+		get_member_list(type, &members);
+		for (List<StringName>::Element *E = members.front(); E; E = E->next()) {
+			PropertyInfo pi;
+			pi.name = E->get();
+			pi.type = get_member_type(type, E->get());
+			p_list->push_back(pi);
+		}
+	}
+}
+
+bool Variant::iter_init(Variant &r_iter, bool &valid) const {
+	valid = true;
+	switch (type) {
+		case INT: {
+			r_iter = 0;
+			return _data._int > 0;
+		} break;
+		case FLOAT: {
+			r_iter = 0;
+			return _data._float > 0.0;
+		} break;
+		case VECTOR2: {
+			double from = reinterpret_cast<const Vector2 *>(_data._mem)->x;
+			double to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
+
+			r_iter = from;
+
+			return from < to;
+		} break;
+		case VECTOR2I: {
+			int64_t from = reinterpret_cast<const Vector2i *>(_data._mem)->x;
+			int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y;
+
+			r_iter = from;
+
+			return from < to;
+		} break;
+		case VECTOR3: {
+			double from = reinterpret_cast<const Vector3 *>(_data._mem)->x;
+			double to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
+			double step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
+
+			r_iter = from;
+
+			if (from == to) {
+				return false;
+			} else if (from < to) {
+				return step > 0;
+			}
+			return step < 0;
+		} break;
+		case VECTOR3I: {
+			int64_t from = reinterpret_cast<const Vector3i *>(_data._mem)->x;
+			int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y;
+			int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z;
+
+			r_iter = from;
+
+			if (from == to) {
+				return false;
+			} else if (from < to) {
+				return step > 0;
+			}
+			return step < 0;
+		} break;
+		case OBJECT: {
+			if (!_get_obj().obj) {
+				valid = false;
+				return false;
+			}
+
+#ifdef DEBUG_ENABLED
+
+			if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
+				valid = false;
+				return false;
+			}
+
+#endif
+			Callable::CallError ce;
+			ce.error = Callable::CallError::CALL_OK;
+			Array ref;
+			ref.push_back(r_iter);
+			Variant vref = ref;
+			const Variant *refp[] = { &vref };
+			Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_init, refp, 1, ce);
+
+			if (ref.size() != 1 || ce.error != Callable::CallError::CALL_OK) {
+				valid = false;
+				return false;
+			}
+
+			r_iter = ref[0];
+			return ret;
+		} break;
+
+		case STRING: {
+			const String *str = reinterpret_cast<const String *>(_data._mem);
+			if (str->empty()) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+		} break;
+		case DICTIONARY: {
+			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
+			if (dic->empty()) {
+				return false;
+			}
+
+			const Variant *next = dic->next(nullptr);
+			r_iter = *next;
+			return true;
+
+		} break;
+		case ARRAY: {
+			const Array *arr = reinterpret_cast<const Array *>(_data._mem);
+			if (arr->empty()) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+		} break;
+		case PACKED_BYTE_ARRAY: {
+			const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+
+		} break;
+		case PACKED_INT32_ARRAY: {
+			const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+
+		} break;
+		case PACKED_INT64_ARRAY: {
+			const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+
+		} break;
+		case PACKED_FLOAT32_ARRAY: {
+			const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+
+		} break;
+		case PACKED_FLOAT64_ARRAY: {
+			const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+
+		} break;
+		case PACKED_STRING_ARRAY: {
+			const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+		} break;
+		case PACKED_VECTOR2_ARRAY: {
+			const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+		} break;
+		case PACKED_VECTOR3_ARRAY: {
+			const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+		} break;
+		case PACKED_COLOR_ARRAY: {
+			const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array);
+			if (arr->size() == 0) {
+				return false;
+			}
+			r_iter = 0;
+			return true;
+
+		} break;
+		default: {
+		}
+	}
+
+	valid = false;
+	return false;
+}
+
+bool Variant::iter_next(Variant &r_iter, bool &valid) const {
+	valid = true;
+	switch (type) {
+		case INT: {
+			int64_t idx = r_iter;
+			idx++;
+			if (idx >= _data._int) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		case FLOAT: {
+			int64_t idx = r_iter;
+			idx++;
+			if (idx >= _data._float) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		case VECTOR2: {
+			double to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
+
+			double idx = r_iter;
+			idx++;
+
+			if (idx >= to) {
+				return false;
+			}
+
+			r_iter = idx;
+			return true;
+		} break;
+		case VECTOR2I: {
+			int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y;
+
+			int64_t idx = r_iter;
+			idx++;
+
+			if (idx >= to) {
+				return false;
+			}
+
+			r_iter = idx;
+			return true;
+		} break;
+		case VECTOR3: {
+			double to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
+			double step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
+
+			double idx = r_iter;
+			idx += step;
+
+			if (step < 0 && idx <= to) {
+				return false;
+			}
+
+			if (step > 0 && idx >= to) {
+				return false;
+			}
+
+			r_iter = idx;
+			return true;
+		} break;
+		case VECTOR3I: {
+			int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y;
+			int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z;
+
+			int64_t idx = r_iter;
+			idx += step;
+
+			if (step < 0 && idx <= to) {
+				return false;
+			}
+
+			if (step > 0 && idx >= to) {
+				return false;
+			}
+
+			r_iter = idx;
+			return true;
+		} break;
+		case OBJECT: {
+			if (!_get_obj().obj) {
+				valid = false;
+				return false;
+			}
+
+#ifdef DEBUG_ENABLED
+
+			if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
+				valid = false;
+				return false;
+			}
+
+#endif
+			Callable::CallError ce;
+			ce.error = Callable::CallError::CALL_OK;
+			Array ref;
+			ref.push_back(r_iter);
+			Variant vref = ref;
+			const Variant *refp[] = { &vref };
+			Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_next, refp, 1, ce);
+
+			if (ref.size() != 1 || ce.error != Callable::CallError::CALL_OK) {
+				valid = false;
+				return false;
+			}
+
+			r_iter = ref[0];
+
+			return ret;
+		} break;
+
+		case STRING: {
+			const String *str = reinterpret_cast<const String *>(_data._mem);
+			int idx = r_iter;
+			idx++;
+			if (idx >= str->length()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		case DICTIONARY: {
+			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
+			const Variant *next = dic->next(&r_iter);
+			if (!next) {
+				return false;
+			}
+
+			r_iter = *next;
+			return true;
+
+		} break;
+		case ARRAY: {
+			const Array *arr = reinterpret_cast<const Array *>(_data._mem);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		case PACKED_BYTE_ARRAY: {
+			const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+
+		} break;
+		case PACKED_INT32_ARRAY: {
+			const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array);
+			int32_t idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+
+		} break;
+		case PACKED_INT64_ARRAY: {
+			const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array);
+			int64_t idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+
+		} break;
+		case PACKED_FLOAT32_ARRAY: {
+			const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+
+		} break;
+		case PACKED_FLOAT64_ARRAY: {
+			const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+
+		} break;
+		case PACKED_STRING_ARRAY: {
+			const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		case PACKED_VECTOR2_ARRAY: {
+			const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		case PACKED_VECTOR3_ARRAY: {
+			const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		case PACKED_COLOR_ARRAY: {
+			const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array);
+			int idx = r_iter;
+			idx++;
+			if (idx >= arr->size()) {
+				return false;
+			}
+			r_iter = idx;
+			return true;
+		} break;
+		default: {
+		}
+	}
+
+	valid = false;
+	return false;
+}
+
+Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const {
+	r_valid = true;
+	switch (type) {
+		case INT: {
+			return r_iter;
+		} break;
+		case FLOAT: {
+			return r_iter;
+		} break;
+		case VECTOR2: {
+			return r_iter;
+		} break;
+		case VECTOR2I: {
+			return r_iter;
+		} break;
+		case VECTOR3: {
+			return r_iter;
+		} break;
+		case VECTOR3I: {
+			return r_iter;
+		} break;
+		case OBJECT: {
+			if (!_get_obj().obj) {
+				r_valid = false;
+				return Variant();
+			}
+#ifdef DEBUG_ENABLED
+			if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
+				r_valid = false;
+				return Variant();
+			}
+
+#endif
+			Callable::CallError ce;
+			ce.error = Callable::CallError::CALL_OK;
+			const Variant *refp[] = { &r_iter };
+			Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_get, refp, 1, ce);
+
+			if (ce.error != Callable::CallError::CALL_OK) {
+				r_valid = false;
+				return Variant();
+			}
+
+			//r_iter=ref[0];
+
+			return ret;
+		} break;
+
+		case STRING: {
+			const String *str = reinterpret_cast<const String *>(_data._mem);
+			return str->substr(r_iter, 1);
+		} break;
+		case DICTIONARY: {
+			return r_iter; //iterator is the same as the key
+
+		} break;
+		case ARRAY: {
+			const Array *arr = reinterpret_cast<const Array *>(_data._mem);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_BYTE_ARRAY: {
+			const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_INT32_ARRAY: {
+			const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array);
+			int32_t idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_INT64_ARRAY: {
+			const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array);
+			int64_t idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_FLOAT32_ARRAY: {
+			const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_FLOAT64_ARRAY: {
+			const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_STRING_ARRAY: {
+			const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_VECTOR2_ARRAY: {
+			const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_VECTOR3_ARRAY: {
+			const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		case PACKED_COLOR_ARRAY: {
+			const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array);
+			int idx = r_iter;
+#ifdef DEBUG_ENABLED
+			if (idx < 0 || idx >= arr->size()) {
+				r_valid = false;
+				return Variant();
+			}
+#endif
+			return arr->get(idx);
+		} break;
+		default: {
+		}
+	}
+
+	r_valid = false;
+	return Variant();
+}
+
+Variant Variant::duplicate(bool deep) const {
+	switch (type) {
+		case OBJECT: {
+			/*  breaks stuff :(
+			if (deep && !_get_obj().ref.is_null()) {
+				Ref<Resource> resource = _get_obj().ref;
+				if (resource.is_valid()) {
+					return resource->duplicate(true);
+				}
+			}
+			*/
+			return *this;
+		} break;
+		case DICTIONARY:
+			return operator Dictionary().duplicate(deep);
+		case ARRAY:
+			return operator Array().duplicate(deep);
+		default:
+			return *this;
+	}
+}
+
+void Variant::blend(const Variant &a, const Variant &b, float c, Variant &r_dst) {
+	if (a.type != b.type) {
+		if (a.is_num() && b.is_num()) {
+			real_t va = a;
+			real_t vb = b;
+			r_dst = va + vb * c;
+		} else {
+			r_dst = a;
+		}
+		return;
+	}
+
+	switch (a.type) {
+		case NIL: {
+			r_dst = Variant();
+		}
+			return;
+		case INT: {
+			int64_t va = a._data._int;
+			int64_t vb = b._data._int;
+			r_dst = int(va + vb * c + 0.5);
+		}
+			return;
+		case FLOAT: {
+			double ra = a._data._float;
+			double rb = b._data._float;
+			r_dst = ra + rb * c;
+		}
+			return;
+		case VECTOR2: {
+			r_dst = *reinterpret_cast<const Vector2 *>(a._data._mem) + *reinterpret_cast<const Vector2 *>(b._data._mem) * c;
+		}
+			return;
+		case VECTOR2I: {
+			int32_t vax = reinterpret_cast<const Vector2i *>(a._data._mem)->x;
+			int32_t vbx = reinterpret_cast<const Vector2i *>(b._data._mem)->x;
+			int32_t vay = reinterpret_cast<const Vector2i *>(a._data._mem)->y;
+			int32_t vby = reinterpret_cast<const Vector2i *>(b._data._mem)->y;
+			r_dst = Vector2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5));
+		}
+			return;
+		case RECT2: {
+			const Rect2 *ra = reinterpret_cast<const Rect2 *>(a._data._mem);
+			const Rect2 *rb = reinterpret_cast<const Rect2 *>(b._data._mem);
+			r_dst = Rect2(ra->position + rb->position * c, ra->size + rb->size * c);
+		}
+			return;
+		case RECT2I: {
+			const Rect2i *ra = reinterpret_cast<const Rect2i *>(a._data._mem);
+			const Rect2i *rb = reinterpret_cast<const Rect2i *>(b._data._mem);
+
+			int32_t vax = ra->position.x;
+			int32_t vay = ra->position.y;
+			int32_t vbx = ra->size.x;
+			int32_t vby = ra->size.y;
+			int32_t vcx = rb->position.x;
+			int32_t vcy = rb->position.y;
+			int32_t vdx = rb->size.x;
+			int32_t vdy = rb->size.y;
+
+			r_dst = Rect2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vcx + vdx * c + 0.5), int32_t(vcy + vdy * c + 0.5));
+		}
+			return;
+		case VECTOR3: {
+			r_dst = *reinterpret_cast<const Vector3 *>(a._data._mem) + *reinterpret_cast<const Vector3 *>(b._data._mem) * c;
+		}
+			return;
+		case VECTOR3I: {
+			int32_t vax = reinterpret_cast<const Vector3i *>(a._data._mem)->x;
+			int32_t vbx = reinterpret_cast<const Vector3i *>(b._data._mem)->x;
+			int32_t vay = reinterpret_cast<const Vector3i *>(a._data._mem)->y;
+			int32_t vby = reinterpret_cast<const Vector3i *>(b._data._mem)->y;
+			int32_t vaz = reinterpret_cast<const Vector3i *>(a._data._mem)->z;
+			int32_t vbz = reinterpret_cast<const Vector3i *>(b._data._mem)->z;
+			r_dst = Vector3i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vaz + vbz * c + 0.5));
+		}
+			return;
+		case AABB: {
+			const ::AABB *ra = reinterpret_cast<const ::AABB *>(a._data._mem);
+			const ::AABB *rb = reinterpret_cast<const ::AABB *>(b._data._mem);
+			r_dst = ::AABB(ra->position + rb->position * c, ra->size + rb->size * c);
+		}
+			return;
+		case QUAT: {
+			Quat empty_rot;
+			const Quat *qa = reinterpret_cast<const Quat *>(a._data._mem);
+			const Quat *qb = reinterpret_cast<const Quat *>(b._data._mem);
+			r_dst = *qa * empty_rot.slerp(*qb, c);
+		}
+			return;
+		case COLOR: {
+			const Color *ca = reinterpret_cast<const Color *>(a._data._mem);
+			const Color *cb = reinterpret_cast<const Color *>(b._data._mem);
+			float new_r = ca->r + cb->r * c;
+			float new_g = ca->g + cb->g * c;
+			float new_b = ca->b + cb->b * c;
+			float new_a = ca->a + cb->a * c;
+			new_r = new_r > 1.0 ? 1.0 : new_r;
+			new_g = new_g > 1.0 ? 1.0 : new_g;
+			new_b = new_b > 1.0 ? 1.0 : new_b;
+			new_a = new_a > 1.0 ? 1.0 : new_a;
+			r_dst = Color(new_r, new_g, new_b, new_a);
+		}
+			return;
+		default: {
+			r_dst = c < 0.5 ? a : b;
+		}
+			return;
+	}
+}
+
+void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst) {
+	if (a.type != b.type) {
+		if (a.is_num() && b.is_num()) {
+			//not as efficient but..
+			real_t va = a;
+			real_t vb = b;
+			r_dst = va + (vb - va) * c;
+
+		} else {
+			r_dst = a;
+		}
+		return;
+	}
+
+	switch (a.type) {
+		case NIL: {
+			r_dst = Variant();
+		}
+			return;
+		case BOOL: {
+			r_dst = a;
+		}
+			return;
+		case INT: {
+			int64_t va = a._data._int;
+			int64_t vb = b._data._int;
+			r_dst = int(va + (vb - va) * c);
+		}
+			return;
+		case FLOAT: {
+			real_t va = a._data._float;
+			real_t vb = b._data._float;
+			r_dst = va + (vb - va) * c;
+		}
+			return;
+		case STRING: {
+			//this is pretty funny and bizarre, but artists like to use it for typewritter effects
+			String sa = *reinterpret_cast<const String *>(a._data._mem);
+			String sb = *reinterpret_cast<const String *>(b._data._mem);
+			String dst;
+			int sa_len = sa.length();
+			int sb_len = sb.length();
+			int csize = sa_len + (sb_len - sa_len) * c;
+			if (csize == 0) {
+				r_dst = "";
+				return;
+			}
+			dst.resize(csize + 1);
+			dst[csize] = 0;
+			int split = csize / 2;
+
+			for (int i = 0; i < csize; i++) {
+				char32_t chr = ' ';
+
+				if (i < split) {
+					if (i < sa.length()) {
+						chr = sa[i];
+					} else if (i < sb.length()) {
+						chr = sb[i];
+					}
+
+				} else {
+					if (i < sb.length()) {
+						chr = sb[i];
+					} else if (i < sa.length()) {
+						chr = sa[i];
+					}
+				}
+
+				dst[i] = chr;
+			}
+
+			r_dst = dst;
+		}
+			return;
+		case VECTOR2: {
+			r_dst = reinterpret_cast<const Vector2 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector2 *>(b._data._mem), c);
+		}
+			return;
+		case VECTOR2I: {
+			int32_t vax = reinterpret_cast<const Vector2i *>(a._data._mem)->x;
+			int32_t vbx = reinterpret_cast<const Vector2i *>(b._data._mem)->x;
+			int32_t vay = reinterpret_cast<const Vector2i *>(a._data._mem)->y;
+			int32_t vby = reinterpret_cast<const Vector2i *>(b._data._mem)->y;
+			r_dst = Vector2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5));
+		}
+			return;
+
+		case RECT2: {
+			r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
+		}
+			return;
+		case RECT2I: {
+			const Rect2i *ra = reinterpret_cast<const Rect2i *>(a._data._mem);
+			const Rect2i *rb = reinterpret_cast<const Rect2i *>(b._data._mem);
+
+			int32_t vax = ra->position.x;
+			int32_t vay = ra->position.y;
+			int32_t vbx = ra->size.x;
+			int32_t vby = ra->size.y;
+			int32_t vcx = rb->position.x;
+			int32_t vcy = rb->position.y;
+			int32_t vdx = rb->size.x;
+			int32_t vdy = rb->size.y;
+
+			r_dst = Rect2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vcx + vdx * c + 0.5), int32_t(vcy + vdy * c + 0.5));
+		}
+			return;
+
+		case VECTOR3: {
+			r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector3 *>(b._data._mem), c);
+		}
+			return;
+		case VECTOR3I: {
+			int32_t vax = reinterpret_cast<const Vector3i *>(a._data._mem)->x;
+			int32_t vbx = reinterpret_cast<const Vector3i *>(b._data._mem)->x;
+			int32_t vay = reinterpret_cast<const Vector3i *>(a._data._mem)->y;
+			int32_t vby = reinterpret_cast<const Vector3i *>(b._data._mem)->y;
+			int32_t vaz = reinterpret_cast<const Vector3i *>(a._data._mem)->z;
+			int32_t vbz = reinterpret_cast<const Vector3i *>(b._data._mem)->z;
+			r_dst = Vector3i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vaz + vbz * c + 0.5));
+		}
+			return;
+
+		case TRANSFORM2D: {
+			r_dst = a._data._transform2d->interpolate_with(*b._data._transform2d, c);
+		}
+			return;
+		case PLANE: {
+			r_dst = a;
+		}
+			return;
+		case QUAT: {
+			r_dst = reinterpret_cast<const Quat *>(a._data._mem)->slerp(*reinterpret_cast<const Quat *>(b._data._mem), c);
+		}
+			return;
+		case AABB: {
+			r_dst = ::AABB(a._data._aabb->position.lerp(b._data._aabb->position, c), a._data._aabb->size.lerp(b._data._aabb->size, c));
+		}
+			return;
+		case BASIS: {
+			r_dst = Transform(*a._data._basis).interpolate_with(Transform(*b._data._basis), c).basis;
+		}
+			return;
+		case TRANSFORM: {
+			r_dst = a._data._transform->interpolate_with(*b._data._transform, c);
+		}
+			return;
+		case COLOR: {
+			r_dst = reinterpret_cast<const Color *>(a._data._mem)->lerp(*reinterpret_cast<const Color *>(b._data._mem), c);
+		}
+			return;
+		case STRING_NAME: {
+			r_dst = a;
+		}
+			return;
+		case NODE_PATH: {
+			r_dst = a;
+		}
+			return;
+		case RID: {
+			r_dst = a;
+		}
+			return;
+		case OBJECT: {
+			r_dst = a;
+		}
+			return;
+		case DICTIONARY: {
+		}
+			return;
+		case ARRAY: {
+			r_dst = a;
+		}
+			return;
+		case PACKED_BYTE_ARRAY: {
+			r_dst = a;
+		}
+			return;
+		case PACKED_INT32_ARRAY: {
+			const Vector<int32_t> *arr_a = &PackedArrayRef<int32_t>::get_array(a._data.packed_array);
+			const Vector<int32_t> *arr_b = &PackedArrayRef<int32_t>::get_array(b._data.packed_array);
+			int32_t sz = arr_a->size();
+			if (sz == 0 || arr_b->size() != sz) {
+				r_dst = a;
+			} else {
+				Vector<int32_t> v;
+				v.resize(sz);
+				{
+					int32_t *vw = v.ptrw();
+					const int32_t *ar = arr_a->ptr();
+					const int32_t *br = arr_b->ptr();
+
+					Variant va;
+					for (int32_t i = 0; i < sz; i++) {
+						Variant::interpolate(ar[i], br[i], c, va);
+						vw[i] = va;
+					}
+				}
+				r_dst = v;
+			}
+		}
+			return;
+		case PACKED_INT64_ARRAY: {
+			const Vector<int64_t> *arr_a = &PackedArrayRef<int64_t>::get_array(a._data.packed_array);
+			const Vector<int64_t> *arr_b = &PackedArrayRef<int64_t>::get_array(b._data.packed_array);
+			int64_t sz = arr_a->size();
+			if (sz == 0 || arr_b->size() != sz) {
+				r_dst = a;
+			} else {
+				Vector<int64_t> v;
+				v.resize(sz);
+				{
+					int64_t *vw = v.ptrw();
+					const int64_t *ar = arr_a->ptr();
+					const int64_t *br = arr_b->ptr();
+
+					Variant va;
+					for (int64_t i = 0; i < sz; i++) {
+						Variant::interpolate(ar[i], br[i], c, va);
+						vw[i] = va;
+					}
+				}
+				r_dst = v;
+			}
+		}
+			return;
+		case PACKED_FLOAT32_ARRAY: {
+			const Vector<float> *arr_a = &PackedArrayRef<float>::get_array(a._data.packed_array);
+			const Vector<float> *arr_b = &PackedArrayRef<float>::get_array(b._data.packed_array);
+			int sz = arr_a->size();
+			if (sz == 0 || arr_b->size() != sz) {
+				r_dst = a;
+			} else {
+				Vector<float> v;
+				v.resize(sz);
+				{
+					float *vw = v.ptrw();
+					const float *ar = arr_a->ptr();
+					const float *br = arr_b->ptr();
+
+					Variant va;
+					for (int i = 0; i < sz; i++) {
+						Variant::interpolate(ar[i], br[i], c, va);
+						vw[i] = va;
+					}
+				}
+				r_dst = v;
+			}
+		}
+			return;
+		case PACKED_FLOAT64_ARRAY: {
+			const Vector<double> *arr_a = &PackedArrayRef<double>::get_array(a._data.packed_array);
+			const Vector<double> *arr_b = &PackedArrayRef<double>::get_array(b._data.packed_array);
+			int sz = arr_a->size();
+			if (sz == 0 || arr_b->size() != sz) {
+				r_dst = a;
+			} else {
+				Vector<double> v;
+				v.resize(sz);
+				{
+					double *vw = v.ptrw();
+					const double *ar = arr_a->ptr();
+					const double *br = arr_b->ptr();
+
+					Variant va;
+					for (int i = 0; i < sz; i++) {
+						Variant::interpolate(ar[i], br[i], c, va);
+						vw[i] = va;
+					}
+				}
+				r_dst = v;
+			}
+		}
+			return;
+		case PACKED_STRING_ARRAY: {
+			r_dst = a;
+		}
+			return;
+		case PACKED_VECTOR2_ARRAY: {
+			const Vector<Vector2> *arr_a = &PackedArrayRef<Vector2>::get_array(a._data.packed_array);
+			const Vector<Vector2> *arr_b = &PackedArrayRef<Vector2>::get_array(b._data.packed_array);
+			int sz = arr_a->size();
+			if (sz == 0 || arr_b->size() != sz) {
+				r_dst = a;
+			} else {
+				Vector<Vector2> v;
+				v.resize(sz);
+				{
+					Vector2 *vw = v.ptrw();
+					const Vector2 *ar = arr_a->ptr();
+					const Vector2 *br = arr_b->ptr();
+
+					for (int i = 0; i < sz; i++) {
+						vw[i] = ar[i].lerp(br[i], c);
+					}
+				}
+				r_dst = v;
+			}
+		}
+			return;
+		case PACKED_VECTOR3_ARRAY: {
+			const Vector<Vector3> *arr_a = &PackedArrayRef<Vector3>::get_array(a._data.packed_array);
+			const Vector<Vector3> *arr_b = &PackedArrayRef<Vector3>::get_array(b._data.packed_array);
+			int sz = arr_a->size();
+			if (sz == 0 || arr_b->size() != sz) {
+				r_dst = a;
+			} else {
+				Vector<Vector3> v;
+				v.resize(sz);
+				{
+					Vector3 *vw = v.ptrw();
+					const Vector3 *ar = arr_a->ptr();
+					const Vector3 *br = arr_b->ptr();
+
+					for (int i = 0; i < sz; i++) {
+						vw[i] = ar[i].lerp(br[i], c);
+					}
+				}
+				r_dst = v;
+			}
+		}
+			return;
+		case PACKED_COLOR_ARRAY: {
+			const Vector<Color> *arr_a = &PackedArrayRef<Color>::get_array(a._data.packed_array);
+			const Vector<Color> *arr_b = &PackedArrayRef<Color>::get_array(b._data.packed_array);
+			int sz = arr_a->size();
+			if (sz == 0 || arr_b->size() != sz) {
+				r_dst = a;
+			} else {
+				Vector<Color> v;
+				v.resize(sz);
+				{
+					Color *vw = v.ptrw();
+					const Color *ar = arr_a->ptr();
+					const Color *br = arr_b->ptr();
+
+					for (int i = 0; i < sz; i++) {
+						vw[i] = ar[i].lerp(br[i], c);
+					}
+				}
+				r_dst = v;
+			}
+		}
+			return;
+		default: {
+			r_dst = a;
+		}
+	}
+}
+
+void Variant::_register_variant_setters_getters() {
+	register_named_setters_getters();
+	register_indexed_setters_getters();
+	register_keyed_setters_getters();
+}
+void Variant::_unregister_variant_setters_getters() {
+	unregister_named_setters_getters();
+	unregister_indexed_setters_getters();
+}
diff --git a/core/variant_op.cpp b/core/variant_op.cpp
deleted file mode 100644
index 47539df856..0000000000
--- a/core/variant_op.cpp
+++ /dev/null
@@ -1,4608 +0,0 @@
-/*************************************************************************/
-/*  variant_op.cpp                                                       */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#include "variant.h"
-
-#include "core/class_db.h"
-#include "core/core_string_names.h"
-#include "core/debugger/engine_debugger.h"
-
-#define CASE_TYPE_ALL(PREFIX, OP) \
-	CASE_TYPE(PREFIX, OP, INT)    \
-	CASE_TYPE_ALL_BUT_INT(PREFIX, OP)
-
-#define CASE_TYPE_ALL_BUT_INT(PREFIX, OP)       \
-	CASE_TYPE(PREFIX, OP, NIL)                  \
-	CASE_TYPE(PREFIX, OP, BOOL)                 \
-	CASE_TYPE(PREFIX, OP, FLOAT)                \
-	CASE_TYPE(PREFIX, OP, STRING)               \
-	CASE_TYPE(PREFIX, OP, VECTOR2)              \
-	CASE_TYPE(PREFIX, OP, VECTOR2I)             \
-	CASE_TYPE(PREFIX, OP, RECT2)                \
-	CASE_TYPE(PREFIX, OP, RECT2I)               \
-	CASE_TYPE(PREFIX, OP, VECTOR3)              \
-	CASE_TYPE(PREFIX, OP, VECTOR3I)             \
-	CASE_TYPE(PREFIX, OP, TRANSFORM2D)          \
-	CASE_TYPE(PREFIX, OP, PLANE)                \
-	CASE_TYPE(PREFIX, OP, QUAT)                 \
-	CASE_TYPE(PREFIX, OP, AABB)                 \
-	CASE_TYPE(PREFIX, OP, BASIS)                \
-	CASE_TYPE(PREFIX, OP, TRANSFORM)            \
-	CASE_TYPE(PREFIX, OP, COLOR)                \
-	CASE_TYPE(PREFIX, OP, STRING_NAME)          \
-	CASE_TYPE(PREFIX, OP, NODE_PATH)            \
-	CASE_TYPE(PREFIX, OP, _RID)                 \
-	CASE_TYPE(PREFIX, OP, OBJECT)               \
-	CASE_TYPE(PREFIX, OP, CALLABLE)             \
-	CASE_TYPE(PREFIX, OP, SIGNAL)               \
-	CASE_TYPE(PREFIX, OP, DICTIONARY)           \
-	CASE_TYPE(PREFIX, OP, ARRAY)                \
-	CASE_TYPE(PREFIX, OP, PACKED_BYTE_ARRAY)    \
-	CASE_TYPE(PREFIX, OP, PACKED_INT32_ARRAY)   \
-	CASE_TYPE(PREFIX, OP, PACKED_INT64_ARRAY)   \
-	CASE_TYPE(PREFIX, OP, PACKED_FLOAT32_ARRAY) \
-	CASE_TYPE(PREFIX, OP, PACKED_FLOAT64_ARRAY) \
-	CASE_TYPE(PREFIX, OP, PACKED_STRING_ARRAY)  \
-	CASE_TYPE(PREFIX, OP, PACKED_VECTOR2_ARRAY) \
-	CASE_TYPE(PREFIX, OP, PACKED_VECTOR3_ARRAY) \
-	CASE_TYPE(PREFIX, OP, PACKED_COLOR_ARRAY)
-
-#ifdef __GNUC__
-#define TYPE(PREFIX, OP, TYPE) &&PREFIX##_##OP##_##TYPE
-
-/* clang-format off */
-#define TYPES(PREFIX, OP) {                     \
-		TYPE(PREFIX, OP, NIL),                  \
-		TYPE(PREFIX, OP, BOOL),                 \
-		TYPE(PREFIX, OP, INT),                  \
-		TYPE(PREFIX, OP, FLOAT),                \
-		TYPE(PREFIX, OP, STRING),               \
-		TYPE(PREFIX, OP, VECTOR2),              \
-		TYPE(PREFIX, OP, VECTOR2I),             \
-		TYPE(PREFIX, OP, RECT2),                \
-		TYPE(PREFIX, OP, RECT2I),               \
-		TYPE(PREFIX, OP, VECTOR3),              \
-		TYPE(PREFIX, OP, VECTOR3I),             \
-		TYPE(PREFIX, OP, TRANSFORM2D),          \
-		TYPE(PREFIX, OP, PLANE),                \
-		TYPE(PREFIX, OP, QUAT),                 \
-		TYPE(PREFIX, OP, AABB),                 \
-		TYPE(PREFIX, OP, BASIS),                \
-		TYPE(PREFIX, OP, TRANSFORM),            \
-		TYPE(PREFIX, OP, COLOR),                \
-		TYPE(PREFIX, OP, STRING_NAME),          \
-		TYPE(PREFIX, OP, NODE_PATH),            \
-		TYPE(PREFIX, OP, _RID),                 \
-		TYPE(PREFIX, OP, OBJECT),               \
-		TYPE(PREFIX, OP, CALLABLE),             \
-		TYPE(PREFIX, OP, SIGNAL),               \
-		TYPE(PREFIX, OP, DICTIONARY),           \
-		TYPE(PREFIX, OP, ARRAY),                \
-		TYPE(PREFIX, OP, PACKED_BYTE_ARRAY),    \
-		TYPE(PREFIX, OP, PACKED_INT32_ARRAY),   \
-		TYPE(PREFIX, OP, PACKED_INT64_ARRAY),   \
-		TYPE(PREFIX, OP, PACKED_FLOAT32_ARRAY), \
-		TYPE(PREFIX, OP, PACKED_FLOAT64_ARRAY), \
-		TYPE(PREFIX, OP, PACKED_STRING_ARRAY),  \
-		TYPE(PREFIX, OP, PACKED_VECTOR2_ARRAY), \
-		TYPE(PREFIX, OP, PACKED_VECTOR3_ARRAY), \
-		TYPE(PREFIX, OP, PACKED_COLOR_ARRAY),   \
-}
-
-/* clang-format on */
-
-#define CASES(PREFIX) static const void *switch_table_##PREFIX[Variant::OP_MAX][Variant::VARIANT_MAX] = { \
-	TYPES(PREFIX, OP_EQUAL),                                                                              \
-	TYPES(PREFIX, OP_NOT_EQUAL),                                                                          \
-	TYPES(PREFIX, OP_LESS),                                                                               \
-	TYPES(PREFIX, OP_LESS_EQUAL),                                                                         \
-	TYPES(PREFIX, OP_GREATER),                                                                            \
-	TYPES(PREFIX, OP_GREATER_EQUAL),                                                                      \
-	TYPES(PREFIX, OP_ADD),                                                                                \
-	TYPES(PREFIX, OP_SUBTRACT),                                                                           \
-	TYPES(PREFIX, OP_MULTIPLY),                                                                           \
-	TYPES(PREFIX, OP_DIVIDE),                                                                             \
-	TYPES(PREFIX, OP_NEGATE),                                                                             \
-	TYPES(PREFIX, OP_POSITIVE),                                                                           \
-	TYPES(PREFIX, OP_MODULE),                                                                             \
-	TYPES(PREFIX, OP_STRING_CONCAT),                                                                      \
-	TYPES(PREFIX, OP_SHIFT_LEFT),                                                                         \
-	TYPES(PREFIX, OP_SHIFT_RIGHT),                                                                        \
-	TYPES(PREFIX, OP_BIT_AND),                                                                            \
-	TYPES(PREFIX, OP_BIT_OR),                                                                             \
-	TYPES(PREFIX, OP_BIT_XOR),                                                                            \
-	TYPES(PREFIX, OP_BIT_NEGATE),                                                                         \
-	TYPES(PREFIX, OP_AND),                                                                                \
-	TYPES(PREFIX, OP_OR),                                                                                 \
-	TYPES(PREFIX, OP_XOR),                                                                                \
-	TYPES(PREFIX, OP_NOT),                                                                                \
-	TYPES(PREFIX, OP_IN),                                                                                 \
-}
-
-#define SWITCH(PREFIX, op, val) goto *switch_table_##PREFIX[op][val];
-#define SWITCH_OP(PREFIX, OP, val)
-#define CASE_TYPE(PREFIX, OP, TYPE) PREFIX##_##OP##_##TYPE:
-
-#else
-#define CASES(PREFIX)
-#define SWITCH(PREFIX, op, val) switch (op)
-#define SWITCH_OP(PREFIX, OP, val) \
-	case OP:                       \
-		switch (val)
-#define CASE_TYPE(PREFIX, OP, TYPE) case TYPE:
-#endif
-
-Variant::operator bool() const {
-	return booleanize();
-}
-
-// We consider all uninitialized or empty types to be false based on the type's
-// zeroiness.
-bool Variant::booleanize() const {
-	return !is_zero();
-}
-
-#define _RETURN(m_what) \
-	{                   \
-		r_ret = m_what; \
-		return;         \
-	}
-
-#define _RETURN_FAIL     \
-	{                    \
-		r_valid = false; \
-		return;          \
-	}
-
-#define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                      \
-		if (p_b.type == INT)                                      \
-			_RETURN(p_a._data.m_type m_op p_b._data._int);        \
-		if (p_b.type == FLOAT)                                    \
-			_RETURN(p_a._data.m_type m_op p_b._data._float);      \
-                                                                  \
-		_RETURN_FAIL                                              \
-	}
-
-#define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                           \
-		if (p_b.type == INT)                                           \
-			_RETURN(p_a._data.m_type m_op p_b._data._int);             \
-		if (p_b.type == FLOAT)                                         \
-			_RETURN(p_a._data.m_type m_op p_b._data._float);           \
-		if (p_b.type == NIL)                                           \
-			_RETURN(!(p_b.type m_op NIL));                             \
-                                                                       \
-		_RETURN_FAIL                                                   \
-	}
-
-#ifdef DEBUG_ENABLED
-#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                    \
-		if (p_b.type == INT) {                                  \
-			if (p_b._data._int == 0) {                          \
-				r_valid = false;                                \
-				_RETURN("Division By Zero");                    \
-			}                                                   \
-			_RETURN(p_a._data.m_type / p_b._data._int);         \
-		}                                                       \
-		if (p_b.type == FLOAT) {                                \
-			if (p_b._data._float == 0) {                        \
-				r_valid = false;                                \
-				_RETURN("Division By Zero");                    \
-			}                                                   \
-			_RETURN(p_a._data.m_type / p_b._data._float);       \
-		}                                                       \
-                                                                \
-		_RETURN_FAIL                                            \
-	}
-#else
-#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                    \
-		if (p_b.type == INT)                                    \
-			_RETURN(p_a._data.m_type / p_b._data._int);         \
-		if (p_b.type == FLOAT)                                  \
-			_RETURN(p_a._data.m_type / p_b._data._float);       \
-                                                                \
-		_RETURN_FAIL                                            \
-	}
-#endif
-
-#define DEFAULT_OP_NUM_NEG(m_prefix, m_op_name, m_name, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                    \
-		_RETURN(-p_a._data.m_type);                             \
-	}
-
-#define DEFAULT_OP_NUM_POS(m_prefix, m_op_name, m_name, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                    \
-		_RETURN(p_a._data.m_type);                              \
-	}
-
-#define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type)                           \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                    \
-		if (p_b.type == INT)                                                                    \
-			_RETURN(p_a._data.m_type m_op p_b._data._int);                                      \
-		if (p_b.type == FLOAT)                                                                  \
-			_RETURN(p_a._data.m_type m_op p_b._data._float);                                    \
-		if (p_b.type == VECTOR2)                                                                \
-			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem));  \
-		if (p_b.type == VECTOR3)                                                                \
-			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem));  \
-		if (p_b.type == VECTOR2I)                                                               \
-			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2i *>(p_b._data._mem)); \
-		if (p_b.type == VECTOR3I)                                                               \
-			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3i *>(p_b._data._mem)); \
-                                                                                                \
-		_RETURN_FAIL                                                                            \
-	}
-
-#define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type)                                                              \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
-		if (p_b.type == STRING)                                                                                                    \
-			_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const String *>(p_a._data._mem));     \
-		if (p_b.type == STRING_NAME)                                                                                               \
-			_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const StringName *>(p_a._data._mem)); \
-		if (p_b.type == NODE_PATH)                                                                                                 \
-			_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const NodePath *>(p_a._data._mem));   \
-                                                                                                                                   \
-		_RETURN_FAIL                                                                                                               \
-	}
-
-#define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type)                                                                  \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
-		if (p_b.type == STRING)                                                                                                    \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));     \
-		if (p_b.type == STRING_NAME)                                                                                               \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
-		if (p_b.type == NODE_PATH)                                                                                                 \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem));   \
-                                                                                                                                   \
-		_RETURN_FAIL                                                                                                               \
-	}
-
-#define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type)                                                             \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
-		if (p_b.type == STRING)                                                                                                    \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));     \
-		if (p_b.type == STRING_NAME)                                                                                               \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
-		if (p_b.type == NODE_PATH)                                                                                                 \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem));   \
-		if (p_b.type == NIL)                                                                                                       \
-			_RETURN(!(p_b.type m_op NIL));                                                                                         \
-                                                                                                                                   \
-		_RETURN_FAIL                                                                                                               \
-	}
-
-#define DEFAULT_OP_STR_NULL_NP(m_prefix, m_op_name, m_name, m_op, m_type)                                                        \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                     \
-		if (p_b.type == STRING)                                                                                                  \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));   \
-		if (p_b.type == NODE_PATH)                                                                                               \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \
-		if (p_b.type == NIL)                                                                                                     \
-			_RETURN(!(p_b.type m_op NIL));                                                                                       \
-                                                                                                                                 \
-		_RETURN_FAIL                                                                                                             \
-	}
-
-#define DEFAULT_OP_STR_NULL_SN(m_prefix, m_op_name, m_name, m_op, m_type)                                                          \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
-		if (p_b.type == STRING)                                                                                                    \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));     \
-		if (p_b.type == STRING_NAME)                                                                                               \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
-		if (p_b.type == NIL)                                                                                                       \
-			_RETURN(!(p_b.type m_op NIL));                                                                                         \
-                                                                                                                                   \
-		_RETURN_FAIL                                                                                                               \
-	}
-
-#define DEFAULT_OP_LOCALMEM_REV(m_prefix, m_op_name, m_name, m_op, m_type)                                                     \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                   \
-		if (p_b.type == m_name)                                                                                                \
-			_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const m_type *>(p_a._data._mem)); \
-                                                                                                                               \
-		_RETURN_FAIL                                                                                                           \
-	}
-
-#define DEFAULT_OP_LOCALMEM(m_prefix, m_op_name, m_name, m_op, m_type)                                                         \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                   \
-		if (p_b.type == m_name)                                                                                                \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
-                                                                                                                               \
-		_RETURN_FAIL                                                                                                           \
-	}
-
-#define DEFAULT_OP_LOCALMEM_NULL(m_prefix, m_op_name, m_name, m_op, m_type)                                                    \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                   \
-		if (p_b.type == m_name)                                                                                                \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
-		if (p_b.type == NIL)                                                                                                   \
-			_RETURN(!(p_b.type m_op NIL));                                                                                     \
-                                                                                                                               \
-		_RETURN_FAIL                                                                                                           \
-	}
-
-#define DEFAULT_OP_LOCALMEM_NEG(m_prefix, m_op_name, m_name, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                         \
-		_RETURN(-*reinterpret_cast<const m_type *>(p_a._data._mem)); \
-	}
-
-#define DEFAULT_OP_LOCALMEM_POS(m_prefix, m_op_name, m_name, m_type) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                         \
-		_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem));  \
-	}
-
-#define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type)                                                     \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                   \
-		if (p_b.type == m_name)                                                                                                \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
-		if (p_b.type == INT)                                                                                                   \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._int);                                    \
-		if (p_b.type == FLOAT)                                                                                                 \
-			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._float);                                  \
-                                                                                                                               \
-		_RETURN_FAIL                                                                                                           \
-	}
-
-#define DEFAULT_OP_PTR(m_op, m_name, m_sub)                \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {               \
-		if (p_b.type == m_name)                            \
-			_RETURN(p_a._data.m_sub m_op p_b._data.m_sub); \
-                                                           \
-		_RETURN_FAIL                                       \
-	}
-
-#define DEFAULT_OP_PTRREF(m_prefix, m_op_name, m_name, m_op, m_sub) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                        \
-		if (p_b.type == m_name)                                     \
-			_RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub);        \
-                                                                    \
-		_RETURN_FAIL                                                \
-	}
-
-#define DEFAULT_OP_PTRREF_NULL(m_prefix, m_op_name, m_name, m_op, m_sub) \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                             \
-		if (p_b.type == m_name)                                          \
-			_RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub);             \
-		if (p_b.type == NIL)                                             \
-			_RETURN(!(p_b.type m_op NIL));                               \
-                                                                         \
-		_RETURN_FAIL                                                     \
-	}
-
-#define DEFAULT_OP_ARRAY_EQ(m_prefix, m_op_name, m_name, m_type)                                  \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                      \
-		if (p_b.type == NIL)                                                                      \
-			_RETURN(false)                                                                        \
-		DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, true, false, false) \
-	}
-
-#define DEFAULT_OP_ARRAY_NEQ(m_prefix, m_op_name, m_name, m_type)                                \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                     \
-		if (p_b.type == NIL)                                                                     \
-			_RETURN(true)                                                                        \
-		DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, false, true, true) \
-	}
-
-#define DEFAULT_OP_ARRAY_LT(m_prefix, m_op_name, m_name, m_type) \
-	DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, <, !=, false, a_len < array_b.size(), true)
-
-#define DEFAULT_OP_ARRAY_GT(m_prefix, m_op_name, m_name, m_type) \
-	DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, >, !=, false, a_len < array_b.size(), true)
-
-#define DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f)      \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                     \
-		DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
-	}
-
-#define DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
-	if (p_a.type != p_b.type)                                                                                    \
-		_RETURN_FAIL                                                                                             \
-                                                                                                                 \
-	const Vector<m_type> &array_a = PackedArrayRef<m_type>::get_array(p_a._data.packed_array);                   \
-	const Vector<m_type> &array_b = PackedArrayRef<m_type>::get_array(p_b._data.packed_array);                   \
-                                                                                                                 \
-	int a_len = array_a.size();                                                                                  \
-	if (a_len m_opa array_b.size()) {                                                                            \
-		_RETURN(m_ret_s);                                                                                        \
-	} else {                                                                                                     \
-		const m_type *ra = array_a.ptr();                                                                        \
-		const m_type *rb = array_b.ptr();                                                                        \
-                                                                                                                 \
-		for (int i = 0; i < a_len; i++) {                                                                        \
-			if (ra[i] m_opb rb[i])                                                                               \
-				_RETURN(m_ret_f);                                                                                \
-		}                                                                                                        \
-                                                                                                                 \
-		_RETURN(m_ret_def);                                                                                      \
-	}
-
-#define DEFAULT_OP_ARRAY_ADD(m_prefix, m_op_name, m_name, m_type)                                  \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                       \
-		if (p_a.type != p_b.type)                                                                  \
-			_RETURN_FAIL;                                                                          \
-                                                                                                   \
-		const Vector<m_type> &array_a = PackedArrayRef<m_type>::get_array(p_a._data.packed_array); \
-		const Vector<m_type> &array_b = PackedArrayRef<m_type>::get_array(p_b._data.packed_array); \
-		Vector<m_type> sum = array_a;                                                              \
-		sum.append_array(array_b);                                                                 \
-		_RETURN(sum);                                                                              \
-	}
-
-void Variant::evaluate(const Operator &p_op, const Variant &p_a,
-		const Variant &p_b, Variant &r_ret, bool &r_valid) {
-	CASES(math);
-	r_valid = true;
-
-	SWITCH(math, p_op, p_a.type) {
-		SWITCH_OP(math, OP_EQUAL, p_a.type) {
-			CASE_TYPE(math, OP_EQUAL, NIL) {
-				if (p_b.type == NIL)
-					_RETURN(true);
-				if (p_b.type == OBJECT)
-					_RETURN(p_b._get_obj().obj == nullptr);
-
-				_RETURN(false);
-			}
-
-			CASE_TYPE(math, OP_EQUAL, BOOL) {
-				if (p_b.type != BOOL) {
-					if (p_b.type == NIL)
-						_RETURN(false);
-					_RETURN_FAIL;
-				}
-
-				_RETURN(p_a._data._bool == p_b._data._bool);
-			}
-
-			CASE_TYPE(math, OP_EQUAL, OBJECT) {
-				if (p_b.type == OBJECT)
-					_RETURN((p_a._get_obj().obj == p_b._get_obj().obj));
-				if (p_b.type == NIL)
-					_RETURN(p_a._get_obj().obj == nullptr);
-
-				_RETURN_FAIL;
-			}
-
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, CALLABLE, ==, Callable);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, SIGNAL, ==, Signal);
-
-			CASE_TYPE(math, OP_EQUAL, DICTIONARY) {
-				if (p_b.type != DICTIONARY) {
-					if (p_b.type == NIL)
-						_RETURN(false);
-					_RETURN_FAIL;
-				}
-
-				const Dictionary *arr_a = reinterpret_cast<const Dictionary *>(p_a._data._mem);
-				const Dictionary *arr_b = reinterpret_cast<const Dictionary *>(p_b._data._mem);
-
-				_RETURN(*arr_a == *arr_b);
-			}
-
-			CASE_TYPE(math, OP_EQUAL, ARRAY) {
-				if (p_b.type != ARRAY) {
-					if (p_b.type == NIL)
-						_RETURN(false);
-					_RETURN_FAIL;
-				}
-				const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
-				const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
-
-				int l = arr_a->size();
-				if (arr_b->size() != l)
-					_RETURN(false);
-				for (int i = 0; i < l; i++) {
-					if (!((*arr_a)[i] == (*arr_b)[i])) {
-						_RETURN(false);
-					}
-				}
-
-				_RETURN(true);
-			}
-
-			DEFAULT_OP_NUM_NULL(math, OP_EQUAL, INT, ==, _int);
-			DEFAULT_OP_NUM_NULL(math, OP_EQUAL, FLOAT, ==, _float);
-			DEFAULT_OP_STR_NULL(math, OP_EQUAL, STRING, ==, String);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR2, ==, Vector2);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR2I, ==, Vector2i);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, RECT2, ==, Rect2);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, RECT2I, ==, Rect2i);
-			DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, TRANSFORM2D, ==, _transform2d);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR3, ==, Vector3);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR3I, ==, Vector3i);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, PLANE, ==, Plane);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, QUAT, ==, Quat);
-			DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, AABB, ==, _aabb);
-			DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, BASIS, ==, _basis);
-			DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, TRANSFORM, ==, _transform);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, COLOR, ==, Color);
-			DEFAULT_OP_STR_NULL_SN(math, OP_EQUAL, STRING_NAME, ==, StringName);
-			DEFAULT_OP_STR_NULL_NP(math, OP_EQUAL, NODE_PATH, ==, NodePath);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, _RID, ==, RID);
-
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_BYTE_ARRAY, uint8_t);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_INT32_ARRAY, int32_t);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_INT64_ARRAY, int64_t);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_FLOAT32_ARRAY, float);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_FLOAT64_ARRAY, double);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_STRING_ARRAY, String);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_VECTOR2_ARRAY, Vector2);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_VECTOR3_ARRAY, Vector3);
-			DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, PACKED_COLOR_ARRAY, Color);
-		}
-
-		SWITCH_OP(math, OP_NOT_EQUAL, p_a.type) {
-			CASE_TYPE(math, OP_NOT_EQUAL, NIL) {
-				if (p_b.type == NIL)
-					_RETURN(false);
-				if (p_b.type == OBJECT)
-					_RETURN(p_b._get_obj().obj != nullptr);
-
-				_RETURN(true);
-			}
-
-			CASE_TYPE(math, OP_NOT_EQUAL, BOOL) {
-				if (p_b.type != BOOL) {
-					if (p_b.type == NIL)
-						_RETURN(true);
-
-					_RETURN_FAIL;
-				}
-
-				_RETURN(p_a._data._bool != p_b._data._bool);
-			}
-
-			CASE_TYPE(math, OP_NOT_EQUAL, OBJECT) {
-				if (p_b.type == OBJECT)
-					_RETURN((p_a._get_obj().obj != p_b._get_obj().obj));
-				if (p_b.type == NIL)
-					_RETURN(p_a._get_obj().obj != nullptr);
-
-				_RETURN_FAIL;
-			}
-
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, CALLABLE, !=, Callable);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, SIGNAL, !=, Signal);
-
-			CASE_TYPE(math, OP_NOT_EQUAL, DICTIONARY) {
-				if (p_b.type != DICTIONARY) {
-					if (p_b.type == NIL)
-						_RETURN(true);
-					_RETURN_FAIL;
-				}
-
-				const Dictionary *arr_a = reinterpret_cast<const Dictionary *>(p_a._data._mem);
-				const Dictionary *arr_b = reinterpret_cast<const Dictionary *>(p_b._data._mem);
-
-				_RETURN(*arr_a != *arr_b);
-			}
-
-			CASE_TYPE(math, OP_NOT_EQUAL, ARRAY) {
-				if (p_b.type != ARRAY) {
-					if (p_b.type == NIL)
-						_RETURN(true);
-
-					_RETURN_FAIL;
-				}
-
-				const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
-				const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
-
-				int l = arr_a->size();
-				if (arr_b->size() != l)
-					_RETURN(true);
-				for (int i = 0; i < l; i++) {
-					if (((*arr_a)[i] != (*arr_b)[i])) {
-						_RETURN(true);
-					}
-				}
-
-				_RETURN(false);
-			}
-
-			DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, INT, !=, _int);
-			DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, FLOAT, !=, _float);
-			DEFAULT_OP_STR_NULL(math, OP_NOT_EQUAL, STRING, !=, String);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR2, !=, Vector2);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR2I, !=, Vector2i);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, RECT2, !=, Rect2);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, RECT2I, !=, Rect2i);
-			DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, TRANSFORM2D, !=, _transform2d);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR3, !=, Vector3);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR3I, !=, Vector3i);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, PLANE, !=, Plane);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, QUAT, !=, Quat);
-			DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, AABB, !=, _aabb);
-			DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, BASIS, !=, _basis);
-			DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, TRANSFORM, !=, _transform);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, COLOR, !=, Color);
-			DEFAULT_OP_STR_NULL_SN(math, OP_NOT_EQUAL, STRING_NAME, !=, StringName);
-			DEFAULT_OP_STR_NULL_NP(math, OP_NOT_EQUAL, NODE_PATH, !=, NodePath);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, _RID, !=, RID);
-
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_BYTE_ARRAY, uint8_t);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_INT32_ARRAY, int32_t);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_INT64_ARRAY, int64_t);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_FLOAT32_ARRAY, float);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_FLOAT64_ARRAY, double);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_STRING_ARRAY, String);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_VECTOR2_ARRAY, Vector2);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_VECTOR3_ARRAY, Vector3);
-			DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, PACKED_COLOR_ARRAY, Color);
-		}
-
-		SWITCH_OP(math, OP_LESS, p_a.type) {
-			CASE_TYPE(math, OP_LESS, BOOL) {
-				if (p_b.type != BOOL)
-					_RETURN_FAIL;
-
-				if (p_a._data._bool == p_b._data._bool)
-					_RETURN(false);
-
-				if (p_a._data._bool && !p_b._data._bool)
-					_RETURN(false);
-
-				_RETURN(true);
-			}
-
-			CASE_TYPE(math, OP_LESS, OBJECT) {
-				if (p_b.type != OBJECT)
-					_RETURN_FAIL;
-				_RETURN((p_a._get_obj().obj < p_b._get_obj().obj));
-			}
-
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_LESS, CALLABLE, <, Callable);
-			DEFAULT_OP_LOCALMEM_NULL(math, OP_LESS, SIGNAL, <, Signal);
-
-			CASE_TYPE(math, OP_LESS, ARRAY) {
-				if (p_b.type != ARRAY)
-					_RETURN_FAIL;
-
-				const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
-				const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
-
-				int l = arr_a->size();
-				if (arr_b->size() < l)
-					_RETURN(false);
-				for (int i = 0; i < l; i++) {
-					if (!((*arr_a)[i] < (*arr_b)[i])) {
-						_RETURN(true);
-					}
-				}
-
-				_RETURN(false);
-			}
-
-			DEFAULT_OP_NUM(math, OP_LESS, INT, <, _int);
-			DEFAULT_OP_NUM(math, OP_LESS, FLOAT, <, _float);
-			DEFAULT_OP_STR(math, OP_LESS, STRING, <, String);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR2, <, Vector2);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR2I, <, Vector2i);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR3, <, Vector3);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR3I, <, Vector3i);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS, _RID, <, RID);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_BYTE_ARRAY, uint8_t);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_INT32_ARRAY, int32_t);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_INT64_ARRAY, int64_t);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_FLOAT32_ARRAY, float);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_FLOAT64_ARRAY, double);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_STRING_ARRAY, String);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_VECTOR2_ARRAY, Vector3);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_VECTOR3_ARRAY, Vector3);
-			DEFAULT_OP_ARRAY_LT(math, OP_LESS, PACKED_COLOR_ARRAY, Color);
-
-			CASE_TYPE(math, OP_LESS, NIL)
-			CASE_TYPE(math, OP_LESS, RECT2)
-			CASE_TYPE(math, OP_LESS, RECT2I)
-			CASE_TYPE(math, OP_LESS, TRANSFORM2D)
-			CASE_TYPE(math, OP_LESS, PLANE)
-			CASE_TYPE(math, OP_LESS, QUAT)
-			CASE_TYPE(math, OP_LESS, AABB)
-			CASE_TYPE(math, OP_LESS, BASIS)
-			CASE_TYPE(math, OP_LESS, TRANSFORM)
-			CASE_TYPE(math, OP_LESS, COLOR)
-			CASE_TYPE(math, OP_LESS, STRING_NAME)
-			CASE_TYPE(math, OP_LESS, NODE_PATH)
-			CASE_TYPE(math, OP_LESS, DICTIONARY)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_LESS_EQUAL, p_a.type) {
-			CASE_TYPE(math, OP_LESS_EQUAL, OBJECT) {
-				if (p_b.type != OBJECT)
-					_RETURN_FAIL;
-				_RETURN((p_a._get_obj().obj <= p_b._get_obj().obj));
-			}
-
-			DEFAULT_OP_NUM(math, OP_LESS_EQUAL, INT, <=, _int);
-			DEFAULT_OP_NUM(math, OP_LESS_EQUAL, FLOAT, <=, _float);
-			DEFAULT_OP_STR(math, OP_LESS_EQUAL, STRING, <=, String);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR2, <=, Vector2);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR2I, <=, Vector2i);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR3, <=, Vector3);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR3I, <=, Vector3i);
-			DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, _RID, <=, RID);
-
-			CASE_TYPE(math, OP_LESS_EQUAL, NIL)
-			CASE_TYPE(math, OP_LESS_EQUAL, BOOL)
-			CASE_TYPE(math, OP_LESS_EQUAL, RECT2)
-			CASE_TYPE(math, OP_LESS_EQUAL, RECT2I)
-			CASE_TYPE(math, OP_LESS_EQUAL, TRANSFORM2D)
-			CASE_TYPE(math, OP_LESS_EQUAL, PLANE)
-			CASE_TYPE(math, OP_LESS_EQUAL, QUAT)
-			CASE_TYPE(math, OP_LESS_EQUAL, AABB)
-			CASE_TYPE(math, OP_LESS_EQUAL, BASIS)
-			CASE_TYPE(math, OP_LESS_EQUAL, TRANSFORM)
-			CASE_TYPE(math, OP_LESS_EQUAL, COLOR)
-			CASE_TYPE(math, OP_LESS_EQUAL, STRING_NAME)
-			CASE_TYPE(math, OP_LESS_EQUAL, NODE_PATH)
-			CASE_TYPE(math, OP_LESS_EQUAL, CALLABLE)
-			CASE_TYPE(math, OP_LESS_EQUAL, SIGNAL)
-
-			CASE_TYPE(math, OP_LESS_EQUAL, DICTIONARY)
-			CASE_TYPE(math, OP_LESS_EQUAL, ARRAY)
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_BYTE_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_INT32_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_INT64_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_FLOAT32_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_FLOAT64_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_STRING_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_VECTOR2_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_VECTOR3_ARRAY);
-			CASE_TYPE(math, OP_LESS_EQUAL, PACKED_COLOR_ARRAY);
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_GREATER, p_a.type) {
-			CASE_TYPE(math, OP_GREATER, BOOL) {
-				if (p_b.type != BOOL)
-					_RETURN_FAIL;
-
-				if (p_a._data._bool == p_b._data._bool)
-					_RETURN(false);
-
-				if (!p_a._data._bool && p_b._data._bool)
-					_RETURN(false);
-
-				_RETURN(true);
-			}
-
-			CASE_TYPE(math, OP_GREATER, OBJECT) {
-				if (p_b.type != OBJECT)
-					_RETURN_FAIL;
-				_RETURN((p_a._get_obj().obj > p_b._get_obj().obj));
-			}
-
-			CASE_TYPE(math, OP_GREATER, ARRAY) {
-				if (p_b.type != ARRAY)
-					_RETURN_FAIL;
-
-				const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
-				const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
-
-				int l = arr_a->size();
-				if (arr_b->size() > l)
-					_RETURN(false);
-				for (int i = 0; i < l; i++) {
-					if (((*arr_a)[i] < (*arr_b)[i])) {
-						_RETURN(false);
-					}
-				}
-
-				_RETURN(true);
-			}
-
-			DEFAULT_OP_NUM(math, OP_GREATER, INT, >, _int);
-			DEFAULT_OP_NUM(math, OP_GREATER, FLOAT, >, _float);
-			DEFAULT_OP_STR_REV(math, OP_GREATER, STRING, <, String);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR2, <, Vector2);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR2I, <, Vector2i);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR3, <, Vector3);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR3I, <, Vector3i);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, _RID, <, RID);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_BYTE_ARRAY, uint8_t);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_INT32_ARRAY, int32_t);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_INT64_ARRAY, int64_t);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_FLOAT32_ARRAY, float);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_FLOAT64_ARRAY, double);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_STRING_ARRAY, String);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_VECTOR2_ARRAY, Vector3);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_VECTOR3_ARRAY, Vector3);
-			DEFAULT_OP_ARRAY_GT(math, OP_GREATER, PACKED_COLOR_ARRAY, Color);
-
-			CASE_TYPE(math, OP_GREATER, NIL)
-			CASE_TYPE(math, OP_GREATER, RECT2)
-			CASE_TYPE(math, OP_GREATER, RECT2I)
-			CASE_TYPE(math, OP_GREATER, TRANSFORM2D)
-			CASE_TYPE(math, OP_GREATER, PLANE)
-			CASE_TYPE(math, OP_GREATER, QUAT)
-			CASE_TYPE(math, OP_GREATER, AABB)
-			CASE_TYPE(math, OP_GREATER, BASIS)
-			CASE_TYPE(math, OP_GREATER, TRANSFORM)
-			CASE_TYPE(math, OP_GREATER, COLOR)
-			CASE_TYPE(math, OP_GREATER, STRING_NAME)
-			CASE_TYPE(math, OP_GREATER, NODE_PATH)
-			CASE_TYPE(math, OP_GREATER, DICTIONARY)
-			CASE_TYPE(math, OP_GREATER, CALLABLE)
-			CASE_TYPE(math, OP_GREATER, SIGNAL)
-
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_GREATER_EQUAL, p_a.type) {
-			CASE_TYPE(math, OP_GREATER_EQUAL, OBJECT) {
-				if (p_b.type != OBJECT)
-					_RETURN_FAIL;
-				_RETURN((p_a._get_obj().obj >= p_b._get_obj().obj));
-			}
-
-			DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, INT, >=, _int);
-			DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, FLOAT, >=, _float);
-			DEFAULT_OP_STR_REV(math, OP_GREATER_EQUAL, STRING, <=, String);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR2, <=, Vector2);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR2I, <=, Vector2i);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR3, <=, Vector3);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR3I, <=, Vector3i);
-			DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, _RID, <=, RID);
-
-			CASE_TYPE(math, OP_GREATER_EQUAL, NIL)
-			CASE_TYPE(math, OP_GREATER_EQUAL, BOOL)
-			CASE_TYPE(math, OP_GREATER_EQUAL, RECT2)
-			CASE_TYPE(math, OP_GREATER_EQUAL, RECT2I)
-			CASE_TYPE(math, OP_GREATER_EQUAL, TRANSFORM2D)
-			CASE_TYPE(math, OP_GREATER_EQUAL, PLANE)
-			CASE_TYPE(math, OP_GREATER_EQUAL, QUAT)
-			CASE_TYPE(math, OP_GREATER_EQUAL, AABB)
-			CASE_TYPE(math, OP_GREATER_EQUAL, BASIS)
-			CASE_TYPE(math, OP_GREATER_EQUAL, TRANSFORM)
-			CASE_TYPE(math, OP_GREATER_EQUAL, COLOR)
-			CASE_TYPE(math, OP_GREATER_EQUAL, STRING_NAME)
-			CASE_TYPE(math, OP_GREATER_EQUAL, NODE_PATH)
-			CASE_TYPE(math, OP_GREATER_EQUAL, CALLABLE)
-			CASE_TYPE(math, OP_GREATER_EQUAL, SIGNAL)
-
-			CASE_TYPE(math, OP_GREATER_EQUAL, DICTIONARY)
-			CASE_TYPE(math, OP_GREATER_EQUAL, ARRAY)
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_BYTE_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_INT32_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_INT64_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_FLOAT32_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_FLOAT64_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_STRING_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_VECTOR2_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_VECTOR3_ARRAY);
-			CASE_TYPE(math, OP_GREATER_EQUAL, PACKED_COLOR_ARRAY);
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_ADD, p_a.type) {
-			CASE_TYPE(math, OP_ADD, ARRAY) {
-				if (p_a.type != p_b.type)
-					_RETURN_FAIL;
-
-				const Array &array_a = *reinterpret_cast<const Array *>(p_a._data._mem);
-				const Array &array_b = *reinterpret_cast<const Array *>(p_b._data._mem);
-				Array sum;
-				int asize = array_a.size();
-				int bsize = array_b.size();
-				sum.resize(asize + bsize);
-				for (int i = 0; i < asize; i++) {
-					sum[i] = array_a[i];
-				}
-				for (int i = 0; i < bsize; i++) {
-					sum[i + asize] = array_b[i];
-				}
-				_RETURN(sum);
-			}
-
-			DEFAULT_OP_NUM(math, OP_ADD, INT, +, _int);
-			DEFAULT_OP_NUM(math, OP_ADD, FLOAT, +, _float);
-			DEFAULT_OP_STR(math, OP_ADD, STRING, +, String);
-			DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR2, +, Vector2);
-			DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR2I, +, Vector2i);
-			DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR3, +, Vector3);
-			DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR3I, +, Vector3i);
-			DEFAULT_OP_LOCALMEM(math, OP_ADD, QUAT, +, Quat);
-			DEFAULT_OP_LOCALMEM(math, OP_ADD, COLOR, +, Color);
-
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_BYTE_ARRAY, uint8_t);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_INT32_ARRAY, int32_t);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_INT64_ARRAY, int64_t);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_FLOAT32_ARRAY, float);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_FLOAT64_ARRAY, double);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_STRING_ARRAY, String);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_VECTOR2_ARRAY, Vector2);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_VECTOR3_ARRAY, Vector3);
-			DEFAULT_OP_ARRAY_ADD(math, OP_ADD, PACKED_COLOR_ARRAY, Color);
-
-			CASE_TYPE(math, OP_ADD, NIL)
-			CASE_TYPE(math, OP_ADD, BOOL)
-			CASE_TYPE(math, OP_ADD, RECT2)
-			CASE_TYPE(math, OP_ADD, RECT2I)
-			CASE_TYPE(math, OP_ADD, TRANSFORM2D)
-			CASE_TYPE(math, OP_ADD, PLANE)
-			CASE_TYPE(math, OP_ADD, AABB)
-			CASE_TYPE(math, OP_ADD, BASIS)
-			CASE_TYPE(math, OP_ADD, TRANSFORM)
-			CASE_TYPE(math, OP_ADD, STRING_NAME)
-			CASE_TYPE(math, OP_ADD, NODE_PATH)
-			CASE_TYPE(math, OP_ADD, _RID)
-			CASE_TYPE(math, OP_ADD, OBJECT)
-			CASE_TYPE(math, OP_ADD, CALLABLE)
-			CASE_TYPE(math, OP_ADD, SIGNAL)
-
-			CASE_TYPE(math, OP_ADD, DICTIONARY)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_SUBTRACT, p_a.type) {
-			DEFAULT_OP_NUM(math, OP_SUBTRACT, INT, -, _int);
-			DEFAULT_OP_NUM(math, OP_SUBTRACT, FLOAT, -, _float);
-			DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR2, -, Vector2);
-			DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR2I, -, Vector2i);
-			DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR3, -, Vector3);
-			DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR3I, -, Vector3i);
-			DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, QUAT, -, Quat);
-			DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, COLOR, -, Color);
-
-			CASE_TYPE(math, OP_SUBTRACT, NIL)
-			CASE_TYPE(math, OP_SUBTRACT, BOOL)
-			CASE_TYPE(math, OP_SUBTRACT, STRING)
-			CASE_TYPE(math, OP_SUBTRACT, RECT2)
-			CASE_TYPE(math, OP_SUBTRACT, RECT2I)
-			CASE_TYPE(math, OP_SUBTRACT, TRANSFORM2D)
-			CASE_TYPE(math, OP_SUBTRACT, PLANE)
-			CASE_TYPE(math, OP_SUBTRACT, AABB)
-			CASE_TYPE(math, OP_SUBTRACT, BASIS)
-			CASE_TYPE(math, OP_SUBTRACT, TRANSFORM)
-			CASE_TYPE(math, OP_SUBTRACT, STRING_NAME)
-			CASE_TYPE(math, OP_SUBTRACT, NODE_PATH)
-			CASE_TYPE(math, OP_SUBTRACT, _RID)
-			CASE_TYPE(math, OP_SUBTRACT, OBJECT)
-			CASE_TYPE(math, OP_SUBTRACT, CALLABLE)
-			CASE_TYPE(math, OP_SUBTRACT, SIGNAL)
-
-			CASE_TYPE(math, OP_SUBTRACT, DICTIONARY)
-			CASE_TYPE(math, OP_SUBTRACT, ARRAY)
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_BYTE_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_INT32_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_INT64_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_FLOAT32_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_FLOAT64_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_STRING_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_VECTOR2_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_VECTOR3_ARRAY);
-			CASE_TYPE(math, OP_SUBTRACT, PACKED_COLOR_ARRAY);
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_MULTIPLY, p_a.type) {
-			CASE_TYPE(math, OP_MULTIPLY, TRANSFORM2D) {
-				switch (p_b.type) {
-					case TRANSFORM2D: {
-						_RETURN(*p_a._data._transform2d * *p_b._data._transform2d);
-					}
-					case VECTOR2: {
-						_RETURN(p_a._data._transform2d->xform(*(const Vector2 *)p_b._data._mem));
-					}
-					default:
-						_RETURN_FAIL;
-				}
-			}
-
-			CASE_TYPE(math, OP_MULTIPLY, QUAT) {
-				switch (p_b.type) {
-					case VECTOR3: {
-						_RETURN(reinterpret_cast<const Quat *>(p_a._data._mem)->xform(*(const Vector3 *)p_b._data._mem));
-					}
-					case QUAT: {
-						_RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * *reinterpret_cast<const Quat *>(p_b._data._mem));
-					}
-					case FLOAT: {
-						_RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * p_b._data._float);
-					}
-					case INT: {
-						_RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * p_b._data._int);
-					}
-					default:
-						_RETURN_FAIL;
-				}
-			}
-
-			CASE_TYPE(math, OP_MULTIPLY, BASIS) {
-				switch (p_b.type) {
-					case VECTOR3: {
-						_RETURN(p_a._data._basis->xform(*(const Vector3 *)p_b._data._mem));
-					}
-					case BASIS: {
-						_RETURN(*p_a._data._basis * *p_b._data._basis);
-					}
-					default:
-						_RETURN_FAIL;
-				}
-			}
-
-			CASE_TYPE(math, OP_MULTIPLY, TRANSFORM) {
-				switch (p_b.type) {
-					case VECTOR3: {
-						_RETURN(p_a._data._transform->xform(*(const Vector3 *)p_b._data._mem));
-					}
-					case TRANSFORM: {
-						_RETURN(*p_a._data._transform * *p_b._data._transform);
-					}
-					default:
-						_RETURN_FAIL;
-				}
-			}
-
-			CASE_TYPE(math, OP_MULTIPLY, INT) {
-				if (p_b.type == INT) {
-					_RETURN(p_a._data._int * p_b._data._int);
-				}
-				if (p_b.type == FLOAT) {
-					_RETURN(p_a._data._int * p_b._data._float);
-				}
-				if (p_b.type == VECTOR2) {
-					_RETURN(p_a._data._int * *reinterpret_cast<const Vector2 *>(p_b._data._mem));
-				}
-				if (p_b.type == VECTOR3) {
-					_RETURN(p_a._data._int * *reinterpret_cast<const Vector3 *>(p_b._data._mem));
-				}
-				if (p_b.type == VECTOR2I) {
-					_RETURN(p_a._data._int * *reinterpret_cast<const Vector2i *>(p_b._data._mem));
-				}
-				if (p_b.type == VECTOR3I) {
-					_RETURN(p_a._data._int * *reinterpret_cast<const Vector3i *>(p_b._data._mem));
-				}
-				if (p_b.type == QUAT) {
-					_RETURN(p_a._data._int * *reinterpret_cast<const Quat *>(p_b._data._mem));
-				}
-				if (p_b.type == COLOR) {
-					_RETURN(p_a._data._int * *reinterpret_cast<const Color *>(p_b._data._mem));
-				}
-
-				_RETURN_FAIL
-			}
-
-			CASE_TYPE(math, OP_MULTIPLY, FLOAT) {
-				if (p_b.type == INT) {
-					_RETURN(p_a._data._float * p_b._data._int);
-				}
-				if (p_b.type == FLOAT) {
-					_RETURN(p_a._data._float * p_b._data._float);
-				}
-				if (p_b.type == VECTOR2) {
-					_RETURN(p_a._data._float * *reinterpret_cast<const Vector2 *>(p_b._data._mem));
-				}
-				if (p_b.type == VECTOR3) {
-					_RETURN(p_a._data._float * *reinterpret_cast<const Vector3 *>(p_b._data._mem));
-				}
-				if (p_b.type == VECTOR2I) {
-					_RETURN(p_a._data._float * *reinterpret_cast<const Vector2i *>(p_b._data._mem));
-				}
-				if (p_b.type == VECTOR3I) {
-					_RETURN(p_a._data._float * *reinterpret_cast<const Vector3i *>(p_b._data._mem));
-				}
-				if (p_b.type == QUAT) {
-					_RETURN(p_a._data._float * *reinterpret_cast<const Quat *>(p_b._data._mem));
-				}
-				if (p_b.type == COLOR) {
-					_RETURN(p_a._data._float * *reinterpret_cast<const Color *>(p_b._data._mem));
-				}
-
-				_RETURN_FAIL
-			}
-
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR2, *, Vector2);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR2I, *, Vector2i);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR3, *, Vector3);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR3I, *, Vector3i);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, COLOR, *, Color);
-
-			CASE_TYPE(math, OP_MULTIPLY, NIL)
-			CASE_TYPE(math, OP_MULTIPLY, BOOL)
-			CASE_TYPE(math, OP_MULTIPLY, STRING)
-			CASE_TYPE(math, OP_MULTIPLY, RECT2)
-			CASE_TYPE(math, OP_MULTIPLY, RECT2I)
-			CASE_TYPE(math, OP_MULTIPLY, PLANE)
-			CASE_TYPE(math, OP_MULTIPLY, AABB)
-			CASE_TYPE(math, OP_MULTIPLY, STRING_NAME)
-			CASE_TYPE(math, OP_MULTIPLY, NODE_PATH)
-			CASE_TYPE(math, OP_MULTIPLY, _RID)
-			CASE_TYPE(math, OP_MULTIPLY, OBJECT)
-			CASE_TYPE(math, OP_MULTIPLY, CALLABLE)
-			CASE_TYPE(math, OP_MULTIPLY, SIGNAL)
-
-			CASE_TYPE(math, OP_MULTIPLY, DICTIONARY)
-			CASE_TYPE(math, OP_MULTIPLY, ARRAY)
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_BYTE_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_INT32_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_INT64_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_FLOAT32_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_FLOAT64_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_STRING_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_VECTOR2_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_VECTOR3_ARRAY);
-			CASE_TYPE(math, OP_MULTIPLY, PACKED_COLOR_ARRAY);
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_DIVIDE, p_a.type) {
-			CASE_TYPE(math, OP_DIVIDE, QUAT) {
-				if (p_b.type != FLOAT)
-					_RETURN_FAIL;
-#ifdef DEBUG_ENABLED
-				if (p_b._data._float == 0) {
-					r_valid = false;
-					_RETURN("Division By Zero");
-				}
-#endif
-				_RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) / p_b._data._float);
-			}
-
-			DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, INT, _int);
-			DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, FLOAT, _float);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR2, /, Vector2);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR2I, /, Vector2i);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR3, /, Vector3);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR3I, /, Vector3i);
-			DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, COLOR, /, Color);
-
-			CASE_TYPE(math, OP_DIVIDE, NIL)
-			CASE_TYPE(math, OP_DIVIDE, BOOL)
-			CASE_TYPE(math, OP_DIVIDE, STRING)
-			CASE_TYPE(math, OP_DIVIDE, RECT2)
-			CASE_TYPE(math, OP_DIVIDE, RECT2I)
-			CASE_TYPE(math, OP_DIVIDE, TRANSFORM2D)
-			CASE_TYPE(math, OP_DIVIDE, PLANE)
-			CASE_TYPE(math, OP_DIVIDE, AABB)
-			CASE_TYPE(math, OP_DIVIDE, BASIS)
-			CASE_TYPE(math, OP_DIVIDE, TRANSFORM)
-			CASE_TYPE(math, OP_DIVIDE, STRING_NAME)
-			CASE_TYPE(math, OP_DIVIDE, NODE_PATH)
-			CASE_TYPE(math, OP_DIVIDE, _RID)
-			CASE_TYPE(math, OP_DIVIDE, OBJECT)
-			CASE_TYPE(math, OP_DIVIDE, CALLABLE)
-			CASE_TYPE(math, OP_DIVIDE, SIGNAL)
-
-			CASE_TYPE(math, OP_DIVIDE, DICTIONARY)
-			CASE_TYPE(math, OP_DIVIDE, ARRAY)
-			CASE_TYPE(math, OP_DIVIDE, PACKED_BYTE_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_INT32_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_INT64_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_FLOAT32_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_FLOAT64_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_STRING_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_VECTOR2_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_VECTOR3_ARRAY);
-			CASE_TYPE(math, OP_DIVIDE, PACKED_COLOR_ARRAY);
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_POSITIVE, p_a.type) {
-			DEFAULT_OP_NUM_POS(math, OP_POSITIVE, INT, _int);
-			DEFAULT_OP_NUM_POS(math, OP_POSITIVE, FLOAT, _float);
-			DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR3, Vector3);
-			DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR3I, Vector3i);
-			DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, PLANE, Plane);
-			DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, QUAT, Quat);
-			DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR2, Vector2);
-			DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR2I, Vector2i);
-
-			CASE_TYPE(math, OP_POSITIVE, NIL)
-			CASE_TYPE(math, OP_POSITIVE, BOOL)
-			CASE_TYPE(math, OP_POSITIVE, STRING)
-			CASE_TYPE(math, OP_POSITIVE, RECT2)
-			CASE_TYPE(math, OP_POSITIVE, RECT2I)
-			CASE_TYPE(math, OP_POSITIVE, TRANSFORM2D)
-			CASE_TYPE(math, OP_POSITIVE, AABB)
-			CASE_TYPE(math, OP_POSITIVE, BASIS)
-			CASE_TYPE(math, OP_POSITIVE, TRANSFORM)
-			CASE_TYPE(math, OP_POSITIVE, COLOR)
-			CASE_TYPE(math, OP_POSITIVE, STRING_NAME)
-			CASE_TYPE(math, OP_POSITIVE, NODE_PATH)
-			CASE_TYPE(math, OP_POSITIVE, _RID)
-			CASE_TYPE(math, OP_POSITIVE, OBJECT)
-			CASE_TYPE(math, OP_POSITIVE, CALLABLE)
-			CASE_TYPE(math, OP_POSITIVE, SIGNAL)
-
-			CASE_TYPE(math, OP_POSITIVE, DICTIONARY)
-			CASE_TYPE(math, OP_POSITIVE, ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_BYTE_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_INT32_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_INT64_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_FLOAT32_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_FLOAT64_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_STRING_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_VECTOR2_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_VECTOR3_ARRAY)
-			CASE_TYPE(math, OP_POSITIVE, PACKED_COLOR_ARRAY)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_NEGATE, p_a.type) {
-			DEFAULT_OP_NUM_NEG(math, OP_NEGATE, INT, _int);
-			DEFAULT_OP_NUM_NEG(math, OP_NEGATE, FLOAT, _float);
-
-			DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR2, Vector2);
-			DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR2I, Vector2i);
-			DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR3, Vector3);
-			DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR3I, Vector3i);
-			DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, PLANE, Plane);
-			DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, QUAT, Quat);
-			DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, COLOR, Color);
-
-			CASE_TYPE(math, OP_NEGATE, NIL)
-			CASE_TYPE(math, OP_NEGATE, BOOL)
-			CASE_TYPE(math, OP_NEGATE, STRING)
-			CASE_TYPE(math, OP_NEGATE, RECT2)
-			CASE_TYPE(math, OP_NEGATE, RECT2I)
-			CASE_TYPE(math, OP_NEGATE, TRANSFORM2D)
-			CASE_TYPE(math, OP_NEGATE, AABB)
-			CASE_TYPE(math, OP_NEGATE, BASIS)
-			CASE_TYPE(math, OP_NEGATE, TRANSFORM)
-			CASE_TYPE(math, OP_NEGATE, STRING_NAME)
-			CASE_TYPE(math, OP_NEGATE, NODE_PATH)
-			CASE_TYPE(math, OP_NEGATE, _RID)
-			CASE_TYPE(math, OP_NEGATE, OBJECT)
-			CASE_TYPE(math, OP_NEGATE, CALLABLE)
-			CASE_TYPE(math, OP_NEGATE, SIGNAL)
-
-			CASE_TYPE(math, OP_NEGATE, DICTIONARY)
-			CASE_TYPE(math, OP_NEGATE, ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_BYTE_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_INT32_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_INT64_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_FLOAT32_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_FLOAT64_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_STRING_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_VECTOR2_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_VECTOR3_ARRAY)
-			CASE_TYPE(math, OP_NEGATE, PACKED_COLOR_ARRAY)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_MODULE, p_a.type) {
-			CASE_TYPE(math, OP_MODULE, INT) {
-				if (p_b.type != INT)
-					_RETURN_FAIL;
-#ifdef DEBUG_ENABLED
-				if (p_b._data._int == 0) {
-					r_valid = false;
-					_RETURN("Division By Zero");
-				}
-#endif
-				_RETURN(p_a._data._int % p_b._data._int);
-			}
-
-			CASE_TYPE(math, OP_MODULE, STRING) {
-				const String *format = reinterpret_cast<const String *>(p_a._data._mem);
-
-				String result;
-				bool error;
-				if (p_b.type == ARRAY) {
-					// e.g. "frog %s %d" % ["fish", 12]
-					const Array *args = reinterpret_cast<const Array *>(p_b._data._mem);
-					result = format->sprintf(*args, &error);
-				} else {
-					// e.g. "frog %d" % 12
-					Array args;
-					args.push_back(p_b);
-					result = format->sprintf(args, &error);
-				}
-				r_valid = !error;
-				_RETURN(result);
-			}
-
-			CASE_TYPE(math, OP_MODULE, NIL)
-			CASE_TYPE(math, OP_MODULE, BOOL)
-			CASE_TYPE(math, OP_MODULE, FLOAT)
-			CASE_TYPE(math, OP_MODULE, VECTOR2)
-			CASE_TYPE(math, OP_MODULE, VECTOR2I)
-			CASE_TYPE(math, OP_MODULE, RECT2)
-			CASE_TYPE(math, OP_MODULE, RECT2I)
-			CASE_TYPE(math, OP_MODULE, VECTOR3)
-			CASE_TYPE(math, OP_MODULE, VECTOR3I)
-			CASE_TYPE(math, OP_MODULE, TRANSFORM2D)
-			CASE_TYPE(math, OP_MODULE, PLANE)
-			CASE_TYPE(math, OP_MODULE, QUAT)
-			CASE_TYPE(math, OP_MODULE, AABB)
-			CASE_TYPE(math, OP_MODULE, BASIS)
-			CASE_TYPE(math, OP_MODULE, TRANSFORM)
-			CASE_TYPE(math, OP_MODULE, COLOR)
-			CASE_TYPE(math, OP_MODULE, STRING_NAME)
-			CASE_TYPE(math, OP_MODULE, NODE_PATH)
-			CASE_TYPE(math, OP_MODULE, _RID)
-			CASE_TYPE(math, OP_MODULE, OBJECT)
-			CASE_TYPE(math, OP_MODULE, CALLABLE)
-			CASE_TYPE(math, OP_MODULE, SIGNAL)
-
-			CASE_TYPE(math, OP_MODULE, DICTIONARY)
-			CASE_TYPE(math, OP_MODULE, ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_BYTE_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_INT32_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_INT64_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_FLOAT32_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_FLOAT64_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_STRING_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_VECTOR2_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_VECTOR3_ARRAY)
-			CASE_TYPE(math, OP_MODULE, PACKED_COLOR_ARRAY)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_STRING_CONCAT, p_a.type) {
-			CASE_TYPE_ALL(math, OP_STRING_CONCAT)
-
-			_RETURN(p_a.operator String() + p_b.operator String());
-		}
-
-		SWITCH_OP(math, OP_SHIFT_LEFT, p_a.type) {
-			CASE_TYPE(math, OP_SHIFT_LEFT, INT) {
-				if (p_b.type != INT)
-					_RETURN_FAIL;
-				if (p_b._data._int < 0 || p_b._data._int >= 64)
-					_RETURN_FAIL;
-				_RETURN(p_a._data._int << p_b._data._int);
-			}
-
-			CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_LEFT)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_SHIFT_RIGHT, p_a.type) {
-			CASE_TYPE(math, OP_SHIFT_RIGHT, INT) {
-				if (p_b.type != INT)
-					_RETURN_FAIL;
-				if (p_b._data._int < 0 || p_b._data._int >= 64)
-					_RETURN_FAIL;
-				_RETURN(p_a._data._int >> p_b._data._int);
-			}
-
-			CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_RIGHT)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_BIT_AND, p_a.type) {
-			CASE_TYPE(math, OP_BIT_AND, INT) {
-				if (p_b.type != INT)
-					_RETURN_FAIL;
-				_RETURN(p_a._data._int & p_b._data._int);
-			}
-
-			CASE_TYPE_ALL_BUT_INT(math, OP_BIT_AND)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_BIT_OR, p_a.type) {
-			CASE_TYPE(math, OP_BIT_OR, INT) {
-				if (p_b.type != INT)
-					_RETURN_FAIL;
-				_RETURN(p_a._data._int | p_b._data._int);
-			}
-
-			CASE_TYPE_ALL_BUT_INT(math, OP_BIT_OR)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_BIT_XOR, p_a.type) {
-			CASE_TYPE(math, OP_BIT_XOR, INT) {
-				if (p_b.type != INT)
-					_RETURN_FAIL;
-				_RETURN(p_a._data._int ^ p_b._data._int);
-			}
-
-			CASE_TYPE_ALL_BUT_INT(math, OP_BIT_XOR)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_BIT_NEGATE, p_a.type) {
-			CASE_TYPE(math, OP_BIT_NEGATE, INT) {
-				_RETURN(~p_a._data._int);
-			}
-
-			CASE_TYPE_ALL_BUT_INT(math, OP_BIT_NEGATE)
-			_RETURN_FAIL;
-		}
-
-		SWITCH_OP(math, OP_AND, p_a.type) {
-			CASE_TYPE_ALL(math, OP_AND) {
-				bool l = p_a.booleanize();
-				bool r = p_b.booleanize();
-
-				_RETURN(l && r);
-			}
-		}
-
-		SWITCH_OP(math, OP_OR, p_a.type) {
-			CASE_TYPE_ALL(math, OP_OR) {
-				bool l = p_a.booleanize();
-				bool r = p_b.booleanize();
-
-				_RETURN(l || r);
-			}
-		}
-
-		SWITCH_OP(math, OP_XOR, p_a.type) {
-			CASE_TYPE_ALL(math, OP_XOR) {
-				bool l = p_a.booleanize();
-				bool r = p_b.booleanize();
-
-				_RETURN((l || r) && !(l && r));
-			}
-		}
-
-		SWITCH_OP(math, OP_NOT, p_a.type) {
-			CASE_TYPE_ALL(math, OP_NOT) {
-				bool l = p_a.booleanize();
-				_RETURN(!l);
-			}
-		}
-
-		SWITCH_OP(math, OP_IN, p_a.type) {
-			CASE_TYPE_ALL(math, OP_IN)
-			_RETURN(p_b.in(p_a, &r_valid));
-		}
-	}
-}
-
-void Variant::set_named(const StringName &p_index, const Variant &p_value, bool *r_valid) {
-	bool valid = false;
-	switch (type) {
-		case VECTOR2: {
-			if (p_value.type == Variant::INT) {
-				Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._int;
-					valid = true;
-				}
-			} else if (p_value.type == Variant::FLOAT) {
-				Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._float;
-					valid = true;
-				}
-			}
-
-		} break;
-		case VECTOR2I: {
-			if (p_value.type == Variant::INT) {
-				Vector2i *v = reinterpret_cast<Vector2i *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._int;
-					valid = true;
-				}
-			} else if (p_value.type == Variant::FLOAT) {
-				Vector2i *v = reinterpret_cast<Vector2i *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._float;
-					valid = true;
-				}
-			}
-
-		} break;
-		case RECT2: {
-			if (p_value.type == Variant::VECTOR2) {
-				Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem);
-				//scalar name
-				if (p_index == CoreStringNames::singleton->position) {
-					v->position = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->size) {
-					v->size = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->end) {
-					v->size = *reinterpret_cast<const Vector2 *>(p_value._data._mem) - v->position;
-					valid = true;
-				}
-			}
-		} break;
-		case RECT2I: {
-			if (p_value.type == Variant::VECTOR2I) {
-				Rect2i *v = reinterpret_cast<Rect2i *>(_data._mem);
-				//scalar name
-				if (p_index == CoreStringNames::singleton->position) {
-					v->position = *reinterpret_cast<const Vector2i *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->size) {
-					v->size = *reinterpret_cast<const Vector2i *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->end) {
-					v->size = *reinterpret_cast<const Vector2i *>(p_value._data._mem) - v->position;
-					valid = true;
-				}
-			}
-		} break;
-		case TRANSFORM2D: {
-			if (p_value.type == Variant::VECTOR2) {
-				Transform2D *v = _data._transform2d;
-				if (p_index == CoreStringNames::singleton->x) {
-					v->elements[0] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->elements[1] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->origin) {
-					v->elements[2] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
-					valid = true;
-				}
-			}
-
-		} break;
-		case VECTOR3: {
-			if (p_value.type == Variant::INT) {
-				Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->z = p_value._data._int;
-					valid = true;
-				}
-			} else if (p_value.type == Variant::FLOAT) {
-				Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->z = p_value._data._float;
-					valid = true;
-				}
-			}
-
-		} break;
-		case VECTOR3I: {
-			if (p_value.type == Variant::INT) {
-				Vector3i *v = reinterpret_cast<Vector3i *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->z = p_value._data._int;
-					valid = true;
-				}
-			} else if (p_value.type == Variant::FLOAT) {
-				Vector3i *v = reinterpret_cast<Vector3i *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->z = p_value._data._float;
-					valid = true;
-				}
-			}
-
-		} break;
-		case PLANE: {
-			if (p_value.type == Variant::INT) {
-				Plane *v = reinterpret_cast<Plane *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->normal.x = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->normal.y = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->normal.z = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->d) {
-					v->d = p_value._data._int;
-					valid = true;
-				}
-			} else if (p_value.type == Variant::FLOAT) {
-				Plane *v = reinterpret_cast<Plane *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->normal.x = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->normal.y = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->normal.z = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->d) {
-					v->d = p_value._data._float;
-					valid = true;
-				}
-
-			} else if (p_value.type == Variant::VECTOR3) {
-				Plane *v = reinterpret_cast<Plane *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->normal) {
-					v->normal = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
-					valid = true;
-				}
-			}
-
-		} break;
-		case QUAT: {
-			if (p_value.type == Variant::INT) {
-				Quat *v = reinterpret_cast<Quat *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->z = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->w) {
-					v->w = p_value._data._int;
-					valid = true;
-				}
-			} else if (p_value.type == Variant::FLOAT) {
-				Quat *v = reinterpret_cast<Quat *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->x) {
-					v->x = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->y = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->z = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->w) {
-					v->w = p_value._data._float;
-					valid = true;
-				}
-			}
-
-		} break;
-		case AABB: {
-			if (p_value.type == Variant::VECTOR3) {
-				::AABB *v = _data._aabb;
-				//scalar name
-				if (p_index == CoreStringNames::singleton->position) {
-					v->position = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->size) {
-					v->size = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->end) {
-					v->size = *reinterpret_cast<const Vector3 *>(p_value._data._mem) - v->position;
-					valid = true;
-				}
-			}
-		} break;
-		case BASIS: {
-			if (p_value.type == Variant::VECTOR3) {
-				Basis *v = _data._basis;
-				//scalar name
-				if (p_index == CoreStringNames::singleton->x) {
-					v->set_axis(0, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->y) {
-					v->set_axis(1, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->z) {
-					v->set_axis(2, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
-					valid = true;
-				}
-			}
-		} break;
-		case TRANSFORM: {
-			if (p_value.type == Variant::BASIS && p_index == CoreStringNames::singleton->basis) {
-				_data._transform->basis = *p_value._data._basis;
-				valid = true;
-			} else if (p_value.type == Variant::VECTOR3 && p_index == CoreStringNames::singleton->origin) {
-				_data._transform->origin = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
-				valid = true;
-			}
-
-		} break;
-		case COLOR: {
-			if (p_value.type == Variant::INT) {
-				Color *v = reinterpret_cast<Color *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->r) {
-					v->r = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->g) {
-					v->g = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->b) {
-					v->b = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->a) {
-					v->a = p_value._data._int;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->r8) {
-					v->r = p_value._data._int / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->g8) {
-					v->g = p_value._data._int / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->b8) {
-					v->b = p_value._data._int / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->a8) {
-					v->a = p_value._data._int / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->h) {
-					v->set_hsv(p_value._data._int, v->get_s(), v->get_v(), v->a);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->s) {
-					v->set_hsv(v->get_h(), p_value._data._int, v->get_v(), v->a);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->v) {
-					v->set_hsv(v->get_h(), v->get_v(), p_value._data._int, v->a);
-					valid = true;
-				}
-			} else if (p_value.type == Variant::FLOAT) {
-				Color *v = reinterpret_cast<Color *>(_data._mem);
-				if (p_index == CoreStringNames::singleton->r) {
-					v->r = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->g) {
-					v->g = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->b) {
-					v->b = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->a) {
-					v->a = p_value._data._float;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->r8) {
-					v->r = p_value._data._float / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->g8) {
-					v->g = p_value._data._float / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->b8) {
-					v->b = p_value._data._float / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->a8) {
-					v->a = p_value._data._float / 255.0;
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->h) {
-					v->set_hsv(p_value._data._float, v->get_s(), v->get_v(), v->a);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->s) {
-					v->set_hsv(v->get_h(), p_value._data._float, v->get_v(), v->a);
-					valid = true;
-				} else if (p_index == CoreStringNames::singleton->v) {
-					v->set_hsv(v->get_h(), v->get_s(), p_value._data._float, v->a);
-					valid = true;
-				}
-			}
-		} break;
-		case OBJECT: {
-#ifdef DEBUG_ENABLED
-			if (!_get_obj().obj) {
-				break;
-			} else if (EngineDebugger::is_active() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-				break;
-			}
-
-#endif
-			_get_obj().obj->set(p_index, p_value, &valid);
-
-		} break;
-		default: {
-			set(p_index.operator String(), p_value, &valid);
-		} break;
-	}
-
-	if (r_valid) {
-		*r_valid = valid;
-	}
-}
-
-Variant Variant::get_named(const StringName &p_index, bool *r_valid) const {
-	if (r_valid) {
-		*r_valid = true;
-	}
-
-	switch (type) {
-		case VECTOR2: {
-			const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->x;
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->y;
-			}
-
-		} break;
-		case VECTOR2I: {
-			const Vector2i *v = reinterpret_cast<const Vector2i *>(_data._mem);
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->x;
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->y;
-			}
-
-		} break;
-		case RECT2: {
-			const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem);
-			//scalar name
-			if (p_index == CoreStringNames::singleton->position) {
-				return v->position;
-			} else if (p_index == CoreStringNames::singleton->size) {
-				return v->size;
-			} else if (p_index == CoreStringNames::singleton->end) {
-				return v->size + v->position;
-			}
-		} break;
-		case RECT2I: {
-			const Rect2i *v = reinterpret_cast<const Rect2i *>(_data._mem);
-			//scalar name
-			if (p_index == CoreStringNames::singleton->position) {
-				return v->position;
-			} else if (p_index == CoreStringNames::singleton->size) {
-				return v->size;
-			} else if (p_index == CoreStringNames::singleton->end) {
-				return v->size + v->position;
-			}
-		} break;
-		case TRANSFORM2D: {
-			const Transform2D *v = _data._transform2d;
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->elements[0];
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->elements[1];
-			} else if (p_index == CoreStringNames::singleton->origin) {
-				return v->elements[2];
-			}
-
-		} break;
-		case VECTOR3: {
-			const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->x;
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->y;
-			} else if (p_index == CoreStringNames::singleton->z) {
-				return v->z;
-			}
-
-		} break;
-		case VECTOR3I: {
-			const Vector3i *v = reinterpret_cast<const Vector3i *>(_data._mem);
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->x;
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->y;
-			} else if (p_index == CoreStringNames::singleton->z) {
-				return v->z;
-			}
-
-		} break;
-		case PLANE: {
-			const Plane *v = reinterpret_cast<const Plane *>(_data._mem);
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->normal.x;
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->normal.y;
-			} else if (p_index == CoreStringNames::singleton->z) {
-				return v->normal.z;
-			} else if (p_index == CoreStringNames::singleton->d) {
-				return v->d;
-			} else if (p_index == CoreStringNames::singleton->normal) {
-				return v->normal;
-			}
-
-		} break;
-		case QUAT: {
-			const Quat *v = reinterpret_cast<const Quat *>(_data._mem);
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->x;
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->y;
-			} else if (p_index == CoreStringNames::singleton->z) {
-				return v->z;
-			} else if (p_index == CoreStringNames::singleton->w) {
-				return v->w;
-			}
-
-		} break;
-		case AABB: {
-			const ::AABB *v = _data._aabb;
-			//scalar name
-			if (p_index == CoreStringNames::singleton->position) {
-				return v->position;
-			} else if (p_index == CoreStringNames::singleton->size) {
-				return v->size;
-			} else if (p_index == CoreStringNames::singleton->end) {
-				return v->size + v->position;
-			}
-		} break;
-		case BASIS: {
-			const Basis *v = _data._basis;
-			//scalar name
-			if (p_index == CoreStringNames::singleton->x) {
-				return v->get_axis(0);
-			} else if (p_index == CoreStringNames::singleton->y) {
-				return v->get_axis(1);
-			} else if (p_index == CoreStringNames::singleton->z) {
-				return v->get_axis(2);
-			}
-
-		} break;
-		case TRANSFORM: {
-			if (p_index == CoreStringNames::singleton->basis) {
-				return _data._transform->basis;
-			} else if (p_index == CoreStringNames::singleton->origin) {
-				return _data._transform->origin;
-			}
-
-		} break;
-		case COLOR: {
-			const Color *v = reinterpret_cast<const Color *>(_data._mem);
-			if (p_index == CoreStringNames::singleton->r) {
-				return v->r;
-			} else if (p_index == CoreStringNames::singleton->g) {
-				return v->g;
-			} else if (p_index == CoreStringNames::singleton->b) {
-				return v->b;
-			} else if (p_index == CoreStringNames::singleton->a) {
-				return v->a;
-			} else if (p_index == CoreStringNames::singleton->r8) {
-				return int(Math::round(v->r * 255.0));
-			} else if (p_index == CoreStringNames::singleton->g8) {
-				return int(Math::round(v->g * 255.0));
-			} else if (p_index == CoreStringNames::singleton->b8) {
-				return int(Math::round(v->b * 255.0));
-			} else if (p_index == CoreStringNames::singleton->a8) {
-				return int(Math::round(v->a * 255.0));
-			} else if (p_index == CoreStringNames::singleton->h) {
-				return v->get_h();
-			} else if (p_index == CoreStringNames::singleton->s) {
-				return v->get_s();
-			} else if (p_index == CoreStringNames::singleton->v) {
-				return v->get_v();
-			}
-		} break;
-		case OBJECT: {
-#ifdef DEBUG_ENABLED
-			if (!_get_obj().obj) {
-				if (r_valid) {
-					*r_valid = false;
-				}
-				return "Instance base is null.";
-			} else {
-				if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-					if (r_valid) {
-						*r_valid = false;
-					}
-					return "Attempted use of stray pointer object.";
-				}
-			}
-
-#endif
-
-			return _get_obj().obj->get(p_index, r_valid);
-
-		} break;
-		default: {
-			return get(p_index.operator String(), r_valid);
-		}
-	}
-
-	if (r_valid) {
-		*r_valid = false;
-	}
-	return Variant();
-}
-
-#define DEFAULT_OP_ARRAY_CMD(m_name, m_type, skip_test, cmd)                              \
-	case m_name: {                                                                        \
-		skip_test;                                                                        \
-                                                                                          \
-		if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { \
-			int index = p_index;                                                          \
-			m_type *arr = reinterpret_cast<m_type *>(_data._mem);                         \
-                                                                                          \
-			if (index < 0)                                                                \
-				index += arr->size();                                                     \
-			if (index >= 0 && index < arr->size()) {                                      \
-				valid = true;                                                             \
-				cmd;                                                                      \
-			}                                                                             \
-		}                                                                                 \
-	} break;
-
-#define DEFAULT_OP_DVECTOR_SET(m_name, m_type, skip_cond)                                    \
-	case m_name: {                                                                           \
-		if (skip_cond)                                                                       \
-			return;                                                                          \
-                                                                                             \
-		if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {    \
-			int index = p_index;                                                             \
-			Vector<m_type> *arr = PackedArrayRef<m_type>::get_array_ptr(_data.packed_array); \
-                                                                                             \
-			if (index < 0)                                                                   \
-				index += arr->size();                                                        \
-			if (index >= 0 && index < arr->size()) {                                         \
-				valid = true;                                                                \
-				arr->set(index, p_value);                                                    \
-			}                                                                                \
-		}                                                                                    \
-	} break;
-
-#define DEFAULT_OP_DVECTOR_GET(m_name, m_type)                                                  \
-	case m_name: {                                                                              \
-		if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {       \
-			int index = p_index;                                                                \
-			const Vector<m_type> *arr = &PackedArrayRef<m_type>::get_array(_data.packed_array); \
-                                                                                                \
-			if (index < 0)                                                                      \
-				index += arr->size();                                                           \
-			if (index >= 0 && index < arr->size()) {                                            \
-				valid = true;                                                                   \
-				return arr->get(index);                                                         \
-			}                                                                                   \
-		}                                                                                       \
-	} break;
-
-void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) {
-	static bool _dummy = false;
-
-	bool &valid = r_valid ? *r_valid : _dummy;
-	valid = false;
-
-	switch (type) {
-		case NIL: {
-			return;
-		} break;
-		case BOOL: {
-			return;
-		} break;
-		case INT: {
-			return;
-		} break;
-		case FLOAT: {
-			return;
-		} break;
-		case STRING: {
-			if (p_index.type != Variant::INT && p_index.type != Variant::FLOAT) {
-				return;
-			}
-
-			int idx = p_index;
-			String *str = reinterpret_cast<String *>(_data._mem);
-			int len = str->length();
-			if (idx < 0) {
-				idx += len;
-			}
-			if (idx < 0 || idx >= len) {
-				return;
-			}
-
-			String chr;
-			if (p_value.type == Variant::INT || p_value.type == Variant::FLOAT) {
-				chr = String::chr(p_value);
-			} else if (p_value.type == Variant::STRING) {
-				chr = p_value;
-			} else {
-				return;
-			}
-
-			*str = str->substr(0, idx) + chr + str->substr(idx + 1, len);
-			valid = true;
-			return;
-
-		} break;
-		case VECTOR2: {
-			if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				// scalar index
-				int idx = p_index;
-
-				if (idx < 0) {
-					idx += 2;
-				}
-				if (idx >= 0 && idx < 2) {
-					Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
-					valid = true;
-					(*v)[idx] = p_value;
-					return;
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					v->x = p_value;
-					return;
-				} else if (*str == "y") {
-					valid = true;
-					v->y = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case VECTOR2I: {
-			if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				// scalar index
-				int idx = p_index;
-
-				if (idx < 0) {
-					idx += 2;
-				}
-				if (idx >= 0 && idx < 2) {
-					Vector2i *v = reinterpret_cast<Vector2i *>(_data._mem);
-					valid = true;
-					(*v)[idx] = p_value;
-					return;
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Vector2i *v = reinterpret_cast<Vector2i *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					v->x = p_value;
-					return;
-				} else if (*str == "y") {
-					valid = true;
-					v->y = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case RECT2: {
-			if (p_value.type != Variant::VECTOR2) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem);
-				if (*str == "position") {
-					valid = true;
-					v->position = p_value;
-					return;
-				} else if (*str == "size") {
-					valid = true;
-					v->size = p_value;
-					return;
-				} else if (*str == "end") {
-					valid = true;
-					v->size = Vector2(p_value) - v->position;
-					return;
-				}
-			}
-		} break;
-		case RECT2I: {
-			if (p_value.type != Variant::VECTOR2I) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Rect2i *v = reinterpret_cast<Rect2i *>(_data._mem);
-				if (*str == "position") {
-					valid = true;
-					v->position = p_value;
-					return;
-				} else if (*str == "size") {
-					valid = true;
-					v->size = p_value;
-					return;
-				} else if (*str == "end") {
-					valid = true;
-					v->size = Vector2i(p_value) - v->position;
-					return;
-				}
-			}
-		} break;
-		case TRANSFORM2D: {
-			if (p_value.type != Variant::VECTOR2) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int index = p_index;
-
-				if (index < 0) {
-					index += 3;
-				}
-				if (index >= 0 && index < 3) {
-					Transform2D *v = _data._transform2d;
-
-					valid = true;
-					v->elements[index] = p_value;
-					return;
-				}
-			} else if (p_index.get_type() == Variant::STRING && p_value.get_type() == Variant::VECTOR2) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Transform2D *v = _data._transform2d;
-				if (*str == "x") {
-					valid = true;
-					v->elements[0] = p_value;
-					return;
-				} else if (*str == "y") {
-					valid = true;
-					v->elements[1] = p_value;
-					return;
-				} else if (*str == "origin") {
-					valid = true;
-					v->elements[2] = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case VECTOR3: {
-			if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				//scalar index
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 3;
-				}
-				if (idx >= 0 && idx < 3) {
-					Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
-					valid = true;
-					(*v)[idx] = p_value;
-					return;
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					v->x = p_value;
-					return;
-				} else if (*str == "y") {
-					valid = true;
-					v->y = p_value;
-					return;
-				} else if (*str == "z") {
-					valid = true;
-					v->z = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case VECTOR3I: {
-			if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				//scalar index
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 3;
-				}
-				if (idx >= 0 && idx < 3) {
-					Vector3i *v = reinterpret_cast<Vector3i *>(_data._mem);
-					valid = true;
-					(*v)[idx] = p_value;
-					return;
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Vector3i *v = reinterpret_cast<Vector3i *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					v->x = p_value;
-					return;
-				} else if (*str == "y") {
-					valid = true;
-					v->y = p_value;
-					return;
-				} else if (*str == "z") {
-					valid = true;
-					v->z = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case PLANE: {
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Plane *v = reinterpret_cast<Plane *>(_data._mem);
-				if (*str == "x") {
-					if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-						return;
-					}
-
-					valid = true;
-					v->normal.x = p_value;
-					return;
-				} else if (*str == "y") {
-					if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-						return;
-					}
-
-					valid = true;
-					v->normal.y = p_value;
-					return;
-				} else if (*str == "z") {
-					if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-						return;
-					}
-
-					valid = true;
-					v->normal.z = p_value;
-					return;
-				} else if (*str == "normal") {
-					if (p_value.type != Variant::VECTOR3) {
-						return;
-					}
-
-					valid = true;
-					v->normal = p_value;
-					return;
-				} else if (*str == "d") {
-					valid = true;
-					v->d = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case QUAT: {
-			if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::STRING) {
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Quat *v = reinterpret_cast<Quat *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					v->x = p_value;
-					return;
-				} else if (*str == "y") {
-					valid = true;
-					v->y = p_value;
-					return;
-				} else if (*str == "z") {
-					valid = true;
-					v->z = p_value;
-					return;
-				} else if (*str == "w") {
-					valid = true;
-					v->w = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case AABB: {
-			if (p_value.type != Variant::VECTOR3) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				::AABB *v = _data._aabb;
-				if (*str == "position") {
-					valid = true;
-					v->position = p_value;
-					return;
-				} else if (*str == "size") {
-					valid = true;
-					v->size = p_value;
-					return;
-				} else if (*str == "end") {
-					valid = true;
-					v->size = Vector3(p_value) - v->position;
-					return;
-				}
-			}
-		} break;
-		case BASIS: {
-			if (p_value.type != Variant::VECTOR3) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int index = p_index;
-
-				if (index < 0) {
-					index += 3;
-				}
-				if (index >= 0 && index < 3) {
-					Basis *v = _data._basis;
-
-					valid = true;
-					v->set_axis(index, p_value);
-					return;
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Basis *v = _data._basis;
-
-				if (*str == "x") {
-					valid = true;
-					v->set_axis(0, p_value);
-					return;
-				} else if (*str == "y") {
-					valid = true;
-					v->set_axis(1, p_value);
-					return;
-				} else if (*str == "z") {
-					valid = true;
-					v->set_axis(2, p_value);
-					return;
-				}
-			}
-
-		} break;
-		case TRANSFORM: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				if (p_value.type != Variant::VECTOR3) {
-					return;
-				}
-
-				int index = p_index;
-
-				if (index < 0) {
-					index += 4;
-				}
-				if (index >= 0 && index < 4) {
-					Transform *v = _data._transform;
-					valid = true;
-					if (index == 3) {
-						v->origin = p_value;
-					} else {
-						v->basis.set_axis(index, p_value);
-					}
-					return;
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				Transform *v = _data._transform;
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-
-				if (*str == "basis") {
-					if (p_value.type != Variant::BASIS) {
-						return;
-					}
-					valid = true;
-					v->basis = p_value;
-					return;
-				}
-				if (*str == "origin") {
-					if (p_value.type != Variant::VECTOR3) {
-						return;
-					}
-					valid = true;
-					v->origin = p_value;
-					return;
-				}
-			}
-
-		} break;
-		case COLOR: {
-			if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) {
-				return;
-			}
-
-			if (p_index.get_type() == Variant::STRING) {
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				Color *v = reinterpret_cast<Color *>(_data._mem);
-				if (*str == "r") {
-					valid = true;
-					v->r = p_value;
-					return;
-				} else if (*str == "g") {
-					valid = true;
-					v->g = p_value;
-					return;
-				} else if (*str == "b") {
-					valid = true;
-					v->b = p_value;
-					return;
-				} else if (*str == "a") {
-					valid = true;
-					v->a = p_value;
-					return;
-				} else if (*str == "h") {
-					valid = true;
-					v->set_hsv(p_value, v->get_s(), v->get_v(), v->a);
-					return;
-				} else if (*str == "s") {
-					valid = true;
-					v->set_hsv(v->get_h(), p_value, v->get_v(), v->a);
-					return;
-				} else if (*str == "v") {
-					valid = true;
-					v->set_hsv(v->get_h(), v->get_s(), p_value, v->a);
-					return;
-				} else if (*str == "r8") {
-					valid = true;
-					v->r = float(p_value) / 255.0;
-					return;
-				} else if (*str == "g8") {
-					valid = true;
-					v->g = float(p_value) / 255.0;
-					return;
-				} else if (*str == "b8") {
-					valid = true;
-					v->b = float(p_value) / 255.0;
-					return;
-				} else if (*str == "a8") {
-					valid = true;
-					v->a = float(p_value) / 255.0;
-					return;
-				}
-			} else if (p_index.get_type() == Variant::INT) {
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 4;
-				}
-				if (idx >= 0 && idx < 4) {
-					Color *v = reinterpret_cast<Color *>(_data._mem);
-					(*v)[idx] = p_value;
-					valid = true;
-				}
-			}
-
-		} break;
-		case STRING_NAME: {
-		} break;
-		case NODE_PATH: {
-		} break;
-		case _RID: {
-		} break;
-		case OBJECT: {
-			Object *obj = _get_obj().obj;
-			//only if debugging!
-
-			if (obj) {
-#ifdef DEBUG_ENABLED
-				if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-					WARN_PRINT("Attempted use of previously freed pointer object.");
-					valid = false;
-					return;
-				}
-#endif
-
-				if (p_index.get_type() != Variant::STRING_NAME && p_index.get_type() != Variant::STRING) {
-					obj->setvar(p_index, p_value, r_valid);
-					return;
-				}
-
-				obj->set(p_index, p_value, r_valid);
-				return;
-			}
-		} break;
-		case DICTIONARY: {
-			Dictionary *dic = reinterpret_cast<Dictionary *>(_data._mem);
-			dic->operator[](p_index) = p_value;
-			valid = true; //always valid, i guess? should this really be ok?
-			return;
-		} break;
-			DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return )
-			DEFAULT_OP_DVECTOR_SET(PACKED_BYTE_ARRAY, uint8_t, p_value.type != Variant::FLOAT && p_value.type != Variant::INT)
-			DEFAULT_OP_DVECTOR_SET(PACKED_INT32_ARRAY, int32_t, p_value.type != Variant::FLOAT && p_value.type != Variant::INT)
-			DEFAULT_OP_DVECTOR_SET(PACKED_INT64_ARRAY, int64_t, p_value.type != Variant::FLOAT && p_value.type != Variant::INT)
-			DEFAULT_OP_DVECTOR_SET(PACKED_FLOAT32_ARRAY, float, p_value.type != Variant::FLOAT && p_value.type != Variant::INT)
-			DEFAULT_OP_DVECTOR_SET(PACKED_FLOAT64_ARRAY, double, p_value.type != Variant::FLOAT && p_value.type != Variant::INT)
-			DEFAULT_OP_DVECTOR_SET(PACKED_STRING_ARRAY, String, p_value.type != Variant::STRING)
-			DEFAULT_OP_DVECTOR_SET(PACKED_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2)
-			DEFAULT_OP_DVECTOR_SET(PACKED_VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3)
-			DEFAULT_OP_DVECTOR_SET(PACKED_COLOR_ARRAY, Color, p_value.type != Variant::COLOR)
-		default:
-			return;
-	}
-}
-
-Variant Variant::get(const Variant &p_index, bool *r_valid) const {
-	static bool _dummy = false;
-
-	bool &valid = r_valid ? *r_valid : _dummy;
-
-	valid = false;
-
-	switch (type) {
-		case NIL: {
-			return Variant();
-		} break;
-		case BOOL: {
-			return Variant();
-		} break;
-		case INT: {
-			return Variant();
-		} break;
-		case FLOAT: {
-			return Variant();
-		} break;
-		case STRING: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				//string index
-
-				int idx = p_index;
-				const String *str = reinterpret_cast<const String *>(_data._mem);
-				if (idx < 0) {
-					idx += str->length();
-				}
-				if (idx >= 0 && idx < str->length()) {
-					valid = true;
-					return str->substr(idx, 1);
-				}
-			}
-
-		} break;
-		case VECTOR2: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				// scalar index
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 2;
-				}
-				if (idx >= 0 && idx < 2) {
-					const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
-					valid = true;
-					return (*v)[idx];
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					return v->x;
-				} else if (*str == "y") {
-					valid = true;
-					return v->y;
-				}
-			}
-
-		} break;
-		case VECTOR2I: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				// scalar index
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 2;
-				}
-				if (idx >= 0 && idx < 2) {
-					const Vector2i *v = reinterpret_cast<const Vector2i *>(_data._mem);
-					valid = true;
-					return (*v)[idx];
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Vector2i *v = reinterpret_cast<const Vector2i *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					return v->x;
-				} else if (*str == "y") {
-					valid = true;
-					return v->y;
-				}
-			}
-
-		} break;
-		case RECT2: {
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem);
-				if (*str == "position") {
-					valid = true;
-					return v->position;
-				} else if (*str == "size") {
-					valid = true;
-					return v->size;
-				} else if (*str == "end") {
-					valid = true;
-					return v->size + v->position;
-				}
-			}
-		} break;
-		case RECT2I: {
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Rect2i *v = reinterpret_cast<const Rect2i *>(_data._mem);
-				if (*str == "position") {
-					valid = true;
-					return v->position;
-				} else if (*str == "size") {
-					valid = true;
-					return v->size;
-				} else if (*str == "end") {
-					valid = true;
-					return v->size + v->position;
-				}
-			}
-		} break;
-		case VECTOR3: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				//scalar index
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 3;
-				}
-				if (idx >= 0 && idx < 3) {
-					const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
-					valid = true;
-					return (*v)[idx];
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					return v->x;
-				} else if (*str == "y") {
-					valid = true;
-					return v->y;
-				} else if (*str == "z") {
-					valid = true;
-					return v->z;
-				}
-			}
-
-		} break;
-		case VECTOR3I: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				//scalar index
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 3;
-				}
-				if (idx >= 0 && idx < 3) {
-					const Vector3i *v = reinterpret_cast<const Vector3i *>(_data._mem);
-					valid = true;
-					return (*v)[idx];
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Vector3i *v = reinterpret_cast<const Vector3i *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					return v->x;
-				} else if (*str == "y") {
-					valid = true;
-					return v->y;
-				} else if (*str == "z") {
-					valid = true;
-					return v->z;
-				}
-			}
-
-		} break;
-		case TRANSFORM2D: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int index = p_index;
-
-				if (index < 0) {
-					index += 3;
-				}
-				if (index >= 0 && index < 3) {
-					const Transform2D *v = _data._transform2d;
-
-					valid = true;
-					return v->elements[index];
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Transform2D *v = _data._transform2d;
-				if (*str == "x") {
-					valid = true;
-					return v->elements[0];
-				} else if (*str == "y") {
-					valid = true;
-					return v->elements[1];
-				} else if (*str == "origin") {
-					valid = true;
-					return v->elements[2];
-				}
-			}
-
-		} break;
-		case PLANE: {
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Plane *v = reinterpret_cast<const Plane *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					return v->normal.x;
-				} else if (*str == "y") {
-					valid = true;
-					return v->normal.y;
-				} else if (*str == "z") {
-					valid = true;
-					return v->normal.z;
-				} else if (*str == "normal") {
-					valid = true;
-					return v->normal;
-				} else if (*str == "d") {
-					valid = true;
-					return v->d;
-				}
-			}
-
-		} break;
-		case QUAT: {
-			if (p_index.get_type() == Variant::STRING) {
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Quat *v = reinterpret_cast<const Quat *>(_data._mem);
-				if (*str == "x") {
-					valid = true;
-					return v->x;
-				} else if (*str == "y") {
-					valid = true;
-					return v->y;
-				} else if (*str == "z") {
-					valid = true;
-					return v->z;
-				} else if (*str == "w") {
-					valid = true;
-					return v->w;
-				}
-			}
-
-		} break;
-		case AABB: {
-			if (p_index.get_type() == Variant::STRING) {
-				//scalar name
-
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const ::AABB *v = _data._aabb;
-				if (*str == "position") {
-					valid = true;
-					return v->position;
-				} else if (*str == "size") {
-					valid = true;
-					return v->size;
-				} else if (*str == "end") {
-					valid = true;
-					return v->size + v->position;
-				}
-			}
-		} break;
-		case BASIS: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int index = p_index;
-				if (index < 0) {
-					index += 3;
-				}
-				if (index >= 0 && index < 3) {
-					const Basis *v = _data._basis;
-
-					valid = true;
-					return v->get_axis(index);
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Basis *v = _data._basis;
-
-				if (*str == "x") {
-					valid = true;
-					return v->get_axis(0);
-				} else if (*str == "y") {
-					valid = true;
-					return v->get_axis(1);
-				} else if (*str == "z") {
-					valid = true;
-					return v->get_axis(2);
-				}
-			}
-
-		} break;
-		case TRANSFORM: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int index = p_index;
-				if (index < 0) {
-					index += 4;
-				}
-				if (index >= 0 && index < 4) {
-					const Transform *v = _data._transform;
-					valid = true;
-					return index == 3 ? v->origin : v->basis.get_axis(index);
-				}
-			} else if (p_index.get_type() == Variant::STRING) {
-				const Transform *v = _data._transform;
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-
-				if (*str == "basis") {
-					valid = true;
-					return v->basis;
-				}
-				if (*str == "origin") {
-					valid = true;
-					return v->origin;
-				}
-			}
-
-		} break;
-		case COLOR: {
-			if (p_index.get_type() == Variant::STRING) {
-				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
-				const Color *v = reinterpret_cast<const Color *>(_data._mem);
-				if (*str == "r") {
-					valid = true;
-					return v->r;
-				} else if (*str == "g") {
-					valid = true;
-					return v->g;
-				} else if (*str == "b") {
-					valid = true;
-					return v->b;
-				} else if (*str == "a") {
-					valid = true;
-					return v->a;
-				} else if (*str == "h") {
-					valid = true;
-					return v->get_h();
-				} else if (*str == "s") {
-					valid = true;
-					return v->get_s();
-				} else if (*str == "v") {
-					valid = true;
-					return v->get_v();
-				} else if (*str == "r8") {
-					valid = true;
-					return (int)Math::round(v->r * 255.0);
-				} else if (*str == "g8") {
-					valid = true;
-					return (int)Math::round(v->g * 255.0);
-				} else if (*str == "b8") {
-					valid = true;
-					return (int)Math::round(v->b * 255.0);
-				} else if (*str == "a8") {
-					valid = true;
-					return (int)Math::round(v->a * 255.0);
-				}
-			} else if (p_index.get_type() == Variant::INT) {
-				int idx = p_index;
-				if (idx < 0) {
-					idx += 4;
-				}
-				if (idx >= 0 && idx < 4) {
-					const Color *v = reinterpret_cast<const Color *>(_data._mem);
-					valid = true;
-					return (*v)[idx];
-				}
-			}
-
-		} break;
-		case STRING_NAME: {
-		} break;
-		case NODE_PATH: {
-		} break;
-		case _RID: {
-		} break;
-		case OBJECT: {
-			Object *obj = _get_obj().obj;
-			if (obj) {
-#ifdef DEBUG_ENABLED
-
-				if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-					valid = false;
-					return "Attempted get on previously freed instance.";
-				}
-#endif
-
-				if (p_index.get_type() != Variant::STRING) {
-					return obj->getvar(p_index, r_valid);
-				}
-
-				return obj->get(p_index, r_valid);
-			}
-
-		} break;
-		case DICTIONARY: {
-			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
-			const Variant *res = dic->getptr(p_index);
-			if (res) {
-				valid = true;
-				return *res;
-			}
-		} break;
-			DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index])
-			DEFAULT_OP_DVECTOR_GET(PACKED_BYTE_ARRAY, uint8_t)
-			DEFAULT_OP_DVECTOR_GET(PACKED_INT32_ARRAY, int32_t)
-			DEFAULT_OP_DVECTOR_GET(PACKED_INT64_ARRAY, int64_t)
-			DEFAULT_OP_DVECTOR_GET(PACKED_FLOAT32_ARRAY, float)
-			DEFAULT_OP_DVECTOR_GET(PACKED_FLOAT64_ARRAY, double)
-			DEFAULT_OP_DVECTOR_GET(PACKED_STRING_ARRAY, String)
-			DEFAULT_OP_DVECTOR_GET(PACKED_VECTOR2_ARRAY, Vector2)
-			DEFAULT_OP_DVECTOR_GET(PACKED_VECTOR3_ARRAY, Vector3)
-			DEFAULT_OP_DVECTOR_GET(PACKED_COLOR_ARRAY, Color)
-		default:
-			return Variant();
-	}
-
-	return Variant();
-}
-
-bool Variant::in(const Variant &p_index, bool *r_valid) const {
-	if (r_valid) {
-		*r_valid = true;
-	}
-
-	switch (type) {
-		case STRING: {
-			if (p_index.get_type() == Variant::STRING) {
-				//string index
-				String idx = p_index;
-				const String *str = reinterpret_cast<const String *>(_data._mem);
-
-				return str->find(idx) != -1;
-			}
-
-		} break;
-		case OBJECT: {
-			Object *obj = _get_obj().obj;
-			if (obj) {
-				bool valid = false;
-#ifdef DEBUG_ENABLED
-
-				if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-					if (r_valid) {
-						*r_valid = false;
-					}
-					return true; // Attempted get on stray pointer.
-				}
-
-#endif
-
-				if (p_index.get_type() != Variant::STRING) {
-					obj->getvar(p_index, &valid);
-				} else {
-					obj->get(p_index, &valid);
-				}
-
-				return valid;
-			} else {
-				if (r_valid) {
-					*r_valid = false;
-				}
-			}
-			return false;
-		} break;
-		case DICTIONARY: {
-			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
-			return dic->has(p_index);
-
-		} break;
-		case ARRAY: {
-			const Array *arr = reinterpret_cast<const Array *>(_data._mem);
-			int l = arr->size();
-			if (l) {
-				for (int i = 0; i < l; i++) {
-					if (evaluate(OP_EQUAL, (*arr)[i], p_index)) {
-						return true;
-					}
-				}
-			}
-
-			return false;
-
-		} break;
-		case PACKED_BYTE_ARRAY: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int index = p_index;
-				const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array);
-				int l = arr->size();
-				if (l) {
-					const uint8_t *r = arr->ptr();
-					for (int i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-
-		} break;
-		case PACKED_INT32_ARRAY: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int32_t index = p_index;
-				const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array);
-				int32_t l = arr->size();
-				if (l) {
-					const int32_t *r = arr->ptr();
-					for (int32_t i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-		} break;
-		case PACKED_INT64_ARRAY: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				int64_t index = p_index;
-				const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array);
-				int64_t l = arr->size();
-				if (l) {
-					const int64_t *r = arr->ptr();
-					for (int64_t i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-		} break;
-		case PACKED_FLOAT32_ARRAY: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				real_t index = p_index;
-				const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array);
-				int l = arr->size();
-				if (l) {
-					const float *r = arr->ptr();
-					for (int i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-
-		} break;
-		case PACKED_FLOAT64_ARRAY: {
-			if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {
-				real_t index = p_index;
-				const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array);
-				int l = arr->size();
-				if (l) {
-					const double *r = arr->ptr();
-					for (int i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-
-		} break;
-		case PACKED_STRING_ARRAY: {
-			if (p_index.get_type() == Variant::STRING) {
-				String index = p_index;
-				const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array);
-
-				int l = arr->size();
-				if (l) {
-					const String *r = arr->ptr();
-					for (int i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-
-		} break; //25
-		case PACKED_VECTOR2_ARRAY: {
-			if (p_index.get_type() == Variant::VECTOR2) {
-				Vector2 index = p_index;
-				const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array);
-
-				int l = arr->size();
-				if (l) {
-					const Vector2 *r = arr->ptr();
-					for (int i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-
-		} break;
-		case PACKED_VECTOR3_ARRAY: {
-			if (p_index.get_type() == Variant::VECTOR3) {
-				Vector3 index = p_index;
-				const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array);
-
-				int l = arr->size();
-				if (l) {
-					const Vector3 *r = arr->ptr();
-					for (int i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-
-		} break;
-		case PACKED_COLOR_ARRAY: {
-			if (p_index.get_type() == Variant::COLOR) {
-				Color index = p_index;
-				const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array);
-
-				int l = arr->size();
-				if (l) {
-					const Color *r = arr->ptr();
-					for (int i = 0; i < l; i++) {
-						if (r[i] == index) {
-							return true;
-						}
-					}
-				}
-
-				return false;
-			}
-		} break;
-		default: {
-		}
-	}
-
-	if (r_valid) {
-		*r_valid = false;
-	}
-	return false;
-}
-
-void Variant::get_property_list(List<PropertyInfo> *p_list) const {
-	switch (type) {
-		case VECTOR2: {
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "x"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "y"));
-
-		} break;
-		case VECTOR2I: {
-			p_list->push_back(PropertyInfo(Variant::INT, "x"));
-			p_list->push_back(PropertyInfo(Variant::INT, "y"));
-
-		} break;
-		case RECT2: {
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, "position"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, "size"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, "end"));
-
-		} break;
-		case RECT2I: {
-			p_list->push_back(PropertyInfo(Variant::VECTOR2I, "position"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2I, "size"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2I, "end"));
-
-		} break;
-		case VECTOR3: {
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "x"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "y"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "z"));
-
-		} break;
-		case VECTOR3I: {
-			p_list->push_back(PropertyInfo(Variant::INT, "x"));
-			p_list->push_back(PropertyInfo(Variant::INT, "y"));
-			p_list->push_back(PropertyInfo(Variant::INT, "z"));
-
-		} break;
-		case TRANSFORM2D: {
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, "x"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, "y"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, "origin"));
-
-		} break;
-		case PLANE: {
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "normal"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "x"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "y"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "z"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "d"));
-
-		} break;
-		case QUAT: {
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "x"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "y"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "z"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "w"));
-
-		} break;
-		case AABB: {
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "position"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "size"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "end"));
-		} break;
-		case BASIS: {
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "x"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "y"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "z"));
-
-		} break;
-		case TRANSFORM: {
-			p_list->push_back(PropertyInfo(Variant::BASIS, "basis"));
-			p_list->push_back(PropertyInfo(Variant::VECTOR3, "origin"));
-
-		} break;
-		case COLOR: {
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "r"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "g"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "b"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "a"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "h"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "s"));
-			p_list->push_back(PropertyInfo(Variant::FLOAT, "v"));
-			p_list->push_back(PropertyInfo(Variant::INT, "r8"));
-			p_list->push_back(PropertyInfo(Variant::INT, "g8"));
-			p_list->push_back(PropertyInfo(Variant::INT, "b8"));
-			p_list->push_back(PropertyInfo(Variant::INT, "a8"));
-
-		} break;
-		case STRING_NAME: {
-		} break;
-		case NODE_PATH: {
-		} break;
-		case _RID: {
-		} break;
-		case OBJECT: {
-			Object *obj = _get_obj().obj;
-			if (obj) {
-#ifdef DEBUG_ENABLED
-
-				if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-					WARN_PRINT("Attempted get_property list on previously freed instance.");
-					return;
-				}
-
-#endif
-
-				obj->get_property_list(p_list);
-			}
-
-		} break;
-		case DICTIONARY: {
-			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
-			List<Variant> keys;
-			dic->get_key_list(&keys);
-			for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
-				if (E->get().get_type() == Variant::STRING) {
-					p_list->push_back(PropertyInfo(Variant::STRING, E->get()));
-				}
-			}
-		} break;
-		case ARRAY:
-		case PACKED_BYTE_ARRAY:
-		case PACKED_INT32_ARRAY:
-		case PACKED_INT64_ARRAY:
-		case PACKED_FLOAT32_ARRAY:
-		case PACKED_FLOAT64_ARRAY:
-		case PACKED_STRING_ARRAY:
-		case PACKED_VECTOR2_ARRAY:
-		case PACKED_VECTOR3_ARRAY:
-		case PACKED_COLOR_ARRAY: {
-			//nothing
-		} break;
-		default: {
-		}
-	}
-}
-
-bool Variant::iter_init(Variant &r_iter, bool &valid) const {
-	valid = true;
-	switch (type) {
-		case INT: {
-			r_iter = 0;
-			return _data._int > 0;
-		} break;
-		case FLOAT: {
-			r_iter = 0;
-			return _data._float > 0.0;
-		} break;
-		case VECTOR2: {
-			double from = reinterpret_cast<const Vector2 *>(_data._mem)->x;
-			double to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
-
-			r_iter = from;
-
-			return from < to;
-		} break;
-		case VECTOR2I: {
-			int64_t from = reinterpret_cast<const Vector2i *>(_data._mem)->x;
-			int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y;
-
-			r_iter = from;
-
-			return from < to;
-		} break;
-		case VECTOR3: {
-			double from = reinterpret_cast<const Vector3 *>(_data._mem)->x;
-			double to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
-			double step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
-
-			r_iter = from;
-
-			if (from == to) {
-				return false;
-			} else if (from < to) {
-				return step > 0;
-			}
-			return step < 0;
-		} break;
-		case VECTOR3I: {
-			int64_t from = reinterpret_cast<const Vector3i *>(_data._mem)->x;
-			int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y;
-			int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z;
-
-			r_iter = from;
-
-			if (from == to) {
-				return false;
-			} else if (from < to) {
-				return step > 0;
-			}
-			return step < 0;
-		} break;
-		case OBJECT: {
-			if (!_get_obj().obj) {
-				valid = false;
-				return false;
-			}
-
-#ifdef DEBUG_ENABLED
-
-			if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-				valid = false;
-				return false;
-			}
-
-#endif
-			Callable::CallError ce;
-			ce.error = Callable::CallError::CALL_OK;
-			Array ref;
-			ref.push_back(r_iter);
-			Variant vref = ref;
-			const Variant *refp[] = { &vref };
-			Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_init, refp, 1, ce);
-
-			if (ref.size() != 1 || ce.error != Callable::CallError::CALL_OK) {
-				valid = false;
-				return false;
-			}
-
-			r_iter = ref[0];
-			return ret;
-		} break;
-
-		case STRING: {
-			const String *str = reinterpret_cast<const String *>(_data._mem);
-			if (str->empty()) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-		} break;
-		case DICTIONARY: {
-			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
-			if (dic->empty()) {
-				return false;
-			}
-
-			const Variant *next = dic->next(nullptr);
-			r_iter = *next;
-			return true;
-
-		} break;
-		case ARRAY: {
-			const Array *arr = reinterpret_cast<const Array *>(_data._mem);
-			if (arr->empty()) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-		} break;
-		case PACKED_BYTE_ARRAY: {
-			const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-
-		} break;
-		case PACKED_INT32_ARRAY: {
-			const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-
-		} break;
-		case PACKED_INT64_ARRAY: {
-			const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-
-		} break;
-		case PACKED_FLOAT32_ARRAY: {
-			const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-
-		} break;
-		case PACKED_FLOAT64_ARRAY: {
-			const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-
-		} break;
-		case PACKED_STRING_ARRAY: {
-			const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-		} break;
-		case PACKED_VECTOR2_ARRAY: {
-			const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-		} break;
-		case PACKED_VECTOR3_ARRAY: {
-			const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-		} break;
-		case PACKED_COLOR_ARRAY: {
-			const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array);
-			if (arr->size() == 0) {
-				return false;
-			}
-			r_iter = 0;
-			return true;
-
-		} break;
-		default: {
-		}
-	}
-
-	valid = false;
-	return false;
-}
-
-bool Variant::iter_next(Variant &r_iter, bool &valid) const {
-	valid = true;
-	switch (type) {
-		case INT: {
-			int64_t idx = r_iter;
-			idx++;
-			if (idx >= _data._int) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		case FLOAT: {
-			int64_t idx = r_iter;
-			idx++;
-			if (idx >= _data._float) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		case VECTOR2: {
-			double to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
-
-			double idx = r_iter;
-			idx++;
-
-			if (idx >= to) {
-				return false;
-			}
-
-			r_iter = idx;
-			return true;
-		} break;
-		case VECTOR2I: {
-			int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y;
-
-			int64_t idx = r_iter;
-			idx++;
-
-			if (idx >= to) {
-				return false;
-			}
-
-			r_iter = idx;
-			return true;
-		} break;
-		case VECTOR3: {
-			double to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
-			double step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
-
-			double idx = r_iter;
-			idx += step;
-
-			if (step < 0 && idx <= to) {
-				return false;
-			}
-
-			if (step > 0 && idx >= to) {
-				return false;
-			}
-
-			r_iter = idx;
-			return true;
-		} break;
-		case VECTOR3I: {
-			int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y;
-			int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z;
-
-			int64_t idx = r_iter;
-			idx += step;
-
-			if (step < 0 && idx <= to) {
-				return false;
-			}
-
-			if (step > 0 && idx >= to) {
-				return false;
-			}
-
-			r_iter = idx;
-			return true;
-		} break;
-		case OBJECT: {
-			if (!_get_obj().obj) {
-				valid = false;
-				return false;
-			}
-
-#ifdef DEBUG_ENABLED
-
-			if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-				valid = false;
-				return false;
-			}
-
-#endif
-			Callable::CallError ce;
-			ce.error = Callable::CallError::CALL_OK;
-			Array ref;
-			ref.push_back(r_iter);
-			Variant vref = ref;
-			const Variant *refp[] = { &vref };
-			Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_next, refp, 1, ce);
-
-			if (ref.size() != 1 || ce.error != Callable::CallError::CALL_OK) {
-				valid = false;
-				return false;
-			}
-
-			r_iter = ref[0];
-
-			return ret;
-		} break;
-
-		case STRING: {
-			const String *str = reinterpret_cast<const String *>(_data._mem);
-			int idx = r_iter;
-			idx++;
-			if (idx >= str->length()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		case DICTIONARY: {
-			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
-			const Variant *next = dic->next(&r_iter);
-			if (!next) {
-				return false;
-			}
-
-			r_iter = *next;
-			return true;
-
-		} break;
-		case ARRAY: {
-			const Array *arr = reinterpret_cast<const Array *>(_data._mem);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		case PACKED_BYTE_ARRAY: {
-			const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-
-		} break;
-		case PACKED_INT32_ARRAY: {
-			const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array);
-			int32_t idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-
-		} break;
-		case PACKED_INT64_ARRAY: {
-			const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array);
-			int64_t idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-
-		} break;
-		case PACKED_FLOAT32_ARRAY: {
-			const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-
-		} break;
-		case PACKED_FLOAT64_ARRAY: {
-			const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-
-		} break;
-		case PACKED_STRING_ARRAY: {
-			const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		case PACKED_VECTOR2_ARRAY: {
-			const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		case PACKED_VECTOR3_ARRAY: {
-			const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		case PACKED_COLOR_ARRAY: {
-			const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array);
-			int idx = r_iter;
-			idx++;
-			if (idx >= arr->size()) {
-				return false;
-			}
-			r_iter = idx;
-			return true;
-		} break;
-		default: {
-		}
-	}
-
-	valid = false;
-	return false;
-}
-
-Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const {
-	r_valid = true;
-	switch (type) {
-		case INT: {
-			return r_iter;
-		} break;
-		case FLOAT: {
-			return r_iter;
-		} break;
-		case VECTOR2: {
-			return r_iter;
-		} break;
-		case VECTOR2I: {
-			return r_iter;
-		} break;
-		case VECTOR3: {
-			return r_iter;
-		} break;
-		case VECTOR3I: {
-			return r_iter;
-		} break;
-		case OBJECT: {
-			if (!_get_obj().obj) {
-				r_valid = false;
-				return Variant();
-			}
-#ifdef DEBUG_ENABLED
-			if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
-				r_valid = false;
-				return Variant();
-			}
-
-#endif
-			Callable::CallError ce;
-			ce.error = Callable::CallError::CALL_OK;
-			const Variant *refp[] = { &r_iter };
-			Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_get, refp, 1, ce);
-
-			if (ce.error != Callable::CallError::CALL_OK) {
-				r_valid = false;
-				return Variant();
-			}
-
-			//r_iter=ref[0];
-
-			return ret;
-		} break;
-
-		case STRING: {
-			const String *str = reinterpret_cast<const String *>(_data._mem);
-			return str->substr(r_iter, 1);
-		} break;
-		case DICTIONARY: {
-			return r_iter; //iterator is the same as the key
-
-		} break;
-		case ARRAY: {
-			const Array *arr = reinterpret_cast<const Array *>(_data._mem);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_BYTE_ARRAY: {
-			const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_INT32_ARRAY: {
-			const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array);
-			int32_t idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_INT64_ARRAY: {
-			const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array);
-			int64_t idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_FLOAT32_ARRAY: {
-			const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_FLOAT64_ARRAY: {
-			const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_STRING_ARRAY: {
-			const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_VECTOR2_ARRAY: {
-			const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_VECTOR3_ARRAY: {
-			const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		case PACKED_COLOR_ARRAY: {
-			const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array);
-			int idx = r_iter;
-#ifdef DEBUG_ENABLED
-			if (idx < 0 || idx >= arr->size()) {
-				r_valid = false;
-				return Variant();
-			}
-#endif
-			return arr->get(idx);
-		} break;
-		default: {
-		}
-	}
-
-	r_valid = false;
-	return Variant();
-}
-
-Variant Variant::duplicate(bool deep) const {
-	switch (type) {
-		case OBJECT: {
-			/*  breaks stuff :(
-			if (deep && !_get_obj().ref.is_null()) {
-				Ref<Resource> resource = _get_obj().ref;
-				if (resource.is_valid()) {
-					return resource->duplicate(true);
-				}
-			}
-			*/
-			return *this;
-		} break;
-		case DICTIONARY:
-			return operator Dictionary().duplicate(deep);
-		case ARRAY:
-			return operator Array().duplicate(deep);
-		default:
-			return *this;
-	}
-}
-
-void Variant::blend(const Variant &a, const Variant &b, float c, Variant &r_dst) {
-	if (a.type != b.type) {
-		if (a.is_num() && b.is_num()) {
-			real_t va = a;
-			real_t vb = b;
-			r_dst = va + vb * c;
-		} else {
-			r_dst = a;
-		}
-		return;
-	}
-
-	switch (a.type) {
-		case NIL: {
-			r_dst = Variant();
-		}
-			return;
-		case INT: {
-			int64_t va = a._data._int;
-			int64_t vb = b._data._int;
-			r_dst = int(va + vb * c + 0.5);
-		}
-			return;
-		case FLOAT: {
-			double ra = a._data._float;
-			double rb = b._data._float;
-			r_dst = ra + rb * c;
-		}
-			return;
-		case VECTOR2: {
-			r_dst = *reinterpret_cast<const Vector2 *>(a._data._mem) + *reinterpret_cast<const Vector2 *>(b._data._mem) * c;
-		}
-			return;
-		case VECTOR2I: {
-			int32_t vax = reinterpret_cast<const Vector2i *>(a._data._mem)->x;
-			int32_t vbx = reinterpret_cast<const Vector2i *>(b._data._mem)->x;
-			int32_t vay = reinterpret_cast<const Vector2i *>(a._data._mem)->y;
-			int32_t vby = reinterpret_cast<const Vector2i *>(b._data._mem)->y;
-			r_dst = Vector2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5));
-		}
-			return;
-		case RECT2: {
-			const Rect2 *ra = reinterpret_cast<const Rect2 *>(a._data._mem);
-			const Rect2 *rb = reinterpret_cast<const Rect2 *>(b._data._mem);
-			r_dst = Rect2(ra->position + rb->position * c, ra->size + rb->size * c);
-		}
-			return;
-		case RECT2I: {
-			const Rect2i *ra = reinterpret_cast<const Rect2i *>(a._data._mem);
-			const Rect2i *rb = reinterpret_cast<const Rect2i *>(b._data._mem);
-
-			int32_t vax = ra->position.x;
-			int32_t vay = ra->position.y;
-			int32_t vbx = ra->size.x;
-			int32_t vby = ra->size.y;
-			int32_t vcx = rb->position.x;
-			int32_t vcy = rb->position.y;
-			int32_t vdx = rb->size.x;
-			int32_t vdy = rb->size.y;
-
-			r_dst = Rect2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vcx + vdx * c + 0.5), int32_t(vcy + vdy * c + 0.5));
-		}
-			return;
-		case VECTOR3: {
-			r_dst = *reinterpret_cast<const Vector3 *>(a._data._mem) + *reinterpret_cast<const Vector3 *>(b._data._mem) * c;
-		}
-			return;
-		case VECTOR3I: {
-			int32_t vax = reinterpret_cast<const Vector3i *>(a._data._mem)->x;
-			int32_t vbx = reinterpret_cast<const Vector3i *>(b._data._mem)->x;
-			int32_t vay = reinterpret_cast<const Vector3i *>(a._data._mem)->y;
-			int32_t vby = reinterpret_cast<const Vector3i *>(b._data._mem)->y;
-			int32_t vaz = reinterpret_cast<const Vector3i *>(a._data._mem)->z;
-			int32_t vbz = reinterpret_cast<const Vector3i *>(b._data._mem)->z;
-			r_dst = Vector3i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vaz + vbz * c + 0.5));
-		}
-			return;
-		case AABB: {
-			const ::AABB *ra = reinterpret_cast<const ::AABB *>(a._data._mem);
-			const ::AABB *rb = reinterpret_cast<const ::AABB *>(b._data._mem);
-			r_dst = ::AABB(ra->position + rb->position * c, ra->size + rb->size * c);
-		}
-			return;
-		case QUAT: {
-			Quat empty_rot;
-			const Quat *qa = reinterpret_cast<const Quat *>(a._data._mem);
-			const Quat *qb = reinterpret_cast<const Quat *>(b._data._mem);
-			r_dst = *qa * empty_rot.slerp(*qb, c);
-		}
-			return;
-		case COLOR: {
-			const Color *ca = reinterpret_cast<const Color *>(a._data._mem);
-			const Color *cb = reinterpret_cast<const Color *>(b._data._mem);
-			float new_r = ca->r + cb->r * c;
-			float new_g = ca->g + cb->g * c;
-			float new_b = ca->b + cb->b * c;
-			float new_a = ca->a + cb->a * c;
-			new_r = new_r > 1.0 ? 1.0 : new_r;
-			new_g = new_g > 1.0 ? 1.0 : new_g;
-			new_b = new_b > 1.0 ? 1.0 : new_b;
-			new_a = new_a > 1.0 ? 1.0 : new_a;
-			r_dst = Color(new_r, new_g, new_b, new_a);
-		}
-			return;
-		default: {
-			r_dst = c < 0.5 ? a : b;
-		}
-			return;
-	}
-}
-
-void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst) {
-	if (a.type != b.type) {
-		if (a.is_num() && b.is_num()) {
-			//not as efficient but..
-			real_t va = a;
-			real_t vb = b;
-			r_dst = va + (vb - va) * c;
-
-		} else {
-			r_dst = a;
-		}
-		return;
-	}
-
-	switch (a.type) {
-		case NIL: {
-			r_dst = Variant();
-		}
-			return;
-		case BOOL: {
-			r_dst = a;
-		}
-			return;
-		case INT: {
-			int64_t va = a._data._int;
-			int64_t vb = b._data._int;
-			r_dst = int(va + (vb - va) * c);
-		}
-			return;
-		case FLOAT: {
-			real_t va = a._data._float;
-			real_t vb = b._data._float;
-			r_dst = va + (vb - va) * c;
-		}
-			return;
-		case STRING: {
-			//this is pretty funny and bizarre, but artists like to use it for typewritter effects
-			String sa = *reinterpret_cast<const String *>(a._data._mem);
-			String sb = *reinterpret_cast<const String *>(b._data._mem);
-			String dst;
-			int sa_len = sa.length();
-			int sb_len = sb.length();
-			int csize = sa_len + (sb_len - sa_len) * c;
-			if (csize == 0) {
-				r_dst = "";
-				return;
-			}
-			dst.resize(csize + 1);
-			dst[csize] = 0;
-			int split = csize / 2;
-
-			for (int i = 0; i < csize; i++) {
-				char32_t chr = ' ';
-
-				if (i < split) {
-					if (i < sa.length()) {
-						chr = sa[i];
-					} else if (i < sb.length()) {
-						chr = sb[i];
-					}
-
-				} else {
-					if (i < sb.length()) {
-						chr = sb[i];
-					} else if (i < sa.length()) {
-						chr = sa[i];
-					}
-				}
-
-				dst[i] = chr;
-			}
-
-			r_dst = dst;
-		}
-			return;
-		case VECTOR2: {
-			r_dst = reinterpret_cast<const Vector2 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector2 *>(b._data._mem), c);
-		}
-			return;
-		case VECTOR2I: {
-			int32_t vax = reinterpret_cast<const Vector2i *>(a._data._mem)->x;
-			int32_t vbx = reinterpret_cast<const Vector2i *>(b._data._mem)->x;
-			int32_t vay = reinterpret_cast<const Vector2i *>(a._data._mem)->y;
-			int32_t vby = reinterpret_cast<const Vector2i *>(b._data._mem)->y;
-			r_dst = Vector2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5));
-		}
-			return;
-
-		case RECT2: {
-			r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
-		}
-			return;
-		case RECT2I: {
-			const Rect2i *ra = reinterpret_cast<const Rect2i *>(a._data._mem);
-			const Rect2i *rb = reinterpret_cast<const Rect2i *>(b._data._mem);
-
-			int32_t vax = ra->position.x;
-			int32_t vay = ra->position.y;
-			int32_t vbx = ra->size.x;
-			int32_t vby = ra->size.y;
-			int32_t vcx = rb->position.x;
-			int32_t vcy = rb->position.y;
-			int32_t vdx = rb->size.x;
-			int32_t vdy = rb->size.y;
-
-			r_dst = Rect2i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vcx + vdx * c + 0.5), int32_t(vcy + vdy * c + 0.5));
-		}
-			return;
-
-		case VECTOR3: {
-			r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector3 *>(b._data._mem), c);
-		}
-			return;
-		case VECTOR3I: {
-			int32_t vax = reinterpret_cast<const Vector3i *>(a._data._mem)->x;
-			int32_t vbx = reinterpret_cast<const Vector3i *>(b._data._mem)->x;
-			int32_t vay = reinterpret_cast<const Vector3i *>(a._data._mem)->y;
-			int32_t vby = reinterpret_cast<const Vector3i *>(b._data._mem)->y;
-			int32_t vaz = reinterpret_cast<const Vector3i *>(a._data._mem)->z;
-			int32_t vbz = reinterpret_cast<const Vector3i *>(b._data._mem)->z;
-			r_dst = Vector3i(int32_t(vax + vbx * c + 0.5), int32_t(vay + vby * c + 0.5), int32_t(vaz + vbz * c + 0.5));
-		}
-			return;
-
-		case TRANSFORM2D: {
-			r_dst = a._data._transform2d->interpolate_with(*b._data._transform2d, c);
-		}
-			return;
-		case PLANE: {
-			r_dst = a;
-		}
-			return;
-		case QUAT: {
-			r_dst = reinterpret_cast<const Quat *>(a._data._mem)->slerp(*reinterpret_cast<const Quat *>(b._data._mem), c);
-		}
-			return;
-		case AABB: {
-			r_dst = ::AABB(a._data._aabb->position.lerp(b._data._aabb->position, c), a._data._aabb->size.lerp(b._data._aabb->size, c));
-		}
-			return;
-		case BASIS: {
-			r_dst = Transform(*a._data._basis).interpolate_with(Transform(*b._data._basis), c).basis;
-		}
-			return;
-		case TRANSFORM: {
-			r_dst = a._data._transform->interpolate_with(*b._data._transform, c);
-		}
-			return;
-		case COLOR: {
-			r_dst = reinterpret_cast<const Color *>(a._data._mem)->lerp(*reinterpret_cast<const Color *>(b._data._mem), c);
-		}
-			return;
-		case STRING_NAME: {
-			r_dst = a;
-		}
-			return;
-		case NODE_PATH: {
-			r_dst = a;
-		}
-			return;
-		case _RID: {
-			r_dst = a;
-		}
-			return;
-		case OBJECT: {
-			r_dst = a;
-		}
-			return;
-		case DICTIONARY: {
-		}
-			return;
-		case ARRAY: {
-			r_dst = a;
-		}
-			return;
-		case PACKED_BYTE_ARRAY: {
-			r_dst = a;
-		}
-			return;
-		case PACKED_INT32_ARRAY: {
-			const Vector<int32_t> *arr_a = &PackedArrayRef<int32_t>::get_array(a._data.packed_array);
-			const Vector<int32_t> *arr_b = &PackedArrayRef<int32_t>::get_array(b._data.packed_array);
-			int32_t sz = arr_a->size();
-			if (sz == 0 || arr_b->size() != sz) {
-				r_dst = a;
-			} else {
-				Vector<int32_t> v;
-				v.resize(sz);
-				{
-					int32_t *vw = v.ptrw();
-					const int32_t *ar = arr_a->ptr();
-					const int32_t *br = arr_b->ptr();
-
-					Variant va;
-					for (int32_t i = 0; i < sz; i++) {
-						Variant::interpolate(ar[i], br[i], c, va);
-						vw[i] = va;
-					}
-				}
-				r_dst = v;
-			}
-		}
-			return;
-		case PACKED_INT64_ARRAY: {
-			const Vector<int64_t> *arr_a = &PackedArrayRef<int64_t>::get_array(a._data.packed_array);
-			const Vector<int64_t> *arr_b = &PackedArrayRef<int64_t>::get_array(b._data.packed_array);
-			int64_t sz = arr_a->size();
-			if (sz == 0 || arr_b->size() != sz) {
-				r_dst = a;
-			} else {
-				Vector<int64_t> v;
-				v.resize(sz);
-				{
-					int64_t *vw = v.ptrw();
-					const int64_t *ar = arr_a->ptr();
-					const int64_t *br = arr_b->ptr();
-
-					Variant va;
-					for (int64_t i = 0; i < sz; i++) {
-						Variant::interpolate(ar[i], br[i], c, va);
-						vw[i] = va;
-					}
-				}
-				r_dst = v;
-			}
-		}
-			return;
-		case PACKED_FLOAT32_ARRAY: {
-			const Vector<float> *arr_a = &PackedArrayRef<float>::get_array(a._data.packed_array);
-			const Vector<float> *arr_b = &PackedArrayRef<float>::get_array(b._data.packed_array);
-			int sz = arr_a->size();
-			if (sz == 0 || arr_b->size() != sz) {
-				r_dst = a;
-			} else {
-				Vector<float> v;
-				v.resize(sz);
-				{
-					float *vw = v.ptrw();
-					const float *ar = arr_a->ptr();
-					const float *br = arr_b->ptr();
-
-					Variant va;
-					for (int i = 0; i < sz; i++) {
-						Variant::interpolate(ar[i], br[i], c, va);
-						vw[i] = va;
-					}
-				}
-				r_dst = v;
-			}
-		}
-			return;
-		case PACKED_FLOAT64_ARRAY: {
-			const Vector<double> *arr_a = &PackedArrayRef<double>::get_array(a._data.packed_array);
-			const Vector<double> *arr_b = &PackedArrayRef<double>::get_array(b._data.packed_array);
-			int sz = arr_a->size();
-			if (sz == 0 || arr_b->size() != sz) {
-				r_dst = a;
-			} else {
-				Vector<double> v;
-				v.resize(sz);
-				{
-					double *vw = v.ptrw();
-					const double *ar = arr_a->ptr();
-					const double *br = arr_b->ptr();
-
-					Variant va;
-					for (int i = 0; i < sz; i++) {
-						Variant::interpolate(ar[i], br[i], c, va);
-						vw[i] = va;
-					}
-				}
-				r_dst = v;
-			}
-		}
-			return;
-		case PACKED_STRING_ARRAY: {
-			r_dst = a;
-		}
-			return;
-		case PACKED_VECTOR2_ARRAY: {
-			const Vector<Vector2> *arr_a = &PackedArrayRef<Vector2>::get_array(a._data.packed_array);
-			const Vector<Vector2> *arr_b = &PackedArrayRef<Vector2>::get_array(b._data.packed_array);
-			int sz = arr_a->size();
-			if (sz == 0 || arr_b->size() != sz) {
-				r_dst = a;
-			} else {
-				Vector<Vector2> v;
-				v.resize(sz);
-				{
-					Vector2 *vw = v.ptrw();
-					const Vector2 *ar = arr_a->ptr();
-					const Vector2 *br = arr_b->ptr();
-
-					for (int i = 0; i < sz; i++) {
-						vw[i] = ar[i].lerp(br[i], c);
-					}
-				}
-				r_dst = v;
-			}
-		}
-			return;
-		case PACKED_VECTOR3_ARRAY: {
-			const Vector<Vector3> *arr_a = &PackedArrayRef<Vector3>::get_array(a._data.packed_array);
-			const Vector<Vector3> *arr_b = &PackedArrayRef<Vector3>::get_array(b._data.packed_array);
-			int sz = arr_a->size();
-			if (sz == 0 || arr_b->size() != sz) {
-				r_dst = a;
-			} else {
-				Vector<Vector3> v;
-				v.resize(sz);
-				{
-					Vector3 *vw = v.ptrw();
-					const Vector3 *ar = arr_a->ptr();
-					const Vector3 *br = arr_b->ptr();
-
-					for (int i = 0; i < sz; i++) {
-						vw[i] = ar[i].lerp(br[i], c);
-					}
-				}
-				r_dst = v;
-			}
-		}
-			return;
-		case PACKED_COLOR_ARRAY: {
-			const Vector<Color> *arr_a = &PackedArrayRef<Color>::get_array(a._data.packed_array);
-			const Vector<Color> *arr_b = &PackedArrayRef<Color>::get_array(b._data.packed_array);
-			int sz = arr_a->size();
-			if (sz == 0 || arr_b->size() != sz) {
-				r_dst = a;
-			} else {
-				Vector<Color> v;
-				v.resize(sz);
-				{
-					Color *vw = v.ptrw();
-					const Color *ar = arr_a->ptr();
-					const Color *br = arr_b->ptr();
-
-					for (int i = 0; i < sz; i++) {
-						vw[i] = ar[i].lerp(br[i], c);
-					}
-				}
-				r_dst = v;
-			}
-		}
-			return;
-		default: {
-			r_dst = a;
-		}
-	}
-}
-
-static const char *_op_names[Variant::OP_MAX] = {
-	"==",
-	"!=",
-	"<",
-	"<=",
-	">",
-	">=",
-	"+",
-	"-",
-	"*",
-	"/",
-	"- (negation)",
-	"+ (positive)",
-	"%",
-	"+ (concatenation)",
-	"<<",
-	">>",
-	"&",
-	"|",
-	"^",
-	"~",
-	"and",
-	"or",
-	"xor",
-	"not",
-	"in"
-
-};
-
-String Variant::get_operator_name(Operator p_op) {
-	ERR_FAIL_INDEX_V(p_op, OP_MAX, "");
-	return _op_names[p_op];
-}