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

Merge pull request #45847 from vnen/gdnative-bindings 

Improve GDNative API and JSON generation further
This commit is contained in:
Rémi Verschelde 2021-02-11 11:11:29 +01:00 committed by GitHub
parent ab4c3ddf32 0b3819d213
commit 94cba993bf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 1098 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
modules/gdnative/gdnative/array.cpp
View File

@ -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

10
modules/gdnative/gdnative/basis.cpp
View File

@ -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

10
modules/gdnative/gdnative/color.cpp
View File

@ -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

11
modules/gdnative/gdnative/dictionary.cpp
View File

@ -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

11
modules/gdnative/gdnative/gdnative.cpp
View File

@ -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;

110
modules/gdnative/gdnative/packed_arrays.cpp
View File

@ -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

10
modules/gdnative/gdnative/quat.cpp
View File

@ -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

10
modules/gdnative/gdnative/transform2d.cpp
View File

@ -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

16
modules/gdnative/gdnative/variant.cpp
View File

@ -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));
}

20
modules/gdnative/gdnative/vector2.cpp
View File

@ -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

20
modules/gdnative/gdnative/vector3.cpp
View File

@ -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

714
modules/gdnative/gdnative_api.json
View File

@ -152,6 +152,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 *",
@ -2370,6 +2436,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",
@ -2665,6 +2771,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",
@ -2675,6 +2809,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",
@ -2705,6 +2867,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",
@ -2725,6 +2915,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",
@ -2765,6 +2983,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",
@ -2785,6 +3031,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",
@ -2805,6 +3079,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",
@ -2825,6 +3127,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",
@ -2845,6 +3175,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",
@ -2865,6 +3223,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",
@ -2885,6 +3271,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",
@ -2905,6 +3319,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",
@ -2925,6 +3367,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",
@ -2945,6 +3463,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",
@ -2965,6 +3511,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",
@ -3277,6 +3851,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",
@ -3287,6 +3889,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",
@ -3297,6 +3927,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",
@ -3307,6 +3965,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",
@ -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"
]
]
}
]
},

3
modules/gdnative/include/gdnative/array.h
View File

@ -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
}

2
modules/gdnative/include/gdnative/basis.h
View File

@ -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
}

2
modules/gdnative/include/gdnative/color.h
View File

@ -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
}

3
modules/gdnative/include/gdnative/dictionary.h
View File

@ -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
}

7
modules/gdnative/include/gdnative/gdnative.h
View File

@ -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);

29
modules/gdnative/include/gdnative/packed_arrays.h
View File

@ -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

2
modules/gdnative/include/gdnative/quat.h
View File

@ -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
}

2
modules/gdnative/include/gdnative/transform2d.h
View File

@ -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
}

14
modules/gdnative/include/gdnative/variant.h
View File

@ -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);

53
modules/gdnative/include/gdnative/variant_struct.h Normal file
View File

@ -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

4
modules/gdnative/include/gdnative/vector2.h
View File

@ -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
}

4
modules/gdnative/include/gdnative/vector3.h
View File

@ -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
}

40
modules/gdnative/nativescript/api_generator.cpp
View File

@ -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.