Merge pull request #51017 from vnen/extension-fixes
This commit is contained in:
Rémi Verschelde
GitHub
commit
46beaacec3
22 changed files with 617 additions and 95 deletions
|
|
@ -545,8 +545,26 @@ void register_global_constants() {
|
|||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_COLOR_NO_ALPHA);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_IMAGE_COMPRESS_LOSSY);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_OBJECT_ID);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_TYPE_STRING);
|
||||
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_METHOD_OF_VARIANT_TYPE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_METHOD_OF_BASE_TYPE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_METHOD_OF_INSTANCE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_METHOD_OF_SCRIPT);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_PROPERTY_OF_BASE_TYPE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_PROPERTY_OF_INSTANCE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_PROPERTY_OF_SCRIPT);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_OBJECT_TOO_BIG);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_NODE_PATH_VALID_TYPES);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_SAVE_FILE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_INT_IS_OBJECTID);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_ARRAY_TYPE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_HINT_MAX);
|
||||
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NONE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_STORAGE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_EDITOR);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NETWORK);
|
||||
|
|
@ -562,6 +580,22 @@ void register_global_constants() {
|
|||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_RESTART_IF_CHANGED);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_SCRIPT_VARIABLE);
|
||||
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_STORE_IF_NULL);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_ANIMATE_AS_TRIGGER);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_CLASS_IS_ENUM);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NIL_IS_VARIANT);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_INTERNAL);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_HIGH_END_GFX);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_KEYING_INCREMENTS);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_DEFERRED_SET_RESOURCE);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_EDITOR_BASIC_SETTING);
|
||||
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_DEFAULT);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_DEFAULT_INTL);
|
||||
BIND_CORE_ENUM_CONSTANT(PROPERTY_USAGE_NOEDITOR);
|
||||
|
|
|
|||
|
|
@ -38,6 +38,25 @@
|
|||
|
||||
#ifdef TOOLS_ENABLED
|
||||
|
||||
static String get_type_name(const PropertyInfo &p_info) {
|
||||
if (p_info.type == Variant::INT && (p_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM)) {
|
||||
return String("enum::") + String(p_info.class_name);
|
||||
}
|
||||
if (p_info.class_name != StringName()) {
|
||||
return p_info.class_name;
|
||||
}
|
||||
if (p_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
|
||||
return p_info.hint_string;
|
||||
}
|
||||
if (p_info.type == Variant::NIL && (p_info.usage & PROPERTY_USAGE_NIL_IS_VARIANT)) {
|
||||
return "Variant";
|
||||
}
|
||||
if (p_info.type == Variant::NIL) {
|
||||
return "void";
|
||||
}
|
||||
return Variant::get_type_name(p_info.type);
|
||||
}
|
||||
|
||||
Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
||||
Dictionary api_dump;
|
||||
|
||||
|
|
@ -60,20 +79,38 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
|
||||
const uint32_t vec3_elems = 3;
|
||||
const uint32_t ptrsize_32 = 4;
|
||||
const uint32_t ptrsize_64 = 4;
|
||||
const uint32_t ptrsize_64 = 8;
|
||||
static const char *build_config_name[4] = { "float_32", "float_64", "double_32", "double_64" };
|
||||
|
||||
{
|
||||
//type sizes
|
||||
struct {
|
||||
constexpr struct {
|
||||
Variant::Type type;
|
||||
uint32_t size_32_bits_real_float;
|
||||
uint32_t size_64_bits_real_float;
|
||||
uint32_t size_32_bits_real_double;
|
||||
uint32_t size_64_bits_real_double;
|
||||
|
||||
// For compile-time size check.
|
||||
constexpr uint32_t operator[](int index) const {
|
||||
switch (index) {
|
||||
#ifndef REAL_T_IS_DOUBLE
|
||||
case sizeof(uint32_t):
|
||||
return size_32_bits_real_float;
|
||||
case sizeof(uint64_t):
|
||||
return size_64_bits_real_float;
|
||||
#else // REAL_T_IS_DOUBLE
|
||||
case sizeof(uint32_t):
|
||||
return size_32_bits_real_double;
|
||||
case sizeof(uint64_t):
|
||||
return size_64_bits_real_double;
|
||||
#endif
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
} type_size_array[Variant::VARIANT_MAX + 1] = {
|
||||
{ Variant::NIL, 0, 0, 0, 0 },
|
||||
{ Variant::BOOL, sizeof(uint32_t), sizeof(uint32_t), sizeof(uint32_t), sizeof(uint32_t) },
|
||||
{ Variant::BOOL, sizeof(uint8_t), sizeof(uint8_t), sizeof(uint8_t), sizeof(uint8_t) },
|
||||
{ Variant::INT, sizeof(int64_t), sizeof(int64_t), sizeof(int64_t), sizeof(int64_t) },
|
||||
{ Variant::FLOAT, sizeof(double), sizeof(double), sizeof(double), sizeof(double) },
|
||||
{ Variant::STRING, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
|
|
@ -98,25 +135,62 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
{ Variant::SIGNAL, sizeof(Signal), sizeof(Signal), sizeof(Signal), sizeof(Signal) }, // Hardcoded align.
|
||||
{ Variant::DICTIONARY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_BYTE_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_INT32_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_INT64_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_FLOAT32_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_FLOAT64_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_STRING_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_VECTOR2_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_VECTOR3_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_COLOR_ARRAY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
|
||||
{ Variant::PACKED_BYTE_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_INT32_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_INT64_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_FLOAT32_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_FLOAT64_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_STRING_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_VECTOR2_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_VECTOR3_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::PACKED_COLOR_ARRAY, ptrsize_32 * 2, ptrsize_64 * 2, ptrsize_32 * 2, ptrsize_64 * 2 },
|
||||
{ Variant::VARIANT_MAX, sizeof(uint64_t) + sizeof(float) * 4, sizeof(uint64_t) + sizeof(float) * 4, sizeof(uint64_t) + sizeof(double) * 4, sizeof(uint64_t) + sizeof(double) * 4 },
|
||||
};
|
||||
|
||||
// Validate sizes at compile time for the current build configuration.
|
||||
static_assert(type_size_array[Variant::BOOL][sizeof(void *)] == sizeof(GDNativeBool), "Size of bool mismatch");
|
||||
static_assert(type_size_array[Variant::INT][sizeof(void *)] == sizeof(GDNativeInt), "Size of int mismatch");
|
||||
static_assert(type_size_array[Variant::FLOAT][sizeof(void *)] == sizeof(double), "Size of float mismatch");
|
||||
static_assert(type_size_array[Variant::STRING][sizeof(void *)] == sizeof(String), "Size of String mismatch");
|
||||
static_assert(type_size_array[Variant::VECTOR2][sizeof(void *)] == sizeof(Vector2), "Size of Vector2 mismatch");
|
||||
static_assert(type_size_array[Variant::VECTOR2I][sizeof(void *)] == sizeof(Vector2i), "Size of Vector2i mismatch");
|
||||
static_assert(type_size_array[Variant::RECT2][sizeof(void *)] == sizeof(Rect2), "Size of Rect2 mismatch");
|
||||
static_assert(type_size_array[Variant::RECT2I][sizeof(void *)] == sizeof(Rect2i), "Size of Rect2i mismatch");
|
||||
static_assert(type_size_array[Variant::VECTOR3][sizeof(void *)] == sizeof(Vector3), "Size of Vector3 mismatch");
|
||||
static_assert(type_size_array[Variant::VECTOR3I][sizeof(void *)] == sizeof(Vector3i), "Size of Vector3i mismatch");
|
||||
static_assert(type_size_array[Variant::TRANSFORM2D][sizeof(void *)] == sizeof(Transform2D), "Size of Transform2D mismatch");
|
||||
static_assert(type_size_array[Variant::PLANE][sizeof(void *)] == sizeof(Plane), "Size of Plane mismatch");
|
||||
static_assert(type_size_array[Variant::QUATERNION][sizeof(void *)] == sizeof(Quaternion), "Size of Quaternion mismatch");
|
||||
static_assert(type_size_array[Variant::AABB][sizeof(void *)] == sizeof(AABB), "Size of AABB mismatch");
|
||||
static_assert(type_size_array[Variant::BASIS][sizeof(void *)] == sizeof(Basis), "Size of Basis mismatch");
|
||||
static_assert(type_size_array[Variant::TRANSFORM3D][sizeof(void *)] == sizeof(Transform3D), "Size of Transform3D mismatch");
|
||||
static_assert(type_size_array[Variant::COLOR][sizeof(void *)] == sizeof(Color), "Size of Color mismatch");
|
||||
static_assert(type_size_array[Variant::STRING_NAME][sizeof(void *)] == sizeof(StringName), "Size of StringName mismatch");
|
||||
static_assert(type_size_array[Variant::NODE_PATH][sizeof(void *)] == sizeof(NodePath), "Size of NodePath mismatch");
|
||||
static_assert(type_size_array[Variant::RID][sizeof(void *)] == sizeof(RID), "Size of RID mismatch");
|
||||
static_assert(type_size_array[Variant::OBJECT][sizeof(void *)] == sizeof(Object *), "Size of Object mismatch");
|
||||
static_assert(type_size_array[Variant::CALLABLE][sizeof(void *)] == sizeof(Callable), "Size of Callable mismatch");
|
||||
static_assert(type_size_array[Variant::SIGNAL][sizeof(void *)] == sizeof(Signal), "Size of Signal mismatch");
|
||||
static_assert(type_size_array[Variant::DICTIONARY][sizeof(void *)] == sizeof(Dictionary), "Size of Dictionary mismatch");
|
||||
static_assert(type_size_array[Variant::ARRAY][sizeof(void *)] == sizeof(Array), "Size of Array mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_BYTE_ARRAY][sizeof(void *)] == sizeof(PackedByteArray), "Size of PackedByteArray mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_INT32_ARRAY][sizeof(void *)] == sizeof(PackedInt32Array), "Size of PackedInt32Array mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_INT64_ARRAY][sizeof(void *)] == sizeof(PackedInt64Array), "Size of PackedInt64Array mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_FLOAT32_ARRAY][sizeof(void *)] == sizeof(PackedFloat32Array), "Size of PackedFloat32Array mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_FLOAT64_ARRAY][sizeof(void *)] == sizeof(PackedFloat64Array), "Size of PackedFloat64Array mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_STRING_ARRAY][sizeof(void *)] == sizeof(PackedStringArray), "Size of PackedStringArray mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_VECTOR2_ARRAY][sizeof(void *)] == sizeof(PackedVector2Array), "Size of PackedVector2Array mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_VECTOR3_ARRAY][sizeof(void *)] == sizeof(PackedVector3Array), "Size of PackedVector3Array mismatch");
|
||||
static_assert(type_size_array[Variant::PACKED_COLOR_ARRAY][sizeof(void *)] == sizeof(PackedColorArray), "Size of PackedColorArray mismatch");
|
||||
static_assert(type_size_array[Variant::VARIANT_MAX][sizeof(void *)] == sizeof(Variant), "Size of Variant mismatch");
|
||||
|
||||
Array core_type_sizes;
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
Dictionary d;
|
||||
d["build_configuration"] = build_config_name[i];
|
||||
Array sizes;
|
||||
for (int j = 0; j < Variant::VARIANT_MAX; j++) {
|
||||
for (int j = 0; j <= Variant::VARIANT_MAX; j++) {
|
||||
Variant::Type t = type_size_array[j].type;
|
||||
String name = t == Variant::VARIANT_MAX ? String("Variant") : Variant::get_type_name(t);
|
||||
Dictionary d2;
|
||||
|
|
@ -356,6 +430,8 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
d["indexing_return_type"] = index_type == Variant::NIL ? String("Variant") : Variant::get_type_name(index_type);
|
||||
}
|
||||
|
||||
d["is_keyed"] = Variant::ValidatedKeyedSetter(type);
|
||||
|
||||
{
|
||||
//members
|
||||
Array members;
|
||||
|
|
@ -403,6 +479,7 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
if (k != Variant::OP_NEGATE && k != Variant::OP_POSITIVE && k != Variant::OP_NOT && k != Variant::OP_BIT_NEGATE) {
|
||||
d2["right_type"] = Variant::get_type_name(Variant::Type(j));
|
||||
}
|
||||
d2["return_type"] = Variant::get_type_name(Variant::get_operator_return_type(Variant::Operator(k), type, Variant::Type(j)));
|
||||
operators.push_back(d2);
|
||||
}
|
||||
}
|
||||
|
|
@ -482,6 +559,10 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
d["constructors"] = constructors;
|
||||
}
|
||||
}
|
||||
{
|
||||
//destructor
|
||||
d["has_destructor"] = Variant::has_destructor(type);
|
||||
}
|
||||
|
||||
builtins.push_back(d);
|
||||
}
|
||||
|
|
@ -590,16 +671,8 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
if (i >= 0) {
|
||||
d3["name"] = pinfo.name;
|
||||
}
|
||||
if (pinfo.class_name != StringName()) {
|
||||
d3["type"] = String(pinfo.class_name);
|
||||
} else {
|
||||
Variant::Type type = pinfo.type;
|
||||
if (type == Variant::NIL) {
|
||||
d3["type"] = "Variant";
|
||||
} else {
|
||||
d3["type"] = Variant::get_type_name(type);
|
||||
}
|
||||
}
|
||||
|
||||
d3["type"] = get_type_name(pinfo);
|
||||
|
||||
if (i == -1) {
|
||||
d2["return_value"] = d3;
|
||||
|
|
@ -641,16 +714,7 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
if (i >= 0) {
|
||||
d3["name"] = pinfo.name;
|
||||
}
|
||||
if (pinfo.class_name != StringName()) {
|
||||
d3["type"] = String(pinfo.class_name);
|
||||
} else {
|
||||
Variant::Type type = pinfo.type;
|
||||
if (type == Variant::NIL) {
|
||||
d3["type"] = "Variant";
|
||||
} else {
|
||||
d3["type"] = Variant::get_type_name(type);
|
||||
}
|
||||
}
|
||||
d3["type"] = get_type_name(pinfo);
|
||||
|
||||
if (method->get_argument_meta(i) > 0) {
|
||||
static const char *argmeta[11] = { "none", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64", "float", "double" };
|
||||
|
|
@ -697,14 +761,7 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
for (int i = 0; i < F.arguments.size(); i++) {
|
||||
Dictionary d3;
|
||||
d3["name"] = F.arguments[i].name;
|
||||
Variant::Type type = F.arguments[i].type;
|
||||
if (F.arguments[i].class_name != StringName()) {
|
||||
d3["type"] = String(F.arguments[i].class_name);
|
||||
} else if (type == Variant::NIL) {
|
||||
d3["type"] = "Variant";
|
||||
} else {
|
||||
d3["type"] = Variant::get_type_name(type);
|
||||
}
|
||||
d3["type"] = get_type_name(F.arguments[i]);
|
||||
arguments.push_back(d3);
|
||||
}
|
||||
if (arguments.size()) {
|
||||
|
|
@ -732,16 +789,8 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
|
|||
}
|
||||
StringName property_name = F.name;
|
||||
Dictionary d2;
|
||||
d2["type"] = get_type_name(F);
|
||||
d2["name"] = String(property_name);
|
||||
|
||||
if (F.class_name != StringName()) {
|
||||
d2["type"] = String(F.class_name);
|
||||
} else if (F.type == Variant::NIL && F.usage & PROPERTY_USAGE_NIL_IS_VARIANT) {
|
||||
d2["type"] = "Variant";
|
||||
} else {
|
||||
d2["type"] = Variant::get_type_name(F.type);
|
||||
}
|
||||
|
||||
d2["setter"] = ClassDB::get_property_setter(class_name, F.name);
|
||||
d2["getter"] = ClassDB::get_property_getter(class_name, F.name);
|
||||
d2["index"] = ClassDB::get_property_index(class_name, F.name);
|
||||
|
|
|
|||
|
|
@ -299,6 +299,161 @@ static GDNativeBool gdnative_variant_can_convert_strict(GDNativeVariantType p_fr
|
|||
return Variant::can_convert_strict((Variant::Type)p_from, (Variant::Type)p_to);
|
||||
}
|
||||
|
||||
// Variant interaction.
|
||||
static GDNativeVariantFromTypeConstructorFunc gdnative_get_variant_from_type_constructor(GDNativeVariantType p_type) {
|
||||
switch (p_type) {
|
||||
case GDNATIVE_VARIANT_TYPE_BOOL:
|
||||
return VariantTypeConstructor<bool>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_INT:
|
||||
return VariantTypeConstructor<int64_t>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_FLOAT:
|
||||
return VariantTypeConstructor<double>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_STRING:
|
||||
return VariantTypeConstructor<String>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR2:
|
||||
return VariantTypeConstructor<Vector2>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR2I:
|
||||
return VariantTypeConstructor<Vector2i>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_RECT2:
|
||||
return VariantTypeConstructor<Rect2>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_RECT2I:
|
||||
return VariantTypeConstructor<Rect2i>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR3:
|
||||
return VariantTypeConstructor<Vector3>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR3I:
|
||||
return VariantTypeConstructor<Vector3i>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_TRANSFORM2D:
|
||||
return VariantTypeConstructor<Transform2D>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PLANE:
|
||||
return VariantTypeConstructor<Plane>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_QUATERNION:
|
||||
return VariantTypeConstructor<Quaternion>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_AABB:
|
||||
return VariantTypeConstructor<AABB>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_BASIS:
|
||||
return VariantTypeConstructor<Basis>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_TRANSFORM3D:
|
||||
return VariantTypeConstructor<Transform3D>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_COLOR:
|
||||
return VariantTypeConstructor<Color>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_STRING_NAME:
|
||||
return VariantTypeConstructor<StringName>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_NODE_PATH:
|
||||
return VariantTypeConstructor<NodePath>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_RID:
|
||||
return VariantTypeConstructor<RID>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_OBJECT:
|
||||
return VariantTypeConstructor<Object *>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_CALLABLE:
|
||||
return VariantTypeConstructor<Callable>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_SIGNAL:
|
||||
return VariantTypeConstructor<Signal>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_DICTIONARY:
|
||||
return VariantTypeConstructor<Dictionary>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_ARRAY:
|
||||
return VariantTypeConstructor<Array>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_BYTE_ARRAY:
|
||||
return VariantTypeConstructor<PackedByteArray>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_INT32_ARRAY:
|
||||
return VariantTypeConstructor<PackedInt32Array>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_INT64_ARRAY:
|
||||
return VariantTypeConstructor<PackedInt64Array>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_FLOAT32_ARRAY:
|
||||
return VariantTypeConstructor<PackedFloat32Array>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_FLOAT64_ARRAY:
|
||||
return VariantTypeConstructor<PackedFloat64Array>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_STRING_ARRAY:
|
||||
return VariantTypeConstructor<PackedStringArray>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_VECTOR2_ARRAY:
|
||||
return VariantTypeConstructor<PackedVector2Array>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_VECTOR3_ARRAY:
|
||||
return VariantTypeConstructor<PackedVector3Array>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_COLOR_ARRAY:
|
||||
return VariantTypeConstructor<PackedColorArray>::variant_from_type;
|
||||
case GDNATIVE_VARIANT_TYPE_NIL:
|
||||
case GDNATIVE_VARIANT_TYPE_VARIANT_MAX:
|
||||
ERR_FAIL_V_MSG(nullptr, "Getting Variant conversion function with invalid type");
|
||||
}
|
||||
ERR_FAIL_V_MSG(nullptr, "Getting Variant conversion function with invalid type");
|
||||
}
|
||||
|
||||
static GDNativeTypeFromVariantConstructorFunc gdnative_get_type_from_variant_constructor(GDNativeVariantType p_type) {
|
||||
switch (p_type) {
|
||||
case GDNATIVE_VARIANT_TYPE_BOOL:
|
||||
return VariantTypeConstructor<bool>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_INT:
|
||||
return VariantTypeConstructor<int64_t>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_FLOAT:
|
||||
return VariantTypeConstructor<double>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_STRING:
|
||||
return VariantTypeConstructor<String>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR2:
|
||||
return VariantTypeConstructor<Vector2>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR2I:
|
||||
return VariantTypeConstructor<Vector2i>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_RECT2:
|
||||
return VariantTypeConstructor<Rect2>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_RECT2I:
|
||||
return VariantTypeConstructor<Rect2i>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR3:
|
||||
return VariantTypeConstructor<Vector3>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_VECTOR3I:
|
||||
return VariantTypeConstructor<Vector3i>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_TRANSFORM2D:
|
||||
return VariantTypeConstructor<Transform2D>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PLANE:
|
||||
return VariantTypeConstructor<Plane>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_QUATERNION:
|
||||
return VariantTypeConstructor<Quaternion>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_AABB:
|
||||
return VariantTypeConstructor<AABB>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_BASIS:
|
||||
return VariantTypeConstructor<Basis>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_TRANSFORM3D:
|
||||
return VariantTypeConstructor<Transform3D>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_COLOR:
|
||||
return VariantTypeConstructor<Color>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_STRING_NAME:
|
||||
return VariantTypeConstructor<StringName>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_NODE_PATH:
|
||||
return VariantTypeConstructor<NodePath>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_RID:
|
||||
return VariantTypeConstructor<RID>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_OBJECT:
|
||||
return VariantTypeConstructor<Object *>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_CALLABLE:
|
||||
return VariantTypeConstructor<Callable>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_SIGNAL:
|
||||
return VariantTypeConstructor<Signal>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_DICTIONARY:
|
||||
return VariantTypeConstructor<Dictionary>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_ARRAY:
|
||||
return VariantTypeConstructor<Array>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_BYTE_ARRAY:
|
||||
return VariantTypeConstructor<PackedByteArray>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_INT32_ARRAY:
|
||||
return VariantTypeConstructor<PackedInt32Array>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_INT64_ARRAY:
|
||||
return VariantTypeConstructor<PackedInt64Array>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_FLOAT32_ARRAY:
|
||||
return VariantTypeConstructor<PackedFloat32Array>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_FLOAT64_ARRAY:
|
||||
return VariantTypeConstructor<PackedFloat64Array>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_STRING_ARRAY:
|
||||
return VariantTypeConstructor<PackedStringArray>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_VECTOR2_ARRAY:
|
||||
return VariantTypeConstructor<PackedVector2Array>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_VECTOR3_ARRAY:
|
||||
return VariantTypeConstructor<PackedVector3Array>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_PACKED_COLOR_ARRAY:
|
||||
return VariantTypeConstructor<PackedColorArray>::type_from_variant;
|
||||
case GDNATIVE_VARIANT_TYPE_NIL:
|
||||
case GDNATIVE_VARIANT_TYPE_VARIANT_MAX:
|
||||
ERR_FAIL_V_MSG(nullptr, "Getting Variant conversion function with invalid type");
|
||||
}
|
||||
ERR_FAIL_V_MSG(nullptr, "Getting Variant conversion function with invalid type");
|
||||
}
|
||||
|
||||
// ptrcalls
|
||||
static GDNativePtrOperatorEvaluator gdnative_variant_get_ptr_operator_evaluator(GDNativeVariantOperator p_operator, GDNativeVariantType p_type_a, GDNativeVariantType p_type_b) {
|
||||
return (GDNativePtrOperatorEvaluator)Variant::get_ptr_operator_evaluator(Variant::Operator(p_operator), Variant::Type(p_type_a), Variant::Type(p_type_b));
|
||||
|
|
@ -316,6 +471,9 @@ static GDNativePtrBuiltInMethod gdnative_variant_get_ptr_builtin_method(GDNative
|
|||
static GDNativePtrConstructor gdnative_variant_get_ptr_constructor(GDNativeVariantType p_type, int32_t p_constructor) {
|
||||
return (GDNativePtrConstructor)Variant::get_ptr_constructor(Variant::Type(p_type), p_constructor);
|
||||
}
|
||||
static GDNativePtrDestructor gdnative_variant_get_ptr_destructor(GDNativeVariantType p_type) {
|
||||
return (GDNativePtrDestructor)Variant::get_ptr_destructor(Variant::Type(p_type));
|
||||
}
|
||||
static void gdnative_variant_construct(GDNativeVariantType p_type, GDNativeVariantPtr p_base, const GDNativeVariantPtr *p_args, int32_t p_argument_count, GDNativeCallError *r_error) {
|
||||
memnew_placement(p_base, Variant);
|
||||
|
||||
|
|
@ -521,11 +679,16 @@ static GDNativeObjectPtr gdnative_global_get_singleton(const char *p_name) {
|
|||
return (GDNativeObjectPtr)Engine::get_singleton()->get_singleton_object(String(p_name));
|
||||
}
|
||||
|
||||
static void *gdnative_object_get_instance_binding(GDNativeObjectPtr p_instance, void *p_token, GDNativeInstanceBindingCallbacks *p_callbacks) {
|
||||
static void *gdnative_object_get_instance_binding(GDNativeObjectPtr p_instance, void *p_token, const GDNativeInstanceBindingCallbacks *p_callbacks) {
|
||||
Object *o = (Object *)p_instance;
|
||||
return o->get_instance_binding(p_token, p_callbacks);
|
||||
}
|
||||
|
||||
static void gdnative_object_set_instance_binding(GDNativeObjectPtr p_instance, void *p_token, void *p_binding, const GDNativeInstanceBindingCallbacks *p_callbacks) {
|
||||
Object *o = (Object *)p_instance;
|
||||
o->set_instance_binding(p_token, p_binding, p_callbacks);
|
||||
}
|
||||
|
||||
static GDNativeObjectPtr gdnative_object_get_instance_from_id(GDObjectInstanceID p_instance_id) {
|
||||
return (GDNativeObjectPtr)ObjectDB::get_instance(ObjectID(p_instance_id));
|
||||
}
|
||||
|
|
@ -626,15 +789,15 @@ void gdnative_setup_interface(GDNativeInterface *p_interface) {
|
|||
gdni.variant_can_convert = gdnative_variant_can_convert;
|
||||
gdni.variant_can_convert_strict = gdnative_variant_can_convert_strict;
|
||||
|
||||
//ptrcalls
|
||||
#if 0
|
||||
GDNativeVariantFromTypeConstructorFunc (*get_variant_from_type_constructor)(GDNativeVariantType p_type);
|
||||
GDNativeTypeFromVariantConstructorFunc (*get_variant_to_type_constructor)(GDNativeVariantType p_type);
|
||||
#endif
|
||||
gdni.get_variant_from_type_constructor = gdnative_get_variant_from_type_constructor;
|
||||
gdni.get_variant_to_type_constructor = gdnative_get_type_from_variant_constructor;
|
||||
|
||||
// ptrcalls.
|
||||
|
||||
gdni.variant_get_ptr_operator_evaluator = gdnative_variant_get_ptr_operator_evaluator;
|
||||
gdni.variant_get_ptr_builtin_method = gdnative_variant_get_ptr_builtin_method;
|
||||
gdni.variant_get_ptr_constructor = gdnative_variant_get_ptr_constructor;
|
||||
gdni.variant_get_ptr_destructor = gdnative_variant_get_ptr_destructor;
|
||||
gdni.variant_construct = gdnative_variant_construct;
|
||||
gdni.variant_get_ptr_setter = gdnative_variant_get_ptr_setter;
|
||||
gdni.variant_get_ptr_getter = gdnative_variant_get_ptr_getter;
|
||||
|
|
@ -672,6 +835,7 @@ void gdnative_setup_interface(GDNativeInterface *p_interface) {
|
|||
gdni.object_destroy = gdnative_object_destroy;
|
||||
gdni.global_get_singleton = gdnative_global_get_singleton;
|
||||
gdni.object_get_instance_binding = gdnative_object_get_instance_binding;
|
||||
gdni.object_set_instance_binding = gdnative_object_set_instance_binding;
|
||||
|
||||
gdni.object_cast_to = gdnative_object_cast_to;
|
||||
gdni.object_get_instance_from_id = gdnative_object_get_instance_from_id;
|
||||
|
|
|
|||
|
|
@ -39,6 +39,11 @@
|
|||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifndef __cplusplus
|
||||
typedef uint32_t char32_t;
|
||||
typedef uint16_t char16_t;
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
|
@ -140,12 +145,12 @@ typedef uint64_t GDObjectInstanceID;
|
|||
/* VARIANT DATA I/O */
|
||||
|
||||
typedef enum {
|
||||
NATIVE_CALL_OK,
|
||||
NATIVE_CALL_ERROR_INVALID_METHOD,
|
||||
NATIVE_CALL_ERROR_INVALID_ARGUMENT, /* expected is variant type */
|
||||
NATIVE_CALL_ERROR_TOO_MANY_ARGUMENTS, /* expected is number of arguments */
|
||||
NATIVE_CALL_ERROR_TOO_FEW_ARGUMENTS, /* expected is number of arguments */
|
||||
NATIVE_CALL_ERROR_INSTANCE_IS_NULL,
|
||||
GDNATIVE_CALL_OK,
|
||||
GDNATIVE_CALL_ERROR_INVALID_METHOD,
|
||||
GDNATIVE_CALL_ERROR_INVALID_ARGUMENT, /* expected is variant type */
|
||||
GDNATIVE_CALL_ERROR_TOO_MANY_ARGUMENTS, /* expected is number of arguments */
|
||||
GDNATIVE_CALL_ERROR_TOO_FEW_ARGUMENTS, /* expected is number of arguments */
|
||||
GDNATIVE_CALL_ERROR_INSTANCE_IS_NULL,
|
||||
|
||||
} GDNativeCallErrorType;
|
||||
|
||||
|
|
@ -160,6 +165,7 @@ typedef void (*GDNativeTypeFromVariantConstructorFunc)(GDNativeTypePtr, GDNative
|
|||
typedef void (*GDNativePtrOperatorEvaluator)(const GDNativeTypePtr p_left, const GDNativeTypePtr p_right, GDNativeTypePtr r_result);
|
||||
typedef void (*GDNativePtrBuiltInMethod)(GDNativeTypePtr p_base, const GDNativeTypePtr *p_args, GDNativeTypePtr r_return, int p_argument_count);
|
||||
typedef void (*GDNativePtrConstructor)(GDNativeTypePtr p_base, const GDNativeTypePtr *p_args);
|
||||
typedef void (*GDNativePtrDestructor)(GDNativeTypePtr p_base);
|
||||
typedef void (*GDNativePtrSetter)(GDNativeTypePtr p_base, const GDNativeTypePtr p_value);
|
||||
typedef void (*GDNativePtrGetter)(const GDNativeTypePtr p_base, GDNativeTypePtr r_value);
|
||||
typedef void (*GDNativePtrIndexedSetter)(GDNativeTypePtr p_base, GDNativeInt p_index, const GDNativeTypePtr p_value);
|
||||
|
|
@ -173,7 +179,7 @@ typedef GDNativeObjectPtr (*GDNativeClassConstructor)();
|
|||
|
||||
typedef void *(*GDNativeInstanceBindingCreateCallback)(void *p_token, void *p_instance);
|
||||
typedef void (*GDNativeInstanceBindingFreeCallback)(void *p_token, void *p_instance, void *p_binding);
|
||||
typedef GDNativeBool (*GDNativeInstanceBindingReferenceCallback)(void *p_token, void *p_instance, GDNativeBool p_reference);
|
||||
typedef GDNativeBool (*GDNativeInstanceBindingReferenceCallback)(void *p_token, void *p_binding, GDNativeBool p_reference);
|
||||
|
||||
struct GDNativeInstanceBindingCallbacks {
|
||||
GDNativeInstanceBindingCreateCallback create_callback;
|
||||
|
|
@ -206,6 +212,7 @@ typedef void (*GDNativeExtensionClassUnreference)(GDExtensionClassInstancePtr p_
|
|||
typedef void (*GDNativeExtensionClassCallVirtual)(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret);
|
||||
typedef GDExtensionClassInstancePtr (*GDNativeExtensionClassCreateInstance)(void *p_userdata);
|
||||
typedef void (*GDNativeExtensionClassFreeInstance)(void *p_userdata, GDExtensionClassInstancePtr p_instance);
|
||||
typedef void (*GDNativeExtensionClassObjectInstance)(GDExtensionClassInstancePtr p_instance, GDNativeObjectPtr p_object_instance);
|
||||
typedef GDNativeExtensionClassCallVirtual (*GDNativeExtensionClassGetVirtual)(void *p_userdata, const char *p_name);
|
||||
|
||||
typedef struct {
|
||||
|
|
@ -219,7 +226,8 @@ typedef struct {
|
|||
GDNativeExtensionClassUnreference unreference_func;
|
||||
GDNativeExtensionClassCreateInstance create_instance_func; /* this one is mandatory */
|
||||
GDNativeExtensionClassFreeInstance free_instance_func; /* this one is mandatory */
|
||||
GDNativeExtensionClassGetVirtual get_firtual_func;
|
||||
GDNativeExtensionClassObjectInstance object_instance_func; /* this one is mandatory */
|
||||
GDNativeExtensionClassGetVirtual get_virtual_func;
|
||||
void *class_userdata;
|
||||
} GDNativeExtensionClassCreationInfo;
|
||||
|
||||
|
|
@ -256,8 +264,8 @@ typedef enum {
|
|||
GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_DOUBLE
|
||||
} GDNativeExtensionClassMethodArgumentMetadata;
|
||||
|
||||
typedef void (*GDNativeExtensionClassMethodCall)(GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error);
|
||||
typedef void (*GDNativeExtensionClassMethodPtrCall)(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret);
|
||||
typedef void (*GDNativeExtensionClassMethodCall)(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error);
|
||||
typedef void (*GDNativeExtensionClassMethodPtrCall)(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret);
|
||||
|
||||
/* passing -1 as argument in the following functions refers to the return type */
|
||||
typedef GDNativeVariantType (*GDNativeExtensionClassMethodGetArgumentType)(void *p_method_userdata, int32_t p_argument);
|
||||
|
|
@ -339,6 +347,7 @@ typedef struct {
|
|||
GDNativePtrOperatorEvaluator (*variant_get_ptr_operator_evaluator)(GDNativeVariantOperator p_operator, GDNativeVariantType p_type_a, GDNativeVariantType p_type_b);
|
||||
GDNativePtrBuiltInMethod (*variant_get_ptr_builtin_method)(GDNativeVariantType p_type, const char *p_method, GDNativeInt p_hash);
|
||||
GDNativePtrConstructor (*variant_get_ptr_constructor)(GDNativeVariantType p_type, int32_t p_constructor);
|
||||
GDNativePtrDestructor (*variant_get_ptr_destructor)(GDNativeVariantType p_type);
|
||||
void (*variant_construct)(GDNativeVariantType p_type, GDNativeVariantPtr p_base, const GDNativeVariantPtr *p_args, int32_t p_argument_count, GDNativeCallError *r_error);
|
||||
GDNativePtrSetter (*variant_get_ptr_setter)(GDNativeVariantType p_type, const char *p_member);
|
||||
GDNativePtrGetter (*variant_get_ptr_getter)(GDNativeVariantType p_type, const char *p_member);
|
||||
|
|
@ -383,7 +392,8 @@ typedef struct {
|
|||
void (*object_method_bind_ptrcall)(GDNativeMethodBindPtr p_method_bind, GDNativeObjectPtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret);
|
||||
void (*object_destroy)(GDNativeObjectPtr p_o);
|
||||
GDNativeObjectPtr (*global_get_singleton)(const char *p_name);
|
||||
void *(*object_get_instance_binding)(GDNativeObjectPtr p_o, void *p_token, GDNativeInstanceBindingCallbacks *p_callbacks);
|
||||
void *(*object_get_instance_binding)(GDNativeObjectPtr p_o, void *p_token, const GDNativeInstanceBindingCallbacks *p_callbacks);
|
||||
void (*object_set_instance_binding)(GDNativeObjectPtr p_o, void *p_token, void *p_binding, const GDNativeInstanceBindingCallbacks *p_callbacks);
|
||||
|
||||
GDNativeObjectPtr (*object_cast_to)(const GDNativeObjectPtr p_object, void *p_class_tag);
|
||||
GDNativeObjectPtr (*object_get_instance_from_id)(GDObjectInstanceID p_instance_id);
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@
|
|||
/*************************************************************************/
|
||||
|
||||
#include "native_extension.h"
|
||||
#include "core/config/project_settings.h"
|
||||
#include "core/io/config_file.h"
|
||||
#include "core/object/class_db.h"
|
||||
#include "core/object/method_bind.h"
|
||||
|
|
@ -69,7 +70,7 @@ public:
|
|||
Variant ret;
|
||||
GDExtensionClassInstancePtr extension_instance = p_object->_get_extension_instance();
|
||||
GDNativeCallError ce;
|
||||
call_func(extension_instance, (const GDNativeVariantPtr *)p_args, p_arg_count, (GDNativeVariantPtr)&ret, &ce);
|
||||
call_func(method_userdata, extension_instance, (const GDNativeVariantPtr *)p_args, p_arg_count, (GDNativeVariantPtr)&ret, &ce);
|
||||
r_error.error = Callable::CallError::Error(ce.error);
|
||||
r_error.argument = ce.argument;
|
||||
r_error.expected = ce.expected;
|
||||
|
|
@ -78,7 +79,7 @@ public:
|
|||
virtual void ptrcall(Object *p_object, const void **p_args, void *r_ret) {
|
||||
ERR_FAIL_COND_MSG(vararg, "Vararg methods don't have ptrcall support. This is most likely an engine bug.");
|
||||
GDExtensionClassInstancePtr extension_instance = p_object->_get_extension_instance();
|
||||
ptrcall_func(extension_instance, (const GDNativeTypePtr *)p_args, (GDNativeTypePtr)r_ret);
|
||||
ptrcall_func(method_userdata, extension_instance, (const GDNativeTypePtr *)p_args, (GDNativeTypePtr)r_ret);
|
||||
}
|
||||
|
||||
virtual bool is_vararg() const {
|
||||
|
|
@ -91,6 +92,7 @@ public:
|
|||
get_argument_type_func = p_method_info->get_argument_type_func;
|
||||
get_argument_info_func = p_method_info->get_argument_info_func;
|
||||
get_argument_metadata_func = p_method_info->get_argument_metadata_func;
|
||||
set_name(p_method_info->name);
|
||||
|
||||
vararg = p_method_info->method_flags & GDNATIVE_EXTENSION_METHOD_FLAG_VARARG;
|
||||
|
||||
|
|
@ -109,7 +111,7 @@ void NativeExtension::_register_extension_class(const GDNativeExtensionClassLibr
|
|||
NativeExtension *self = (NativeExtension *)p_library;
|
||||
|
||||
StringName class_name = p_class_name;
|
||||
ERR_FAIL_COND_MSG(String(class_name).is_valid_identifier(), "Attempt to register extension clas '" + class_name + "', which is not a valid class identifier.");
|
||||
ERR_FAIL_COND_MSG(!String(class_name).is_valid_identifier(), "Attempt to register extension class '" + class_name + "', which is not a valid class identifier.");
|
||||
ERR_FAIL_COND_MSG(ClassDB::class_exists(class_name), "Attempt to register extension class '" + class_name + "', which appears to be already registered.");
|
||||
|
||||
Extension *parent_extension = nullptr;
|
||||
|
|
@ -150,6 +152,7 @@ void NativeExtension::_register_extension_class(const GDNativeExtensionClassLibr
|
|||
extension->native_extension.unreference = p_extension_funcs->unreference_func;
|
||||
extension->native_extension.class_userdata = p_extension_funcs->class_userdata;
|
||||
extension->native_extension.create_instance = p_extension_funcs->create_instance_func;
|
||||
extension->native_extension.set_object_instance = p_extension_funcs->object_instance_func;
|
||||
extension->native_extension.free_instance = p_extension_funcs->free_instance_func;
|
||||
|
||||
ClassDB::register_extension_class(&extension->native_extension);
|
||||
|
|
@ -159,11 +162,12 @@ void NativeExtension::_register_extension_class_method(const GDNativeExtensionCl
|
|||
|
||||
StringName class_name = p_class_name;
|
||||
StringName method_name = p_method_info->name;
|
||||
ERR_FAIL_COND_MSG(self->extension_classes.has(class_name), "Attempt to register extension method '" + String(method_name) + "' for unexisting class '" + class_name + "'.");
|
||||
ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension method '" + String(method_name) + "' for unexisting class '" + class_name + "'.");
|
||||
|
||||
//Extension *extension = &self->extension_classes[class_name];
|
||||
|
||||
NativeExtensionMethodBind *method = memnew(NativeExtensionMethodBind(p_method_info));
|
||||
method->set_instance_class(class_name);
|
||||
|
||||
ClassDB::bind_method_custom(class_name, method);
|
||||
}
|
||||
|
|
@ -171,7 +175,7 @@ void NativeExtension::_register_extension_class_integer_constant(const GDNativeE
|
|||
NativeExtension *self = (NativeExtension *)p_library;
|
||||
|
||||
StringName class_name = p_class_name;
|
||||
ERR_FAIL_COND_MSG(self->extension_classes.has(class_name), "Attempt to register extension constant '" + String(p_constant_name) + "' for unexisting class '" + class_name + "'.");
|
||||
ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension constant '" + String(p_constant_name) + "' for unexisting class '" + class_name + "'.");
|
||||
|
||||
//Extension *extension = &self->extension_classes[class_name];
|
||||
|
||||
|
|
@ -181,7 +185,7 @@ void NativeExtension::_register_extension_class_property(const GDNativeExtension
|
|||
NativeExtension *self = (NativeExtension *)p_library;
|
||||
|
||||
StringName class_name = p_class_name;
|
||||
ERR_FAIL_COND_MSG(self->extension_classes.has(class_name), "Attempt to register extension class property '" + String(p_info->name) + "' for unexisting class '" + class_name + "'.");
|
||||
ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension class property '" + String(p_info->name) + "' for unexisting class '" + class_name + "'.");
|
||||
|
||||
//Extension *extension = &self->extension_classes[class_name];
|
||||
PropertyInfo pinfo;
|
||||
|
|
@ -199,7 +203,7 @@ void NativeExtension::_register_extension_class_signal(const GDNativeExtensionCl
|
|||
NativeExtension *self = (NativeExtension *)p_library;
|
||||
|
||||
StringName class_name = p_class_name;
|
||||
ERR_FAIL_COND_MSG(self->extension_classes.has(class_name), "Attempt to register extension class signal '" + String(p_signal_name) + "' for unexisting class '" + class_name + "'.");
|
||||
ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension class signal '" + String(p_signal_name) + "' for unexisting class '" + class_name + "'.");
|
||||
|
||||
MethodInfo s;
|
||||
s.name = p_signal_name;
|
||||
|
|
@ -220,7 +224,7 @@ void NativeExtension::_unregister_extension_class(const GDNativeExtensionClassLi
|
|||
NativeExtension *self = (NativeExtension *)p_library;
|
||||
|
||||
StringName class_name = p_class_name;
|
||||
ERR_FAIL_COND_MSG(self->extension_classes.has(class_name), "Attempt to unregister unexisting extension class '" + class_name + "'.");
|
||||
ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to unregister unexisting extension class '" + class_name + "'.");
|
||||
Extension *ext = &self->extension_classes[class_name];
|
||||
ERR_FAIL_COND_MSG(ext->native_extension.children.size(), "Attempt to unregister class '" + class_name + "' while other extension classes inherit from it.");
|
||||
|
||||
|
|
@ -368,7 +372,7 @@ RES NativeExtensionResourceLoader::load(const String &p_path, const String &p_or
|
|||
}
|
||||
}
|
||||
|
||||
if (library_path != String()) {
|
||||
if (library_path == String()) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_FILE_NOT_FOUND;
|
||||
}
|
||||
|
|
@ -381,7 +385,8 @@ RES NativeExtensionResourceLoader::load(const String &p_path, const String &p_or
|
|||
|
||||
Ref<NativeExtension> lib;
|
||||
lib.instantiate();
|
||||
err = lib->open_library(library_path, entry_symbol);
|
||||
String abs_path = ProjectSettings::get_singleton()->globalize_path(library_path);
|
||||
err = lib->open_library(abs_path, entry_symbol);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = err;
|
||||
|
|
|
|||
|
|
@ -35,8 +35,8 @@
|
|||
#include "core/io/resource_loader.h"
|
||||
#include "core/object/ref_counted.h"
|
||||
|
||||
class NativeExtension : public RefCounted {
|
||||
GDCLASS(NativeExtension, RefCounted)
|
||||
class NativeExtension : public Resource {
|
||||
GDCLASS(NativeExtension, Resource)
|
||||
|
||||
void *library = nullptr; // pointer if valid,
|
||||
|
||||
|
|
|
|||
|
|
@ -505,11 +505,12 @@ thread_local bool initializing_with_extension = false;
|
|||
thread_local ObjectNativeExtension *initializing_extension = nullptr;
|
||||
thread_local GDExtensionClassInstancePtr initializing_extension_instance = nullptr;
|
||||
|
||||
void ClassDB::instance_get_native_extension_data(ObjectNativeExtension **r_extension, GDExtensionClassInstancePtr *r_extension_instance) {
|
||||
void ClassDB::instance_get_native_extension_data(ObjectNativeExtension **r_extension, GDExtensionClassInstancePtr *r_extension_instance, Object *p_base) {
|
||||
if (initializing_with_extension) {
|
||||
*r_extension = initializing_extension;
|
||||
*r_extension_instance = initializing_extension_instance;
|
||||
initializing_with_extension = false;
|
||||
initializing_extension->set_object_instance(*r_extension_instance, p_base);
|
||||
} else {
|
||||
*r_extension = nullptr;
|
||||
*r_extension_instance = nullptr;
|
||||
|
|
@ -1592,7 +1593,7 @@ void ClassDB::register_extension_class(ObjectNativeExtension *p_extension) {
|
|||
GLOBAL_LOCK_FUNCTION;
|
||||
|
||||
ERR_FAIL_COND_MSG(classes.has(p_extension->class_name), "Class already registered: " + String(p_extension->class_name));
|
||||
ERR_FAIL_COND_MSG(classes.has(p_extension->parent_class_name), "Parent class name for extension class not found: " + String(p_extension->parent_class_name));
|
||||
ERR_FAIL_COND_MSG(!classes.has(p_extension->parent_class_name), "Parent class name for extension class not found: " + String(p_extension->parent_class_name));
|
||||
|
||||
ClassInfo *parent = classes.getptr(p_extension->parent_class_name);
|
||||
|
||||
|
|
@ -1604,6 +1605,7 @@ void ClassDB::register_extension_class(ObjectNativeExtension *p_extension) {
|
|||
c.inherits = parent->name;
|
||||
c.class_ptr = parent->class_ptr;
|
||||
c.inherits_ptr = parent;
|
||||
c.exposed = true;
|
||||
|
||||
classes[p_extension->class_name] = c;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -233,7 +233,7 @@ public:
|
|||
static bool is_parent_class(const StringName &p_class, const StringName &p_inherits);
|
||||
static bool can_instantiate(const StringName &p_class);
|
||||
static Object *instantiate(const StringName &p_class);
|
||||
static void instance_get_native_extension_data(ObjectNativeExtension **r_extension, GDExtensionClassInstancePtr *r_extension_instance);
|
||||
static void instance_get_native_extension_data(ObjectNativeExtension **r_extension, GDExtensionClassInstancePtr *r_extension_instance, Object *p_base);
|
||||
|
||||
static APIType get_api_type(const StringName &p_class);
|
||||
|
||||
|
|
|
|||
|
|
@ -1815,7 +1815,7 @@ void Object::_construct_object(bool p_reference) {
|
|||
type_is_reference = p_reference;
|
||||
_instance_id = ObjectDB::add_instance(this);
|
||||
|
||||
ClassDB::instance_get_native_extension_data(&_extension, &_extension_instance);
|
||||
ClassDB::instance_get_native_extension_data(&_extension, &_extension_instance, this);
|
||||
|
||||
#ifdef DEBUG_ENABLED
|
||||
_lock_index.init(1);
|
||||
|
|
@ -1876,7 +1876,7 @@ Object::~Object() {
|
|||
if (_instance_bindings != nullptr) {
|
||||
for (uint32_t i = 0; i < _instance_binding_count; i++) {
|
||||
if (_instance_bindings[i].free_callback) {
|
||||
_instance_bindings[i].free_callback(_instance_bindings[i].token, _instance_bindings[i].binding, this);
|
||||
_instance_bindings[i].free_callback(_instance_bindings[i].token, this, _instance_bindings[i].binding);
|
||||
}
|
||||
}
|
||||
memfree(_instance_bindings);
|
||||
|
|
|
|||
|
|
@ -272,6 +272,7 @@ struct ObjectNativeExtension {
|
|||
|
||||
GDNativeExtensionClassCreateInstance create_instance;
|
||||
GDNativeExtensionClassFreeInstance free_instance;
|
||||
GDNativeExtensionClassObjectInstance set_object_instance;
|
||||
GDNativeExtensionClassGetVirtual get_virtual;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -82,6 +82,7 @@ static Ref<ResourceFormatLoaderImage> resource_format_image;
|
|||
static Ref<TranslationLoaderPO> resource_format_po;
|
||||
static Ref<ResourceFormatSaverCrypto> resource_format_saver_crypto;
|
||||
static Ref<ResourceFormatLoaderCrypto> resource_format_loader_crypto;
|
||||
static Ref<NativeExtensionResourceLoader> resource_loader_native_extension;
|
||||
|
||||
static _ResourceLoader *_resource_loader = nullptr;
|
||||
static _ResourceSaver *_resource_saver = nullptr;
|
||||
|
|
@ -234,6 +235,9 @@ void register_core_types() {
|
|||
|
||||
native_extension_manager = memnew(NativeExtensionManager);
|
||||
|
||||
resource_loader_native_extension.instantiate();
|
||||
ResourceLoader::add_resource_format_loader(resource_loader_native_extension);
|
||||
|
||||
ip = IP::create();
|
||||
|
||||
_geometry_2d = memnew(_Geometry2D);
|
||||
|
|
@ -298,6 +302,7 @@ void register_core_singletons() {
|
|||
|
||||
void register_core_extensions() {
|
||||
// Hardcoded for now.
|
||||
NativeExtension::initialize_native_extensions();
|
||||
if (ProjectSettings::get_singleton()->has_setting("native_extensions/paths")) {
|
||||
Vector<String> paths = ProjectSettings::get_singleton()->get("native_extensions/paths");
|
||||
for (int i = 0; i < paths.size(); i++) {
|
||||
|
|
@ -349,6 +354,9 @@ void unregister_core_types() {
|
|||
memdelete(ip);
|
||||
}
|
||||
|
||||
ResourceLoader::remove_resource_format_loader(resource_loader_native_extension);
|
||||
resource_loader_native_extension.unref();
|
||||
|
||||
ResourceLoader::finalize();
|
||||
|
||||
ClassDB::cleanup_defaults();
|
||||
|
|
|
|||
|
|
@ -3533,12 +3533,13 @@ void Variant::register_types() {
|
|||
_register_variant_methods();
|
||||
_register_variant_setters_getters();
|
||||
_register_variant_constructors();
|
||||
_register_variant_destructors();
|
||||
_register_variant_utility_functions();
|
||||
}
|
||||
void Variant::unregister_types() {
|
||||
_unregister_variant_operators();
|
||||
_unregister_variant_methods();
|
||||
_unregister_variant_setters_getters();
|
||||
_unregister_variant_constructors();
|
||||
_unregister_variant_destructors();
|
||||
_unregister_variant_utility_functions();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -208,7 +208,7 @@ private:
|
|||
Transform3D *_transform3d;
|
||||
PackedArrayRefBase *packed_array;
|
||||
void *_ptr; //generic pointer
|
||||
uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)];
|
||||
uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)]{ 0 };
|
||||
} _data alignas(8);
|
||||
|
||||
void reference(const Variant &p_variant);
|
||||
|
|
@ -271,6 +271,8 @@ private:
|
|||
static void _register_variant_setters_getters();
|
||||
static void _unregister_variant_setters_getters();
|
||||
static void _register_variant_constructors();
|
||||
static void _unregister_variant_destructors();
|
||||
static void _register_variant_destructors();
|
||||
static void _unregister_variant_constructors();
|
||||
static void _register_variant_utility_functions();
|
||||
static void _unregister_variant_utility_functions();
|
||||
|
|
@ -534,6 +536,14 @@ public:
|
|||
|
||||
static void get_constructor_list(Type p_type, List<MethodInfo> *r_list); //convenience
|
||||
|
||||
/* Destructors */
|
||||
|
||||
// Only ptrcall is available.
|
||||
typedef void (*PTRDestructor)(void *base);
|
||||
|
||||
static PTRDestructor get_ptr_destructor(Variant::Type p_type);
|
||||
static bool has_destructor(Variant::Type p_type);
|
||||
|
||||
/* Properties */
|
||||
|
||||
void set_named(const StringName &p_member, const Variant &p_value, bool &r_valid);
|
||||
|
|
|
|||
|
|
@ -1709,7 +1709,7 @@ static void _register_variant_builtin_methods() {
|
|||
bind_method(Transform2D, interpolate_with, sarray("xform", "weight"), varray());
|
||||
bind_method(Transform2D, is_equal_approx, sarray("xform"), varray());
|
||||
bind_method(Transform2D, set_rotation, sarray("rotation"), varray());
|
||||
bind_method(Transform2D, looking_at, sarray("target"), varray(Transform2D()));
|
||||
bind_method(Transform2D, looking_at, sarray("target"), varray(Vector2()));
|
||||
|
||||
/* Basis */
|
||||
|
||||
|
|
|
|||
78
core/variant/variant_destruct.cpp
Normal file
78
core/variant/variant_destruct.cpp
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
/*************************************************************************/
|
||||
/* variant_destruct.cpp */
|
||||
/*************************************************************************/
|
||||
/* 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. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "variant_destruct.h"
|
||||
|
||||
#include "core/templates/local_vector.h"
|
||||
|
||||
static Variant::PTRDestructor destruct_pointers[Variant::VARIANT_MAX] = { nullptr };
|
||||
|
||||
template <class T>
|
||||
static void add_destructor() {
|
||||
destruct_pointers[T::get_base_type()] = T::ptr_destruct;
|
||||
}
|
||||
|
||||
void Variant::_register_variant_destructors() {
|
||||
add_destructor<VariantDestruct<String>>();
|
||||
add_destructor<VariantDestruct<Transform2D>>();
|
||||
add_destructor<VariantDestruct<::AABB>>();
|
||||
add_destructor<VariantDestruct<Basis>>();
|
||||
add_destructor<VariantDestruct<Transform3D>>();
|
||||
add_destructor<VariantDestruct<StringName>>();
|
||||
add_destructor<VariantDestruct<NodePath>>();
|
||||
add_destructor<VariantDestruct<::RID>>();
|
||||
add_destructor<VariantDestruct<Callable>>();
|
||||
add_destructor<VariantDestruct<Signal>>();
|
||||
add_destructor<VariantDestruct<Dictionary>>();
|
||||
add_destructor<VariantDestruct<Array>>();
|
||||
add_destructor<VariantDestruct<PackedByteArray>>();
|
||||
add_destructor<VariantDestruct<PackedInt32Array>>();
|
||||
add_destructor<VariantDestruct<PackedInt64Array>>();
|
||||
add_destructor<VariantDestruct<PackedFloat32Array>>();
|
||||
add_destructor<VariantDestruct<PackedFloat64Array>>();
|
||||
add_destructor<VariantDestruct<PackedStringArray>>();
|
||||
add_destructor<VariantDestruct<PackedVector2Array>>();
|
||||
add_destructor<VariantDestruct<PackedVector3Array>>();
|
||||
add_destructor<VariantDestruct<PackedColorArray>>();
|
||||
}
|
||||
|
||||
void Variant::_unregister_variant_destructors() {
|
||||
// Nothing to be done.
|
||||
}
|
||||
|
||||
Variant::PTRDestructor Variant::get_ptr_destructor(Variant::Type p_type) {
|
||||
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
|
||||
return destruct_pointers[p_type];
|
||||
}
|
||||
|
||||
bool Variant::has_destructor(Variant::Type p_type) {
|
||||
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
|
||||
return destruct_pointers[p_type] != nullptr;
|
||||
}
|
||||
76
core/variant/variant_destruct.h
Normal file
76
core/variant/variant_destruct.h
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
/*************************************************************************/
|
||||
/* variant_destruct.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 VARIANT_DESTRUCT_H
|
||||
#define VARIANT_DESTRUCT_H
|
||||
|
||||
#include "core/variant/variant.h"
|
||||
|
||||
#include "core/object/class_db.h"
|
||||
|
||||
template <class T>
|
||||
struct VariantDestruct {};
|
||||
|
||||
#define MAKE_PTRDESTRUCT(m_type) \
|
||||
template <> \
|
||||
struct VariantDestruct<m_type> { \
|
||||
_FORCE_INLINE_ static void ptr_destruct(void *p_ptr) { \
|
||||
reinterpret_cast<m_type *>(p_ptr)->~m_type(); \
|
||||
} \
|
||||
_FORCE_INLINE_ static Variant::Type get_base_type() { \
|
||||
return GetTypeInfo<m_type>::VARIANT_TYPE; \
|
||||
} \
|
||||
}
|
||||
|
||||
MAKE_PTRDESTRUCT(String);
|
||||
MAKE_PTRDESTRUCT(Transform2D);
|
||||
MAKE_PTRDESTRUCT(AABB);
|
||||
MAKE_PTRDESTRUCT(Basis);
|
||||
MAKE_PTRDESTRUCT(Transform3D);
|
||||
MAKE_PTRDESTRUCT(StringName);
|
||||
MAKE_PTRDESTRUCT(NodePath);
|
||||
MAKE_PTRDESTRUCT(RID);
|
||||
MAKE_PTRDESTRUCT(Callable);
|
||||
MAKE_PTRDESTRUCT(Signal);
|
||||
MAKE_PTRDESTRUCT(Dictionary);
|
||||
MAKE_PTRDESTRUCT(Array);
|
||||
MAKE_PTRDESTRUCT(PackedByteArray);
|
||||
MAKE_PTRDESTRUCT(PackedInt32Array);
|
||||
MAKE_PTRDESTRUCT(PackedInt64Array);
|
||||
MAKE_PTRDESTRUCT(PackedFloat32Array);
|
||||
MAKE_PTRDESTRUCT(PackedFloat64Array);
|
||||
MAKE_PTRDESTRUCT(PackedStringArray);
|
||||
MAKE_PTRDESTRUCT(PackedVector2Array);
|
||||
MAKE_PTRDESTRUCT(PackedVector3Array);
|
||||
MAKE_PTRDESTRUCT(PackedColorArray);
|
||||
|
||||
#undef MAKE_PTRDESTRUCT
|
||||
|
||||
#endif // VARIANT_DESTRUCT_H
|
||||
|
|
@ -1171,6 +1171,11 @@ struct VariantInitializer<PackedColorArray> {
|
|||
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_color_array(v); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct VariantInitializer<Object *> {
|
||||
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::object_assign_null(v); }
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct VariantZeroAssigner {
|
||||
};
|
||||
|
|
@ -1385,4 +1390,19 @@ struct VariantTypeAdjust<Object *> {
|
|||
}
|
||||
};
|
||||
|
||||
// GDNative extension helpers.
|
||||
|
||||
template <class T>
|
||||
struct VariantTypeConstructor {
|
||||
_FORCE_INLINE_ static void variant_from_type(void *p_variant, void *p_value) {
|
||||
Variant *variant = reinterpret_cast<Variant *>(p_variant);
|
||||
VariantInitializer<T>::init(variant);
|
||||
VariantInternalAccessor<T>::set(variant, *((T *)p_value));
|
||||
}
|
||||
|
||||
_FORCE_INLINE_ static void type_from_variant(void *p_value, void *p_variant) {
|
||||
*((T *)p_value) = VariantInternalAccessor<T>::get(reinterpret_cast<Variant *>(p_variant));
|
||||
}
|
||||
};
|
||||
|
||||
#endif // VARIANT_INTERNAL_H
|
||||
|
|
|
|||
|
|
@ -2306,6 +2306,8 @@
|
|||
<constant name="PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS" value="23" enum="PropertyHint">
|
||||
Hints that an image is compressed using lossless compression.
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_OBJECT_ID" value="24" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_TYPE_STRING" value="25" enum="PropertyHint">
|
||||
Hint that a property represents a particular type. If a property is [constant TYPE_STRING], allows to set a type from the create dialog. If you need to create an [Array] to contain elements of a specific type, the [code]hint_string[/code] must encode nested types using [code]":"[/code] and [code]"/"[/code] for specifying [Resource] types. For instance:
|
||||
[codeblock]
|
||||
|
|
@ -2316,6 +2318,38 @@
|
|||
[/codeblock]
|
||||
[b]Note:[/b] the final colon is required to specify for properly detecting built-in types.
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE" value="26" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_METHOD_OF_VARIANT_TYPE" value="27" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_METHOD_OF_BASE_TYPE" value="28" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_METHOD_OF_INSTANCE" value="29" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_METHOD_OF_SCRIPT" value="30" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE" value="31" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_PROPERTY_OF_BASE_TYPE" value="32" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_PROPERTY_OF_INSTANCE" value="33" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_PROPERTY_OF_SCRIPT" value="34" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_OBJECT_TOO_BIG" value="35" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_NODE_PATH_VALID_TYPES" value="36" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_SAVE_FILE" value="37" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_INT_IS_OBJECTID" value="38" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_ARRAY_TYPE" value="39" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_HINT_MAX" value="40" enum="PropertyHint">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_NONE" value="0" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_STORAGE" value="1" enum="PropertyUsageFlags">
|
||||
The property is serialized and saved in the scene file (default).
|
||||
</constant>
|
||||
|
|
@ -2355,6 +2389,36 @@
|
|||
<constant name="PROPERTY_USAGE_SCRIPT_VARIABLE" value="8192" enum="PropertyUsageFlags">
|
||||
The property is a script variable which should be serialized and saved in the scene file.
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_STORE_IF_NULL" value="16384" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_ANIMATE_AS_TRIGGER" value="32768" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED" value="65536" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE" value="131072" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_CLASS_IS_ENUM" value="262144" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_NIL_IS_VARIANT" value="524288" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_INTERNAL" value="1048576" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE" value="2097152" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_HIGH_END_GFX" value="4194304" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT" value="8388608" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT" value="16777216" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_KEYING_INCREMENTS" value="33554432" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_DEFERRED_SET_RESOURCE" value="67108864" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT" value="134217728" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_EDITOR_BASIC_SETTING" value="268435456" enum="PropertyUsageFlags">
|
||||
</constant>
|
||||
<constant name="PROPERTY_USAGE_DEFAULT" value="7" enum="PropertyUsageFlags">
|
||||
Default usage (storage, editor and network).
|
||||
</constant>
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
<?xml version="1.0" encoding="UTF-8" ?>
|
||||
<class name="NativeExtension" inherits="RefCounted" version="4.0">
|
||||
<class name="NativeExtension" inherits="Resource" version="4.0">
|
||||
<brief_description>
|
||||
</brief_description>
|
||||
<description>
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@
|
|||
<argument index="5" name="clear_color_values" type="PackedColorArray" default="PackedColorArray()" />
|
||||
<argument index="6" name="clear_depth" type="float" default="1.0" />
|
||||
<argument index="7" name="clear_stencil" type="int" default="0" />
|
||||
<argument index="8" name="region" type="Rect2" default="Rect2i(0, 0, 0, 0)" />
|
||||
<argument index="8" name="region" type="Rect2" default="Rect2(0, 0, 0, 0)" />
|
||||
<argument index="9" name="storage_textures" type="Array" default="[]" />
|
||||
<description>
|
||||
</description>
|
||||
|
|
@ -165,7 +165,7 @@
|
|||
<argument index="6" name="clear_color_values" type="PackedColorArray" default="PackedColorArray()" />
|
||||
<argument index="7" name="clear_depth" type="float" default="1.0" />
|
||||
<argument index="8" name="clear_stencil" type="int" default="0" />
|
||||
<argument index="9" name="region" type="Rect2" default="Rect2i(0, 0, 0, 0)" />
|
||||
<argument index="9" name="region" type="Rect2" default="Rect2(0, 0, 0, 0)" />
|
||||
<argument index="10" name="storage_textures" type="RID[]" default="[]" />
|
||||
<description>
|
||||
</description>
|
||||
|
|
@ -217,7 +217,7 @@
|
|||
<method name="draw_list_enable_scissor">
|
||||
<return type="void" />
|
||||
<argument index="0" name="draw_list" type="int" />
|
||||
<argument index="1" name="rect" type="Rect2" default="Rect2i(0, 0, 0, 0)" />
|
||||
<argument index="1" name="rect" type="Rect2" default="Rect2(0, 0, 0, 0)" />
|
||||
<description>
|
||||
</description>
|
||||
</method>
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@
|
|||
</method>
|
||||
<method name="looking_at" qualifiers="const">
|
||||
<return type="Transform2D" />
|
||||
<argument index="0" name="target" type="Vector2" default="Transform2D(1, 0, 0, 1, 0, 0)" />
|
||||
<argument index="0" name="target" type="Vector2" default="Vector2(0, 0)" />
|
||||
<description>
|
||||
Returns a copy of the transform rotated such that it's rotation on the X-axis points towards the [code]target[/code] position.
|
||||
Operations take place in global space.
|
||||
|
|
|
|||
|
|
@ -420,8 +420,8 @@ void RenderingDevice::_bind_methods() {
|
|||
|
||||
ClassDB::bind_method(D_METHOD("draw_list_begin_for_screen", "screen", "clear_color"), &RenderingDevice::draw_list_begin_for_screen, DEFVAL(DisplayServer::MAIN_WINDOW_ID), DEFVAL(Color()));
|
||||
|
||||
ClassDB::bind_method(D_METHOD("draw_list_begin", "framebuffer", "initial_color_action", "final_color_action", "initial_depth_action", "final_depth_action", "clear_color_values", "clear_depth", "clear_stencil", "region", "storage_textures"), &RenderingDevice::draw_list_begin, DEFVAL(Vector<Color>()), DEFVAL(1.0), DEFVAL(0), DEFVAL(Rect2i()), DEFVAL(TypedArray<RID>()));
|
||||
ClassDB::bind_method(D_METHOD("draw_list_begin_split", "framebuffer", "splits", "initial_color_action", "final_color_action", "initial_depth_action", "final_depth_action", "clear_color_values", "clear_depth", "clear_stencil", "region", "storage_textures"), &RenderingDevice::_draw_list_begin_split, DEFVAL(Vector<Color>()), DEFVAL(1.0), DEFVAL(0), DEFVAL(Rect2i()), DEFVAL(TypedArray<RID>()));
|
||||
ClassDB::bind_method(D_METHOD("draw_list_begin", "framebuffer", "initial_color_action", "final_color_action", "initial_depth_action", "final_depth_action", "clear_color_values", "clear_depth", "clear_stencil", "region", "storage_textures"), &RenderingDevice::draw_list_begin, DEFVAL(Vector<Color>()), DEFVAL(1.0), DEFVAL(0), DEFVAL(Rect2()), DEFVAL(TypedArray<RID>()));
|
||||
ClassDB::bind_method(D_METHOD("draw_list_begin_split", "framebuffer", "splits", "initial_color_action", "final_color_action", "initial_depth_action", "final_depth_action", "clear_color_values", "clear_depth", "clear_stencil", "region", "storage_textures"), &RenderingDevice::_draw_list_begin_split, DEFVAL(Vector<Color>()), DEFVAL(1.0), DEFVAL(0), DEFVAL(Rect2()), DEFVAL(TypedArray<RID>()));
|
||||
|
||||
ClassDB::bind_method(D_METHOD("draw_list_bind_render_pipeline", "draw_list", "render_pipeline"), &RenderingDevice::draw_list_bind_render_pipeline);
|
||||
ClassDB::bind_method(D_METHOD("draw_list_bind_uniform_set", "draw_list", "uniform_set", "set_index"), &RenderingDevice::draw_list_bind_uniform_set);
|
||||
|
|
@ -431,7 +431,7 @@ void RenderingDevice::_bind_methods() {
|
|||
|
||||
ClassDB::bind_method(D_METHOD("draw_list_draw", "draw_list", "use_indices", "instances", "procedural_vertex_count"), &RenderingDevice::draw_list_draw, DEFVAL(0));
|
||||
|
||||
ClassDB::bind_method(D_METHOD("draw_list_enable_scissor", "draw_list", "rect"), &RenderingDevice::draw_list_enable_scissor, DEFVAL(Rect2i()));
|
||||
ClassDB::bind_method(D_METHOD("draw_list_enable_scissor", "draw_list", "rect"), &RenderingDevice::draw_list_enable_scissor, DEFVAL(Rect2()));
|
||||
ClassDB::bind_method(D_METHOD("draw_list_disable_scissor", "draw_list"), &RenderingDevice::draw_list_disable_scissor);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("draw_list_switch_to_next_pass"), &RenderingDevice::draw_list_switch_to_next_pass);
|
||||
|
|
|
|||
Loading…
Reference in a new issue