Merge pull request #45847 from vnen/gdnative-bindings

Improve GDNative API and JSON generation further

25 files changed, 1098 insertions, 19 deletions

diff --git a/modules/gdnative/gdnative/array.cpp b/modules/gdnative/gdnative/array.cpp
index 87a8c8e376..e68b60c5e6 100644
--- a/modules/gdnative/gdnative/array.cpp
+++ b/modules/gdnative/gdnative/array.cpp
@@ -47,6 +47,16 @@ void GDAPI godot_array_destroy(godot_array *p_self) {
 	((Array *)p_self)->~Array();
 }
 
+godot_variant GDAPI *godot_array_operator_index(godot_array *p_self, godot_int p_index) {
+	Array *self = (Array *)p_self;
+	return (godot_variant *)&self->operator[](p_index);
+}
+
+const godot_variant GDAPI *godot_array_operator_index_const(const godot_array *p_self, godot_int p_index) {
+	const Array *self = (const Array *)p_self;
+	return (const godot_variant *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/basis.cpp b/modules/gdnative/gdnative/basis.cpp
index 86a6d6216c..df3e1255ac 100644
--- a/modules/gdnative/gdnative/basis.cpp
+++ b/modules/gdnative/gdnative/basis.cpp
@@ -42,6 +42,16 @@ void GDAPI godot_basis_new(godot_basis *p_self) {
 	memnew_placement(p_self, Basis);
 }
 
+godot_vector3 GDAPI *godot_basis_operator_index(godot_basis *p_self, godot_int p_index) {
+	Basis *self = (Basis *)p_self;
+	return (godot_vector3 *)&self->operator[](p_index);
+}
+
+const godot_vector3 GDAPI *godot_basis_operator_index_const(const godot_basis *p_self, godot_int p_index) {
+	const Basis *self = (const Basis *)p_self;
+	return (const godot_vector3 *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/color.cpp b/modules/gdnative/gdnative/color.cpp
index 784c8d439e..12a800d333 100644
--- a/modules/gdnative/gdnative/color.cpp
+++ b/modules/gdnative/gdnative/color.cpp
@@ -42,6 +42,16 @@ void GDAPI godot_color_new(godot_color *p_self) {
 	memnew_placement(p_self, Color);
 }
 
+float GDAPI *godot_color_operator_index(godot_color *p_self, godot_int p_index) {
+	Color *self = (Color *)p_self;
+	return (float *)&self->operator[](p_index);
+}
+
+const float GDAPI *godot_color_operator_index_const(const godot_color *p_self, godot_int p_index) {
+	const Color *self = (const Color *)p_self;
+	return (const float *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/dictionary.cpp b/modules/gdnative/gdnative/dictionary.cpp
index d58e08f4b0..9fa4a27a83 100644
--- a/modules/gdnative/gdnative/dictionary.cpp
+++ b/modules/gdnative/gdnative/dictionary.cpp
@@ -31,6 +31,7 @@
 #include "gdnative/dictionary.h"
 
 #include "core/variant/dictionary.h"
+#include "core/variant/variant.h"
 
 static_assert(sizeof(godot_dictionary) == sizeof(Dictionary), "Dictionary size mismatch");
 
@@ -47,6 +48,16 @@ void GDAPI godot_dictionary_destroy(godot_dictionary *p_self) {
 	self->~Dictionary();
 }
 
+godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_self, const godot_variant *p_key) {
+	Dictionary *self = (Dictionary *)p_self;
+	return (godot_variant *)&self->operator[](*((const Variant *)p_key));
+}
+
+const godot_variant GDAPI *godot_dictionary_operator_index_const(const godot_dictionary *p_self, const godot_variant *p_key) {
+	const Dictionary *self = (const Dictionary *)p_self;
+	return (const godot_variant *)&self->operator[](*((const Variant *)p_key));
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/gdnative.cpp b/modules/gdnative/gdnative/gdnative.cpp
index c3d25f81c7..b84ce2d192 100644
--- a/modules/gdnative/gdnative/gdnative.cpp
+++ b/modules/gdnative/gdnative/gdnative.cpp
@@ -127,6 +127,17 @@ void GDAPI godot_free(void *p_ptr) {
 	memfree(p_ptr);
 }
 
+// Helper print functions.
+void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line) {
+	_err_print_error(p_function, p_file, p_line, p_description, ERR_HANDLER_ERROR);
+}
+void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line) {
+	_err_print_error(p_function, p_file, p_line, p_description, ERR_HANDLER_WARNING);
+}
+void GDAPI godot_print_script_error(const char *p_description, const char *p_function, const char *p_file, int p_line) {
+	_err_print_error(p_function, p_file, p_line, p_description, ERR_HANDLER_SCRIPT);
+}
+
 void _gdnative_report_version_mismatch(const godot_object *p_library, const char *p_ext, godot_gdnative_api_version p_want, godot_gdnative_api_version p_have) {
 	String message = "Error loading GDNative file ";
 	GDNativeLibrary *library = (GDNativeLibrary *)p_library;
diff --git a/modules/gdnative/gdnative/packed_arrays.cpp b/modules/gdnative/gdnative/packed_arrays.cpp
index 9e4c6e6f38..63a2425b87 100644
--- a/modules/gdnative/gdnative/packed_arrays.cpp
+++ b/modules/gdnative/gdnative/packed_arrays.cpp
@@ -63,6 +63,16 @@ void GDAPI godot_packed_byte_array_destroy(godot_packed_byte_array *p_self) {
 	((PackedByteArray *)p_self)->~PackedByteArray();
 }
 
+uint8_t GDAPI *godot_packed_byte_array_operator_index(godot_packed_byte_array *p_self, godot_int p_index) {
+	PackedByteArray *self = (PackedByteArray *)p_self;
+	return (uint8_t *)&self->operator[](p_index);
+}
+
+const uint8_t GDAPI *godot_packed_byte_array_operator_index_const(const godot_packed_byte_array *p_self, godot_int p_index) {
+	const PackedByteArray *self = (const PackedByteArray *)p_self;
+	return (const uint8_t *)&self->operator[](p_index);
+}
+
 // int32
 
 void GDAPI godot_packed_int32_array_new(godot_packed_int32_array *p_self) {
@@ -73,6 +83,16 @@ void GDAPI godot_packed_int32_array_destroy(godot_packed_int32_array *p_self) {
 	((PackedInt32Array *)p_self)->~PackedInt32Array();
 }
 
+int32_t GDAPI *godot_packed_int32_array_operator_index(godot_packed_int32_array *p_self, godot_int p_index) {
+	PackedInt32Array *self = (PackedInt32Array *)p_self;
+	return (int32_t *)&self->operator[](p_index);
+}
+
+const int32_t GDAPI *godot_packed_int32_array_operator_index_const(const godot_packed_int32_array *p_self, godot_int p_index) {
+	const PackedInt32Array *self = (const PackedInt32Array *)p_self;
+	return (const int32_t *)&self->operator[](p_index);
+}
+
 // int64
 
 void GDAPI godot_packed_int64_array_new(godot_packed_int64_array *p_self) {
@@ -83,6 +103,16 @@ void GDAPI godot_packed_int64_array_destroy(godot_packed_int64_array *p_self) {
 	((PackedInt64Array *)p_self)->~PackedInt64Array();
 }
 
+int64_t GDAPI *godot_packed_int64_array_operator_index(godot_packed_int64_array *p_self, godot_int p_index) {
+	PackedInt64Array *self = (PackedInt64Array *)p_self;
+	return (int64_t *)&self->operator[](p_index);
+}
+
+const int64_t GDAPI *godot_packed_int64_array_operator_index_const(const godot_packed_int64_array *p_self, godot_int p_index) {
+	const PackedInt64Array *self = (const PackedInt64Array *)p_self;
+	return (const int64_t *)&self->operator[](p_index);
+}
+
 // float32
 
 void GDAPI godot_packed_float32_array_new(godot_packed_float32_array *p_self) {
@@ -93,6 +123,16 @@ void GDAPI godot_packed_float32_array_destroy(godot_packed_float32_array *p_self
 	((PackedFloat32Array *)p_self)->~PackedFloat32Array();
 }
 
+float GDAPI *godot_packed_float32_array_operator_index(godot_packed_float32_array *p_self, godot_int p_index) {
+	PackedFloat32Array *self = (PackedFloat32Array *)p_self;
+	return (float *)&self->operator[](p_index);
+}
+
+const float GDAPI *godot_packed_float32_array_operator_index_const(const godot_packed_float32_array *p_self, godot_int p_index) {
+	const PackedFloat32Array *self = (const PackedFloat32Array *)p_self;
+	return (const float *)&self->operator[](p_index);
+}
+
 // float64
 
 void GDAPI godot_packed_float64_array_new(godot_packed_float64_array *p_self) {
@@ -103,6 +143,16 @@ void GDAPI godot_packed_float64_array_destroy(godot_packed_float64_array *p_self
 	((PackedFloat64Array *)p_self)->~PackedFloat64Array();
 }
 
+double GDAPI *godot_packed_float64_array_operator_index(godot_packed_float64_array *p_self, godot_int p_index) {
+	PackedFloat64Array *self = (PackedFloat64Array *)p_self;
+	return (double *)&self->operator[](p_index);
+}
+
+const double GDAPI *godot_packed_float64_array_operator_index_const(const godot_packed_float64_array *p_self, godot_int p_index) {
+	const PackedFloat64Array *self = (const PackedFloat64Array *)p_self;
+	return (const double *)&self->operator[](p_index);
+}
+
 // string
 
 void GDAPI godot_packed_string_array_new(godot_packed_string_array *p_self) {
@@ -113,6 +163,16 @@ void GDAPI godot_packed_string_array_destroy(godot_packed_string_array *p_self)
 	((PackedStringArray *)p_self)->~PackedStringArray();
 }
 
+godot_string GDAPI *godot_packed_string_array_operator_index(godot_packed_string_array *p_self, godot_int p_index) {
+	PackedStringArray *self = (PackedStringArray *)p_self;
+	return (godot_string *)&self->operator[](p_index);
+}
+
+const godot_string GDAPI *godot_packed_string_array_operator_index_const(const godot_packed_string_array *p_self, godot_int p_index) {
+	const PackedStringArray *self = (const PackedStringArray *)p_self;
+	return (const godot_string *)&self->operator[](p_index);
+}
+
 // vector2
 
 void GDAPI godot_packed_vector2_array_new(godot_packed_vector2_array *p_self) {
@@ -123,6 +183,16 @@ void GDAPI godot_packed_vector2_array_destroy(godot_packed_vector2_array *p_self
 	((PackedVector2Array *)p_self)->~PackedVector2Array();
 }
 
+godot_vector2 GDAPI *godot_packed_vector2_array_operator_index(godot_packed_vector2_array *p_self, godot_int p_index) {
+	PackedVector2Array *self = (PackedVector2Array *)p_self;
+	return (godot_vector2 *)&self->operator[](p_index);
+}
+
+const godot_vector2 GDAPI *godot_packed_vector2_array_operator_index_const(const godot_packed_vector2_array *p_self, godot_int p_index) {
+	const PackedVector2Array *self = (const PackedVector2Array *)p_self;
+	return (const godot_vector2 *)&self->operator[](p_index);
+}
+
 // vector2i
 
 void GDAPI godot_packed_vector2i_array_new(godot_packed_vector2i_array *p_self) {
@@ -133,6 +203,16 @@ void GDAPI godot_packed_vector2i_array_destroy(godot_packed_vector2i_array *p_se
 	((Vector<Vector2i> *)p_self)->~Vector();
 }
 
+godot_vector2i GDAPI *godot_packed_vector2i_array_operator_index(godot_packed_vector2i_array *p_self, godot_int p_index) {
+	Vector<Vector2i> *self = (Vector<Vector2i> *)p_self;
+	return (godot_vector2i *)&self->operator[](p_index);
+}
+
+const godot_vector2i GDAPI *godot_packed_vector2i_array_operator_index_const(const godot_packed_vector2i_array *p_self, godot_int p_index) {
+	const Vector<Vector2i> *self = (const Vector<Vector2i> *)p_self;
+	return (const godot_vector2i *)&self->operator[](p_index);
+}
+
 // vector3
 
 void GDAPI godot_packed_vector3_array_new(godot_packed_vector3_array *p_self) {
@@ -143,6 +223,16 @@ void GDAPI godot_packed_vector3_array_destroy(godot_packed_vector3_array *p_self
 	((PackedVector3Array *)p_self)->~PackedVector3Array();
 }
 
+godot_vector3 GDAPI *godot_packed_vector3_array_operator_index(godot_packed_vector3_array *p_self, godot_int p_index) {
+	PackedVector3Array *self = (PackedVector3Array *)p_self;
+	return (godot_vector3 *)&self->operator[](p_index);
+}
+
+const godot_vector3 GDAPI *godot_packed_vector3_array_operator_index_const(const godot_packed_vector3_array *p_self, godot_int p_index) {
+	const PackedVector3Array *self = (const PackedVector3Array *)p_self;
+	return (const godot_vector3 *)&self->operator[](p_index);
+}
+
 // vector3i
 
 void GDAPI godot_packed_vector3i_array_new(godot_packed_vector3i_array *p_self) {
@@ -153,6 +243,16 @@ void GDAPI godot_packed_vector3i_array_destroy(godot_packed_vector3i_array *p_se
 	((Vector<Vector3i> *)p_self)->~Vector();
 }
 
+godot_vector3i GDAPI *godot_packed_vector3i_array_operator_index(godot_packed_vector3i_array *p_self, godot_int p_index) {
+	Vector<Vector3i> *self = (Vector<Vector3i> *)p_self;
+	return (godot_vector3i *)&self->operator[](p_index);
+}
+
+const godot_vector3i GDAPI *godot_packed_vector3i_array_operator_index_const(const godot_packed_vector3i_array *p_self, godot_int p_index) {
+	const Vector<Vector3i> *self = (const Vector<Vector3i> *)p_self;
+	return (const godot_vector3i *)&self->operator[](p_index);
+}
+
 // color
 
 void GDAPI godot_packed_color_array_new(godot_packed_color_array *p_self) {
@@ -163,6 +263,16 @@ void GDAPI godot_packed_color_array_destroy(godot_packed_color_array *p_self) {
 	((PackedColorArray *)p_self)->~PackedColorArray();
 }
 
+godot_color GDAPI *godot_packed_color_array_operator_index(godot_packed_color_array *p_self, godot_int p_index) {
+	PackedColorArray *self = (PackedColorArray *)p_self;
+	return (godot_color *)&self->operator[](p_index);
+}
+
+const godot_color GDAPI *godot_packed_color_array_operator_index_const(const godot_packed_color_array *p_self, godot_int p_index) {
+	const PackedColorArray *self = (const PackedColorArray *)p_self;
+	return (const godot_color *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/quat.cpp b/modules/gdnative/gdnative/quat.cpp
index 87f1d7d8e5..836d6390d6 100644
--- a/modules/gdnative/gdnative/quat.cpp
+++ b/modules/gdnative/gdnative/quat.cpp
@@ -42,6 +42,16 @@ void GDAPI godot_quat_new(godot_quat *p_self) {
 	memnew_placement(p_self, Quat);
 }
 
+godot_real_t GDAPI *godot_quat_operator_index(godot_quat *p_self, godot_int p_index) {
+	Quat *self = (Quat *)p_self;
+	return (godot_real_t *)&self->operator[](p_index);
+}
+
+const godot_real_t GDAPI *godot_quat_operator_index_const(const godot_quat *p_self, godot_int p_index) {
+	const Quat *self = (const Quat *)p_self;
+	return (const godot_real_t *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/transform2d.cpp b/modules/gdnative/gdnative/transform2d.cpp
index e2c933f1ea..679174d5a5 100644
--- a/modules/gdnative/gdnative/transform2d.cpp
+++ b/modules/gdnative/gdnative/transform2d.cpp
@@ -42,6 +42,16 @@ void GDAPI godot_transform2d_new(godot_transform2d *p_self) {
 	memnew_placement(p_self, Transform2D);
 }
 
+godot_vector2 GDAPI *godot_transform2d_operator_index(godot_transform2d *p_self, godot_int p_index) {
+	Transform2D *self = (Transform2D *)p_self;
+	return (godot_vector2 *)&self->operator[](p_index);
+}
+
+const godot_vector2 GDAPI *godot_transform2d_operator_index_const(const godot_transform2d *p_self, godot_int p_index) {
+	const Transform2D *self = (const Transform2D *)p_self;
+	return (const godot_vector2 *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/variant.cpp b/modules/gdnative/gdnative/variant.cpp
index 79f5a536e5..ee4353bb48 100644
--- a/modules/gdnative/gdnative/variant.cpp
+++ b/modules/gdnative/gdnative/variant.cpp
@@ -1065,6 +1065,22 @@ void GDAPI godot_variant_call_utility_function_with_cstring(const char *p_functi
 	}
 }
 
+godot_ptr_utility_function GDAPI godot_variant_get_ptr_utility_function(const godot_string_name *p_function) {
+	return (godot_ptr_utility_function)Variant::get_ptr_utility_function(*((const StringName *)p_function));
+}
+
+godot_ptr_utility_function GDAPI godot_variant_get_ptr_utility_function_with_cstring(const char *p_function) {
+	return (godot_ptr_utility_function)Variant::get_ptr_utility_function(StringName(p_function));
+}
+
+godot_validated_utility_function GDAPI godot_variant_get_validated_utility_function(const godot_string_name *p_function) {
+	return (godot_validated_utility_function)Variant::get_validated_utility_function(*((const StringName *)p_function));
+}
+
+godot_validated_utility_function GDAPI godot_variant_get_validated_utility_function_with_cstring(const char *p_function) {
+	return (godot_validated_utility_function)Variant::get_validated_utility_function(StringName(p_function));
+}
+
 godot_variant_utility_function_type GDAPI godot_variant_get_utility_function_type(const godot_string_name *p_function) {
 	return (godot_variant_utility_function_type)Variant::get_utility_function_type(*((const StringName *)p_function));
 }
diff --git a/modules/gdnative/gdnative/vector2.cpp b/modules/gdnative/gdnative/vector2.cpp
index e2f957e4f2..ebb1996649 100644
--- a/modules/gdnative/gdnative/vector2.cpp
+++ b/modules/gdnative/gdnative/vector2.cpp
@@ -47,6 +47,26 @@ void GDAPI godot_vector2i_new(godot_vector2i *p_self) {
 	memnew_placement(p_self, Vector2i);
 }
 
+godot_real_t GDAPI *godot_vector2_operator_index(godot_vector2 *p_self, godot_int p_index) {
+	Vector2 *self = (Vector2 *)p_self;
+	return (godot_real_t *)&self->operator[](p_index);
+}
+
+const godot_real_t GDAPI *godot_vector2_operator_index_const(const godot_vector2 *p_self, godot_int p_index) {
+	const Vector2 *self = (const Vector2 *)p_self;
+	return (const godot_real_t *)&self->operator[](p_index);
+}
+
+int32_t GDAPI *godot_vector2i_operator_index(godot_vector2i *p_self, godot_int p_index) {
+	Vector2i *self = (Vector2i *)p_self;
+	return (int32_t *)&self->operator[](p_index);
+}
+
+const int32_t GDAPI *godot_vector2i_operator_index_const(const godot_vector2i *p_self, godot_int p_index) {
+	const Vector2i *self = (const Vector2i *)p_self;
+	return (const int32_t *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative/vector3.cpp b/modules/gdnative/gdnative/vector3.cpp
index ee365edaec..0fe1b292a7 100644
--- a/modules/gdnative/gdnative/vector3.cpp
+++ b/modules/gdnative/gdnative/vector3.cpp
@@ -47,6 +47,26 @@ void GDAPI godot_vector3i_new(godot_vector3i *p_self) {
 	memnew_placement(p_self, Vector3i);
 }
 
+godot_real_t GDAPI *godot_vector3_operator_index(godot_vector3 *p_self, godot_int p_index) {
+	Vector3 *self = (Vector3 *)p_self;
+	return (godot_real_t *)&self->operator[](p_index);
+}
+
+const godot_real_t GDAPI *godot_vector3_operator_index_const(const godot_vector3 *p_self, godot_int p_index) {
+	const Vector3 *self = (const Vector3 *)p_self;
+	return (const godot_real_t *)&self->operator[](p_index);
+}
+
+int32_t GDAPI *godot_vector3i_operator_index(godot_vector3i *p_self, godot_int p_index) {
+	Vector3i *self = (Vector3i *)p_self;
+	return (int32_t *)&self->operator[](p_index);
+}
+
+const int32_t GDAPI *godot_vector3i_operator_index_const(const godot_vector3i *p_self, godot_int p_index) {
+	const Vector3i *self = (const Vector3i *)p_self;
+	return (const int32_t *)&self->operator[](p_index);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/modules/gdnative/gdnative_api.json b/modules/gdnative/gdnative_api.json
index 909e91393e..c163fbbc1b 100644
--- a/modules/gdnative/gdnative_api.json
+++ b/modules/gdnative/gdnative_api.json
@@ -153,6 +153,72 @@
 				]
 			},
 			{
+				"name": "godot_print_error",
+				"return_type": "void",
+				"arguments": [
+					[
+						"const char *",
+						"p_description"
+					],
+					[
+						"const char *",
+						"p_function"
+					],
+					[
+						"const char *",
+						"p_file"
+					],
+					[
+						"int",
+						"p_line"
+					]
+				]
+			},
+			{
+				"name": "godot_print_warning",
+				"return_type": "void",
+				"arguments": [
+					[
+						"const char *",
+						"p_description"
+					],
+					[
+						"const char *",
+						"p_function"
+					],
+					[
+						"const char *",
+						"p_file"
+					],
+					[
+						"int",
+						"p_line"
+					]
+				]
+			},
+			{
+				"name": "godot_print_script_error",
+				"return_type": "void",
+				"arguments": [
+					[
+						"const char *",
+						"p_description"
+					],
+					[
+						"const char *",
+						"p_function"
+					],
+					[
+						"const char *",
+						"p_file"
+					],
+					[
+						"int",
+						"p_line"
+					]
+				]
+			},
+			{
 				"name": "godot_get_class_tag",
 				"return_type": "void *",
 				"arguments": [
@@ -2371,6 +2437,46 @@
 				]
 			},
 			{
+				"name": "godot_variant_get_ptr_utility_function",
+				"return_type": "godot_ptr_utility_function",
+				"arguments": [
+					[
+						"const godot_string_name *",
+						"p_function"
+					]
+				]
+			},
+			{
+				"name": "godot_variant_get_ptr_utility_function_with_cstring",
+				"return_type": "godot_ptr_utility_function",
+				"arguments": [
+					[
+						"const char *",
+						"p_function"
+					]
+				]
+			},
+			{
+				"name": "godot_variant_get_validated_utility_function",
+				"return_type": "godot_validated_utility_function",
+				"arguments": [
+					[
+						"const godot_string_name *",
+						"p_function"
+					]
+				]
+			},
+			{
+				"name": "godot_variant_get_validated_utility_function_with_cstring",
+				"return_type": "godot_validated_utility_function",
+				"arguments": [
+					[
+						"const char *",
+						"p_function"
+					]
+				]
+			},
+			{
 				"name": "godot_variant_get_utility_function_type",
 				"return_type": "godot_variant_utility_function_type",
 				"arguments": [
@@ -2666,6 +2772,34 @@
 				]
 			},
 			{
+				"name": "godot_array_operator_index",
+				"return_type": "godot_variant *",
+				"arguments": [
+					[
+						"godot_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_array_operator_index_const",
+				"return_type": "const godot_variant *",
+				"arguments": [
+					[
+						"const godot_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_basis_new",
 				"return_type": "void",
 				"arguments": [
@@ -2676,6 +2810,34 @@
 				]
 			},
 			{
+				"name": "godot_basis_operator_index",
+				"return_type": "godot_vector3 *",
+				"arguments": [
+					[
+						"godot_basis *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_basis_operator_index_const",
+				"return_type": "const godot_vector3 *",
+				"arguments": [
+					[
+						"const godot_basis *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_callable_new",
 				"return_type": "void",
 				"arguments": [
@@ -2706,6 +2868,34 @@
 				]
 			},
 			{
+				"name": "godot_color_operator_index",
+				"return_type": "float *",
+				"arguments": [
+					[
+						"godot_color *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_color_operator_index_const",
+				"return_type": "const float *",
+				"arguments": [
+					[
+						"const godot_color *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_dictionary_new",
 				"return_type": "void",
 				"arguments": [
@@ -2726,6 +2916,34 @@
 				]
 			},
 			{
+				"name": "godot_dictionary_operator_index",
+				"return_type": "godot_variant *",
+				"arguments": [
+					[
+						"godot_dictionary *",
+						"p_self"
+					],
+					[
+						"const godot_variant *",
+						"p_key"
+					]
+				]
+			},
+			{
+				"name": "godot_dictionary_operator_index_const",
+				"return_type": "const godot_variant *",
+				"arguments": [
+					[
+						"const godot_dictionary *",
+						"p_self"
+					],
+					[
+						"const godot_variant *",
+						"p_key"
+					]
+				]
+			},
+			{
 				"name": "godot_node_path_new",
 				"return_type": "void",
 				"arguments": [
@@ -2766,6 +2984,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_byte_array_operator_index",
+				"return_type": "uint8_t *",
+				"arguments": [
+					[
+						"godot_packed_byte_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_byte_array_operator_index_const",
+				"return_type": "const uint8_t *",
+				"arguments": [
+					[
+						"const godot_packed_byte_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_int32_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2786,6 +3032,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_int32_array_operator_index",
+				"return_type": "int32_t *",
+				"arguments": [
+					[
+						"godot_packed_int32_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_int32_array_operator_index_const",
+				"return_type": "const int32_t *",
+				"arguments": [
+					[
+						"const godot_packed_int32_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_int64_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2806,6 +3080,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_int64_array_operator_index",
+				"return_type": "int64_t *",
+				"arguments": [
+					[
+						"godot_packed_int64_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_int64_array_operator_index_const",
+				"return_type": "const int64_t *",
+				"arguments": [
+					[
+						"const godot_packed_int64_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_float32_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2826,6 +3128,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_float32_array_operator_index",
+				"return_type": "float *",
+				"arguments": [
+					[
+						"godot_packed_float32_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_float32_array_operator_index_const",
+				"return_type": "const float *",
+				"arguments": [
+					[
+						"const godot_packed_float32_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_float64_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2846,6 +3176,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_float64_array_operator_index",
+				"return_type": "double *",
+				"arguments": [
+					[
+						"godot_packed_float64_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_float64_array_operator_index_const",
+				"return_type": "const double *",
+				"arguments": [
+					[
+						"const godot_packed_float64_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_string_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2866,6 +3224,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_string_array_operator_index",
+				"return_type": "godot_string *",
+				"arguments": [
+					[
+						"godot_packed_string_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_string_array_operator_index_const",
+				"return_type": "const godot_string *",
+				"arguments": [
+					[
+						"const godot_packed_string_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_vector2_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2886,6 +3272,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_vector2_array_operator_index",
+				"return_type": "godot_vector2 *",
+				"arguments": [
+					[
+						"godot_packed_vector2_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_vector2_array_operator_index_const",
+				"return_type": "const godot_vector2 *",
+				"arguments": [
+					[
+						"const godot_packed_vector2_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_vector2i_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2906,6 +3320,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_vector2i_array_operator_index",
+				"return_type": "godot_vector2i *",
+				"arguments": [
+					[
+						"godot_packed_vector2i_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_vector2i_array_operator_index_const",
+				"return_type": "const godot_vector2i *",
+				"arguments": [
+					[
+						"const godot_packed_vector2i_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_vector3_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2926,6 +3368,82 @@
 				]
 			},
 			{
+				"name": "godot_packed_vector3_array_operator_index",
+				"return_type": "godot_vector3 *",
+				"arguments": [
+					[
+						"godot_packed_vector3_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_vector3_array_operator_index_const",
+				"return_type": "const godot_vector3 *",
+				"arguments": [
+					[
+						"const godot_packed_vector3_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_vector3i_array_new",
+				"return_type": "void",
+				"arguments": [
+					[
+						"godot_packed_vector3i_array *",
+						"p_self"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_vector3i_array_destroy",
+				"return_type": "void",
+				"arguments": [
+					[
+						"godot_packed_vector3i_array *",
+						"p_self"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_vector3i_array_operator_index",
+				"return_type": "godot_vector3i *",
+				"arguments": [
+					[
+						"godot_packed_vector3i_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_vector3i_array_operator_index_const",
+				"return_type": "const godot_vector3i *",
+				"arguments": [
+					[
+						"const godot_packed_vector3i_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_packed_color_array_new",
 				"return_type": "void",
 				"arguments": [
@@ -2946,6 +3464,34 @@
 				]
 			},
 			{
+				"name": "godot_packed_color_array_operator_index",
+				"return_type": "godot_color *",
+				"arguments": [
+					[
+						"godot_packed_color_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_packed_color_array_operator_index_const",
+				"return_type": "const godot_color *",
+				"arguments": [
+					[
+						"const godot_packed_color_array *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_plane_new",
 				"return_type": "void",
 				"arguments": [
@@ -2966,6 +3512,34 @@
 				]
 			},
 			{
+				"name": "godot_quat_operator_index",
+				"return_type": "godot_real_t *",
+				"arguments": [
+					[
+						"godot_quat *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_quat_operator_index_const",
+				"return_type": "const godot_real_t *",
+				"arguments": [
+					[
+						"const godot_quat *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_rect2_new",
 				"return_type": "void",
 				"arguments": [
@@ -3278,6 +3852,34 @@
 				]
 			},
 			{
+				"name": "godot_transform2d_operator_index",
+				"return_type": "godot_vector2 *",
+				"arguments": [
+					[
+						"godot_transform2d *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_transform2d_operator_index_const",
+				"return_type": "const godot_vector2 *",
+				"arguments": [
+					[
+						"const godot_transform2d *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_vector2_new",
 				"return_type": "void",
 				"arguments": [
@@ -3288,6 +3890,34 @@
 				]
 			},
 			{
+				"name": "godot_vector2_operator_index",
+				"return_type": "godot_real_t *",
+				"arguments": [
+					[
+						"godot_vector2 *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_vector2_operator_index_const",
+				"return_type": "const godot_real_t *",
+				"arguments": [
+					[
+						"const godot_vector2 *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_vector2i_new",
 				"return_type": "void",
 				"arguments": [
@@ -3298,6 +3928,34 @@
 				]
 			},
 			{
+				"name": "godot_vector2i_operator_index",
+				"return_type": "int32_t *",
+				"arguments": [
+					[
+						"godot_vector2i *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_vector2i_operator_index_const",
+				"return_type": "const int32_t *",
+				"arguments": [
+					[
+						"const godot_vector2i *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_vector3_new",
 				"return_type": "void",
 				"arguments": [
@@ -3308,6 +3966,34 @@
 				]
 			},
 			{
+				"name": "godot_vector3_operator_index",
+				"return_type": "godot_real_t *",
+				"arguments": [
+					[
+						"godot_vector3 *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_vector3_operator_index_const",
+				"return_type": "const godot_real_t *",
+				"arguments": [
+					[
+						"const godot_vector3 *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
 				"name": "godot_vector3i_new",
 				"return_type": "void",
 				"arguments": [
@@ -3316,6 +4002,34 @@
 						"r_dest"
 					]
 				]
+			},
+			{
+				"name": "godot_vector3i_operator_index",
+				"return_type": "int32_t *",
+				"arguments": [
+					[
+						"godot_vector3i *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
+			},
+			{
+				"name": "godot_vector3i_operator_index_const",
+				"return_type": "const int32_t *",
+				"arguments": [
+					[
+						"const godot_vector3i *",
+						"p_self"
+					],
+					[
+						"godot_int",
+						"p_index"
+					]
+				]
 			}
 		]
 	},
diff --git a/modules/gdnative/include/gdnative/array.h b/modules/gdnative/include/gdnative/array.h
index d734d49232..7603edaa73 100644
--- a/modules/gdnative/include/gdnative/array.h
+++ b/modules/gdnative/include/gdnative/array.h
@@ -47,9 +47,12 @@ typedef struct {
 #endif
 
 #include <gdnative/gdnative.h>
+#include <gdnative/variant_struct.h>
 
 void GDAPI godot_array_new(godot_array *p_self);
 void GDAPI godot_array_destroy(godot_array *p_self);
+godot_variant GDAPI *godot_array_operator_index(godot_array *p_self, godot_int p_index);
+const godot_variant GDAPI *godot_array_operator_index_const(const godot_array *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/include/gdnative/basis.h b/modules/gdnative/include/gdnative/basis.h
index d40ca3d6a5..af8d7cbdd3 100644
--- a/modules/gdnative/include/gdnative/basis.h
+++ b/modules/gdnative/include/gdnative/basis.h
@@ -49,6 +49,8 @@ typedef struct {
 #include <gdnative/gdnative.h>
 
 void GDAPI godot_basis_new(godot_basis *p_self);
+godot_vector3 GDAPI *godot_basis_operator_index(godot_basis *p_self, godot_int p_index);
+const godot_vector3 GDAPI *godot_basis_operator_index_const(const godot_basis *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/include/gdnative/color.h b/modules/gdnative/include/gdnative/color.h
index 12c4a829bd..17a021e6ea 100644
--- a/modules/gdnative/include/gdnative/color.h
+++ b/modules/gdnative/include/gdnative/color.h
@@ -50,6 +50,8 @@ typedef struct {
 #include <gdnative/gdnative.h>
 
 void GDAPI godot_color_new(godot_color *p_self);
+float GDAPI *godot_color_operator_index(godot_color *p_self, godot_int p_index);
+const float GDAPI *godot_color_operator_index_const(const godot_color *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/include/gdnative/dictionary.h b/modules/gdnative/include/gdnative/dictionary.h
index 231d2ef578..d2afbc4c94 100644
--- a/modules/gdnative/include/gdnative/dictionary.h
+++ b/modules/gdnative/include/gdnative/dictionary.h
@@ -47,9 +47,12 @@ typedef struct {
 #endif
 
 #include <gdnative/gdnative.h>
+#include <gdnative/variant_struct.h>
 
 void GDAPI godot_dictionary_new(godot_dictionary *p_self);
 void GDAPI godot_dictionary_destroy(godot_dictionary *p_self);
+godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_self, const godot_variant *p_key);
+const godot_variant GDAPI *godot_dictionary_operator_index_const(const godot_dictionary *p_self, const godot_variant *p_key);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/include/gdnative/gdnative.h b/modules/gdnative/include/gdnative/gdnative.h
index 630966b035..a4ed7ebb8c 100644
--- a/modules/gdnative/include/gdnative/gdnative.h
+++ b/modules/gdnative/include/gdnative/gdnative.h
@@ -62,8 +62,6 @@ extern "C" {
 #include <stdbool.h>
 #include <stdint.h>
 
-#define GODOT_API_VERSION 1
-
 ////// Error
 
 typedef enum {
@@ -266,6 +264,11 @@ void GDAPI *godot_alloc(int p_bytes);
 void GDAPI *godot_realloc(void *p_ptr, int p_bytes);
 void GDAPI godot_free(void *p_ptr);
 
+// Helper print functions.
+void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line);
+void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line);
+void GDAPI godot_print_script_error(const char *p_description, const char *p_function, const char *p_file, int p_line);
+
 //tags used for safe dynamic casting
 void GDAPI *godot_get_class_tag(const godot_string_name *p_class);
 godot_object GDAPI *godot_object_cast_to(const godot_object *p_object, void *p_class_tag);
diff --git a/modules/gdnative/include/gdnative/packed_arrays.h b/modules/gdnative/include/gdnative/packed_arrays.h
index 1a26d8ed6d..621ed60cdf 100644
--- a/modules/gdnative/include/gdnative/packed_arrays.h
+++ b/modules/gdnative/include/gdnative/packed_arrays.h
@@ -164,54 +164,81 @@ typedef struct {
 
 void GDAPI godot_packed_byte_array_new(godot_packed_byte_array *p_self);
 void GDAPI godot_packed_byte_array_destroy(godot_packed_byte_array *p_self);
+uint8_t GDAPI *godot_packed_byte_array_operator_index(godot_packed_byte_array *p_self, godot_int p_index);
+const uint8_t GDAPI *godot_packed_byte_array_operator_index_const(const godot_packed_byte_array *p_self, godot_int p_index);
 
 // Int32.
 
 void GDAPI godot_packed_int32_array_new(godot_packed_int32_array *p_self);
 void GDAPI godot_packed_int32_array_destroy(godot_packed_int32_array *p_self);
+int32_t GDAPI *godot_packed_int32_array_operator_index(godot_packed_int32_array *p_self, godot_int p_index);
+const int32_t GDAPI *godot_packed_int32_array_operator_index_const(const godot_packed_int32_array *p_self, godot_int p_index);
 
 // Int64.
 
 void GDAPI godot_packed_int64_array_new(godot_packed_int64_array *p_self);
 void GDAPI godot_packed_int64_array_destroy(godot_packed_int64_array *p_self);
+int64_t GDAPI *godot_packed_int64_array_operator_index(godot_packed_int64_array *p_self, godot_int p_index);
+const int64_t GDAPI *godot_packed_int64_array_operator_index_const(const godot_packed_int64_array *p_self, godot_int p_index);
 
 // Float32.
 
 void GDAPI godot_packed_float32_array_new(godot_packed_float32_array *p_self);
 void GDAPI godot_packed_float32_array_destroy(godot_packed_float32_array *p_self);
+float GDAPI *godot_packed_float32_array_operator_index(godot_packed_float32_array *p_self, godot_int p_index);
+const float GDAPI *godot_packed_float32_array_operator_index_const(const godot_packed_float32_array *p_self, godot_int p_index);
 
 // Float64.
 
 void GDAPI godot_packed_float64_array_new(godot_packed_float64_array *p_self);
 void GDAPI godot_packed_float64_array_destroy(godot_packed_float64_array *p_self);
+double GDAPI *godot_packed_float64_array_operator_index(godot_packed_float64_array *p_self, godot_int p_index);
+const double GDAPI *godot_packed_float64_array_operator_index_const(const godot_packed_float64_array *p_self, godot_int p_index);
 
 // String.
 
 void GDAPI godot_packed_string_array_new(godot_packed_string_array *p_self);
 void GDAPI godot_packed_string_array_destroy(godot_packed_string_array *p_self);
+godot_string GDAPI *godot_packed_string_array_operator_index(godot_packed_string_array *p_self, godot_int p_index);
+const godot_string GDAPI *godot_packed_string_array_operator_index_const(const godot_packed_string_array *p_self, godot_int p_index);
 
 // Vector2.
 
 void GDAPI godot_packed_vector2_array_new(godot_packed_vector2_array *p_self);
 void GDAPI godot_packed_vector2_array_destroy(godot_packed_vector2_array *p_self);
+godot_vector2 GDAPI *godot_packed_vector2_array_operator_index(godot_packed_vector2_array *p_self, godot_int p_index);
+const godot_vector2 GDAPI *godot_packed_vector2_array_operator_index_const(const godot_packed_vector2_array *p_self, godot_int p_index);
 
 // Vector2i.
 
 void GDAPI godot_packed_vector2i_array_new(godot_packed_vector2i_array *p_self);
 void GDAPI godot_packed_vector2i_array_destroy(godot_packed_vector2i_array *p_self);
+godot_vector2i GDAPI *godot_packed_vector2i_array_operator_index(godot_packed_vector2i_array *p_self, godot_int p_index);
+const godot_vector2i GDAPI *godot_packed_vector2i_array_operator_index_const(const godot_packed_vector2i_array *p_self, godot_int p_index);
 
 // Vector3.
 
 void GDAPI godot_packed_vector3_array_new(godot_packed_vector3_array *p_self);
 void GDAPI godot_packed_vector3_array_destroy(godot_packed_vector3_array *p_self);
+godot_vector3 GDAPI *godot_packed_vector3_array_operator_index(godot_packed_vector3_array *p_self, godot_int p_index);
+const godot_vector3 GDAPI *godot_packed_vector3_array_operator_index_const(const godot_packed_vector3_array *p_self, godot_int p_index);
+
+// Vector3i.
+
+void GDAPI godot_packed_vector3i_array_new(godot_packed_vector3i_array *p_self);
+void GDAPI godot_packed_vector3i_array_destroy(godot_packed_vector3i_array *p_self);
+godot_vector3i GDAPI *godot_packed_vector3i_array_operator_index(godot_packed_vector3i_array *p_self, godot_int p_index);
+const godot_vector3i GDAPI *godot_packed_vector3i_array_operator_index_const(const godot_packed_vector3i_array *p_self, godot_int p_index);
 
 // Color.
 
 void GDAPI godot_packed_color_array_new(godot_packed_color_array *p_self);
 void GDAPI godot_packed_color_array_destroy(godot_packed_color_array *p_self);
+godot_color GDAPI *godot_packed_color_array_operator_index(godot_packed_color_array *p_self, godot_int p_index);
+const godot_color GDAPI *godot_packed_color_array_operator_index_const(const godot_packed_color_array *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // GODOT_POOL_ARRAYS_H
+#endif // GODOT_PACKED_ARRAYS_H
diff --git a/modules/gdnative/include/gdnative/quat.h b/modules/gdnative/include/gdnative/quat.h
index a87d0bdbe5..69bf427611 100644
--- a/modules/gdnative/include/gdnative/quat.h
+++ b/modules/gdnative/include/gdnative/quat.h
@@ -49,6 +49,8 @@ typedef struct {
 #include <gdnative/gdnative.h>
 
 void GDAPI godot_quat_new(godot_quat *p_self);
+godot_real_t GDAPI *godot_quat_operator_index(godot_quat *p_self, godot_int p_index);
+const godot_real_t GDAPI *godot_quat_operator_index_const(const godot_quat *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/include/gdnative/transform2d.h b/modules/gdnative/include/gdnative/transform2d.h
index 85e3a86972..4a2bca7cfc 100644
--- a/modules/gdnative/include/gdnative/transform2d.h
+++ b/modules/gdnative/include/gdnative/transform2d.h
@@ -49,6 +49,8 @@ typedef struct {
 #include <gdnative/gdnative.h>
 
 void GDAPI godot_transform2d_new(godot_transform2d *p_self);
+godot_vector2 GDAPI *godot_transform2d_operator_index(godot_transform2d *p_self, godot_int p_index);
+const godot_vector2 GDAPI *godot_transform2d_operator_index_const(const godot_transform2d *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/include/gdnative/variant.h b/modules/gdnative/include/gdnative/variant.h
index 82bd030170..329a6faf51 100644
--- a/modules/gdnative/include/gdnative/variant.h
+++ b/modules/gdnative/include/gdnative/variant.h
@@ -36,15 +36,7 @@ extern "C" {
 #endif
 
 #include <gdnative/math_defs.h>
-
-#define GODOT_VARIANT_SIZE (sizeof(godot_real_t) * 4 + sizeof(int64_t))
-
-#ifndef GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
-#define GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
-typedef struct {
-	uint8_t _dont_touch_that[GODOT_VARIANT_SIZE];
-} godot_variant;
-#endif
+#include <gdnative/variant_struct.h>
 
 typedef enum godot_variant_type {
 	GODOT_VARIANT_TYPE_NIL,
@@ -390,6 +382,10 @@ bool GDAPI godot_variant_has_utility_function(const godot_string_name *p_functio
 bool GDAPI godot_variant_has_utility_function_with_cstring(const char *p_function);
 void GDAPI godot_variant_call_utility_function(const godot_string_name *p_function, godot_variant *r_ret, const godot_variant **p_args, int p_argument_count, godot_variant_call_error *r_error);
 void GDAPI godot_variant_call_utility_function_with_cstring(const char *p_function, godot_variant *r_ret, const godot_variant **p_args, int p_argument_count, godot_variant_call_error *r_error);
+godot_ptr_utility_function GDAPI godot_variant_get_ptr_utility_function(const godot_string_name *p_function);
+godot_ptr_utility_function GDAPI godot_variant_get_ptr_utility_function_with_cstring(const char *p_function);
+godot_validated_utility_function GDAPI godot_variant_get_validated_utility_function(const godot_string_name *p_function);
+godot_validated_utility_function GDAPI godot_variant_get_validated_utility_function_with_cstring(const char *p_function);
 godot_variant_utility_function_type GDAPI godot_variant_get_utility_function_type(const godot_string_name *p_function);
 godot_variant_utility_function_type GDAPI godot_variant_get_utility_function_type_with_cstring(const char *p_function);
 int GDAPI godot_variant_get_utility_function_argument_count(const godot_string_name *p_function);
diff --git a/modules/gdnative/include/gdnative/variant_struct.h b/modules/gdnative/include/gdnative/variant_struct.h
new file mode 100644
index 0000000000..321c76c206
--- /dev/null
+++ b/modules/gdnative/include/gdnative/variant_struct.h
@@ -0,0 +1,53 @@
+/*************************************************************************/
+/*  variant_struct.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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 GODOT_VARIANT_STRUCT_H
+#define GODOT_VARIANT_STRUCT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gdnative/math_defs.h>
+
+#define GODOT_VARIANT_SIZE (sizeof(godot_real_t) * 4 + sizeof(int64_t))
+
+#ifndef GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_VARIANT_SIZE];
+} godot_variant;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/modules/gdnative/include/gdnative/vector2.h b/modules/gdnative/include/gdnative/vector2.h
index a21ab304d0..5ebb705ba4 100644
--- a/modules/gdnative/include/gdnative/vector2.h
+++ b/modules/gdnative/include/gdnative/vector2.h
@@ -59,6 +59,10 @@ typedef struct {
 
 void GDAPI godot_vector2_new(godot_vector2 *p_self);
 void GDAPI godot_vector2i_new(godot_vector2i *p_self);
+godot_real_t GDAPI *godot_vector2_operator_index(godot_vector2 *p_self, godot_int p_index);
+const godot_real_t GDAPI *godot_vector2_operator_index_const(const godot_vector2 *p_self, godot_int p_index);
+int32_t GDAPI *godot_vector2i_operator_index(godot_vector2i *p_self, godot_int p_index);
+const int32_t GDAPI *godot_vector2i_operator_index_const(const godot_vector2i *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/include/gdnative/vector3.h b/modules/gdnative/include/gdnative/vector3.h
index 354c7555b6..d37ebd3cc9 100644
--- a/modules/gdnative/include/gdnative/vector3.h
+++ b/modules/gdnative/include/gdnative/vector3.h
@@ -59,6 +59,10 @@ typedef struct {
 
 void GDAPI godot_vector3_new(godot_vector3 *p_self);
 void GDAPI godot_vector3i_new(godot_vector3i *p_self);
+godot_real_t GDAPI *godot_vector3_operator_index(godot_vector3 *p_self, godot_int p_index);
+const godot_real_t GDAPI *godot_vector3_operator_index_const(const godot_vector3 *p_self, godot_int p_index);
+int32_t GDAPI *godot_vector3i_operator_index(godot_vector3i *p_self, godot_int p_index);
+const int32_t GDAPI *godot_vector3i_operator_index_const(const godot_vector3i *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnative/nativescript/api_generator.cpp b/modules/gdnative/nativescript/api_generator.cpp
index 2b824938f2..3e75478cd8 100644
--- a/modules/gdnative/nativescript/api_generator.cpp
+++ b/modules/gdnative/nativescript/api_generator.cpp
@@ -122,6 +122,7 @@ struct ClassAPI {
 	// @Unclear
 	bool is_reference = false;
 	bool has_indexing = false; // For builtin types.
+	String indexed_type; // For builtin types.
 	bool is_keyed = false; // For builtin types.
 
 	List<MethodAPI> methods;
@@ -141,7 +142,7 @@ static String get_type_name(const PropertyInfo &info) {
 		return info.class_name;
 	}
 	if (info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
-		return info.hint_string;
+		return info.class_name;
 	}
 	if (info.type == Variant::NIL && (info.usage & PROPERTY_USAGE_NIL_IS_VARIANT)) {
 		return "Variant";
@@ -196,11 +197,32 @@ List<ClassAPI> generate_c_api_classes() {
 		global_constants_api.singleton_name = "CoreConstants";
 		global_constants_api.is_instantiable = false;
 		const int constants_count = CoreConstants::get_global_constant_count();
+
+		Map<StringName, EnumAPI> enum_api_map;
 		for (int i = 0; i < constants_count; ++i) {
-			ConstantAPI constant_api;
-			constant_api.constant_name = CoreConstants::get_global_constant_name(i);
-			constant_api.constant_value = CoreConstants::get_global_constant_value(i);
-			global_constants_api.constants.push_back(constant_api);
+			StringName enum_name = CoreConstants::get_global_constant_enum(i);
+			String name = String(CoreConstants::get_global_constant_name(i));
+			int value = CoreConstants::get_global_constant_value(i);
+
+			if (enum_name == StringName()) {
+				ConstantAPI constant_api;
+				constant_api.constant_name = name;
+				constant_api.constant_value = value;
+				global_constants_api.constants.push_back(constant_api);
+			} else {
+				EnumAPI enum_api;
+				if (enum_api_map.has(enum_name)) {
+					enum_api = enum_api_map[enum_name];
+				} else {
+					enum_api.name = String(enum_name);
+				}
+				enum_api.values.push_back(Pair(value, name));
+
+				enum_api_map[enum_name] = enum_api;
+			}
+		}
+		for (const Map<StringName, EnumAPI>::Element *E = enum_api_map.front(); E; E = E->next()) {
+			global_constants_api.enums.push_back(E->get());
 		}
 		global_constants_api.constants.sort_custom<ConstantAPIComparator>();
 		api.push_back(global_constants_api);
@@ -308,7 +330,9 @@ List<ClassAPI> generate_c_api_classes() {
 					property_api.type = p->get().name.get_slice(":", 1);
 					property_api.name = p->get().name.get_slice(":", 0);
 				} else {
-					property_api.type = get_type_name(p->get());
+					MethodInfo minfo;
+					ClassDB::get_method_info(class_name, property_api.getter, &minfo, true, false);
+					property_api.type = get_type_name(minfo.return_val);
 				}
 
 				property_api.index = ClassDB::get_property_index(class_name, p->get().name);
@@ -370,7 +394,7 @@ List<ClassAPI> generate_c_api_classes() {
 						arg_type = arg_info.name.get_slice(":", 1);
 						arg_name = arg_info.name.get_slice(":", 0);
 					} else if (arg_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
-						arg_type = arg_info.hint_string;
+						arg_type = arg_info.class_name;
 					} else if (arg_info.type == Variant::NIL) {
 						arg_type = "Variant";
 					} else if (arg_info.type == Variant::OBJECT) {
@@ -468,6 +492,7 @@ List<ClassAPI> generate_c_builtin_api_types() {
 		class_api.class_name = Variant::get_type_name(type);
 		class_api.is_instantiable = true;
 		class_api.has_indexing = Variant::has_indexing(type);
+		class_api.indexed_type = Variant::get_type_name(Variant::get_indexed_element_type(type));
 		class_api.is_keyed = Variant::is_keyed(type);
 		// Types that are passed by reference.
 		switch (type) {
@@ -768,6 +793,7 @@ static List<String> generate_c_builtin_api_json(const List<ClassAPI> &p_api) {
 		append_indented(source, vformat(R"("is_instantiable": %s,)", class_api.is_instantiable ? "true" : "false"));
 		append_indented(source, vformat(R"("is_reference": %s,)", class_api.is_reference ? "true" : "false"));
 		append_indented(source, vformat(R"("has_indexing": %s,)", class_api.has_indexing ? "true" : "false"));
+		append_indented(source, vformat(R"("indexed_type": "%s",)", class_api.has_indexing && class_api.indexed_type == "Nil" ? "Variant" : class_api.indexed_type));
 		append_indented(source, vformat(R"("is_keyed": %s,)", class_api.is_keyed ? "true" : "false"));
 
 		// Constructors.