diff options
Diffstat (limited to 'core/variant_call.cpp')
| -rw-r--r-- | core/variant_call.cpp | 450 |
1 files changed, 243 insertions, 207 deletions
diff --git a/core/variant_call.cpp b/core/variant_call.cpp index 391c293810..82b1f29805 100644 --- a/core/variant_call.cpp +++ b/core/variant_call.cpp @@ -42,14 +42,11 @@ typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_a typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args); struct _VariantCall { - static void Vector3_dot(Variant &r_ret, Variant &p_self, const Variant **p_args) { - r_ret = reinterpret_cast<Vector3 *>(p_self._data._mem)->dot(*reinterpret_cast<const Vector3 *>(p_args[0]->_data._mem)); } struct FuncData { - int arg_count; Vector<Variant> default_args; Vector<Variant::Type> arg_types; @@ -62,16 +59,16 @@ struct _VariantCall { VariantFunc func; _FORCE_INLINE_ bool verify_arguments(const Variant **p_args, Callable::CallError &r_error) { - - if (arg_count == 0) + if (arg_count == 0) { return true; + } const Variant::Type *tptr = &arg_types[0]; for (int i = 0; i < arg_count; i++) { - - if (tptr[i] == Variant::NIL || tptr[i] == p_args[i]->type) + if (tptr[i] == Variant::NIL || tptr[i] == p_args[i]->type) { continue; // all good + } if (!Variant::can_convert(p_args[i]->type, tptr[i])) { r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.argument = i; @@ -102,21 +99,25 @@ struct _VariantCall { #endif ERR_FAIL_COND(p_argcount > VARIANT_ARG_MAX); const Variant *newargs[VARIANT_ARG_MAX]; - for (int i = 0; i < p_argcount; i++) + for (int i = 0; i < p_argcount; i++) { newargs[i] = p_args[i]; + } // fill in any remaining parameters with defaults int first_default_arg = arg_count - def_argcount; - for (int i = p_argcount; i < arg_count; i++) + for (int i = p_argcount; i < arg_count; i++) { newargs[i] = &default_args[i - first_default_arg]; + } #ifdef DEBUG_ENABLED - if (!verify_arguments(newargs, r_error)) + if (!verify_arguments(newargs, r_error)) { return; + } #endif func(r_ret, p_self, newargs); } else { #ifdef DEBUG_ENABLED - if (!verify_arguments(p_args, r_error)) + if (!verify_arguments(p_args, r_error)) { return; + } #endif func(r_ret, p_self, p_args); } @@ -124,7 +125,6 @@ struct _VariantCall { }; struct TypeFunc { - Map<StringName, FuncData> functions; }; @@ -143,14 +143,12 @@ struct _VariantCall { //void addfunc(Variant::Type p_type, const StringName& p_name,VariantFunc p_func); static void make_func_return_variant(Variant::Type p_type, const StringName &p_name) { - #ifdef DEBUG_ENABLED type_funcs[p_type].functions[p_name].returns = true; #endif } static void addfunc(bool p_const, Variant::Type p_type, Variant::Type p_return, bool p_has_return, const StringName &p_name, VariantFunc p_func, const Vector<Variant> &p_defaultarg, const Arg &p_argtype1 = Arg(), const Arg &p_argtype2 = Arg(), const Arg &p_argtype3 = Arg(), const Arg &p_argtype4 = Arg(), const Arg &p_argtype5 = Arg()) { - FuncData funcdata; funcdata.func = p_func; funcdata.default_args = p_defaultarg; @@ -164,8 +162,9 @@ struct _VariantCall { funcdata.arg_names.push_back(p_argtype1.name); #endif - } else + } else { goto end; + } if (p_argtype2.name) { funcdata.arg_types.push_back(p_argtype2.type); @@ -173,8 +172,9 @@ struct _VariantCall { funcdata.arg_names.push_back(p_argtype2.name); #endif - } else + } else { goto end; + } if (p_argtype3.name) { funcdata.arg_types.push_back(p_argtype3.type); @@ -182,24 +182,27 @@ struct _VariantCall { funcdata.arg_names.push_back(p_argtype3.name); #endif - } else + } else { goto end; + } if (p_argtype4.name) { funcdata.arg_types.push_back(p_argtype4.type); #ifdef DEBUG_ENABLED funcdata.arg_names.push_back(p_argtype4.name); #endif - } else + } else { goto end; + } if (p_argtype5.name) { funcdata.arg_types.push_back(p_argtype5.type); #ifdef DEBUG_ENABLED funcdata.arg_names.push_back(p_argtype5.name); #endif - } else + } else { goto end; + } end: @@ -262,6 +265,7 @@ struct _VariantCall { VCALL_LOCALMEM3R(String, split); VCALL_LOCALMEM3R(String, rsplit); VCALL_LOCALMEM2R(String, split_floats); + VCALL_LOCALMEM1R(String, join); VCALL_LOCALMEM0R(String, to_upper); VCALL_LOCALMEM0R(String, to_lower); VCALL_LOCALMEM1R(String, left); @@ -314,7 +318,6 @@ struct _VariantCall { VCALL_LOCALMEM1R(String, trim_suffix); static void _call_String_to_ascii(Variant &r_ret, Variant &p_self, const Variant **p_args) { - String *s = reinterpret_cast<String *>(p_self._data._mem); if (s->empty()) { r_ret = PackedByteArray(); @@ -332,7 +335,6 @@ struct _VariantCall { } static void _call_String_to_utf8(Variant &r_ret, Variant &p_self, const Variant **p_args) { - String *s = reinterpret_cast<String *>(p_self._data._mem); if (s->empty()) { r_ret = PackedByteArray(); @@ -362,7 +364,7 @@ struct _VariantCall { VCALL_LOCALMEM1R(Vector2, angle_to); VCALL_LOCALMEM1R(Vector2, angle_to_point); VCALL_LOCALMEM1R(Vector2, direction_to); - VCALL_LOCALMEM2R(Vector2, linear_interpolate); + VCALL_LOCALMEM2R(Vector2, lerp); VCALL_LOCALMEM2R(Vector2, slerp); VCALL_LOCALMEM4R(Vector2, cubic_interpolate); VCALL_LOCALMEM2R(Vector2, move_toward); @@ -426,7 +428,7 @@ struct _VariantCall { VCALL_LOCALMEM0R(Vector3, inverse); VCALL_LOCALMEM1R(Vector3, snapped); VCALL_LOCALMEM2R(Vector3, rotated); - VCALL_LOCALMEM2R(Vector3, linear_interpolate); + VCALL_LOCALMEM2R(Vector3, lerp); VCALL_LOCALMEM2R(Vector3, slerp); VCALL_LOCALMEM4R(Vector3, cubic_interpolate); VCALL_LOCALMEM2R(Vector3, move_toward); @@ -464,26 +466,29 @@ struct _VariantCall { //return vector3 if intersected, nil if not static void _call_Plane_intersect_3(Variant &r_ret, Variant &p_self, const Variant **p_args) { Vector3 result; - if (reinterpret_cast<Plane *>(p_self._data._mem)->intersect_3(*p_args[0], *p_args[1], &result)) + if (reinterpret_cast<Plane *>(p_self._data._mem)->intersect_3(*p_args[0], *p_args[1], &result)) { r_ret = result; - else + } else { r_ret = Variant(); + } } static void _call_Plane_intersects_ray(Variant &r_ret, Variant &p_self, const Variant **p_args) { Vector3 result; - if (reinterpret_cast<Plane *>(p_self._data._mem)->intersects_ray(*p_args[0], *p_args[1], &result)) + if (reinterpret_cast<Plane *>(p_self._data._mem)->intersects_ray(*p_args[0], *p_args[1], &result)) { r_ret = result; - else + } else { r_ret = Variant(); + } } static void _call_Plane_intersects_segment(Variant &r_ret, Variant &p_self, const Variant **p_args) { Vector3 result; - if (reinterpret_cast<Plane *>(p_self._data._mem)->intersects_segment(*p_args[0], *p_args[1], &result)) + if (reinterpret_cast<Plane *>(p_self._data._mem)->intersects_segment(*p_args[0], *p_args[1], &result)) { r_ret = result; - else + } else { r_ret = Variant(); + } } VCALL_LOCALMEM0R(Quat, length); @@ -509,7 +514,7 @@ struct _VariantCall { VCALL_LOCALMEM0R(Color, to_rgba64); VCALL_LOCALMEM0R(Color, inverted); VCALL_LOCALMEM0R(Color, contrasted); - VCALL_LOCALMEM2R(Color, linear_interpolate); + VCALL_LOCALMEM2R(Color, lerp); VCALL_LOCALMEM1R(Color, blend); VCALL_LOCALMEM1R(Color, lightened); VCALL_LOCALMEM1R(Color, darkened); @@ -591,7 +596,6 @@ struct _VariantCall { VCALL_LOCALMEM0R(Array, min); static void _call_PackedByteArray_get_string_from_ascii(Variant &r_ret, Variant &p_self, const Variant **p_args) { - PackedByteArray *ba = reinterpret_cast<PackedByteArray *>(p_self._data._mem); String s; if (ba->size() > 0) { @@ -607,7 +611,6 @@ struct _VariantCall { } static void _call_PackedByteArray_get_string_from_utf8(Variant &r_ret, Variant &p_self, const Variant **p_args) { - PackedByteArray *ba = reinterpret_cast<PackedByteArray *>(p_self._data._mem); String s; if (ba->size() > 0) { @@ -618,7 +621,6 @@ struct _VariantCall { } static void _call_PackedByteArray_compress(Variant &r_ret, Variant &p_self, const Variant **p_args) { - PackedByteArray *ba = reinterpret_cast<PackedByteArray *>(p_self._data._mem); PackedByteArray compressed; if (ba->size() > 0) { @@ -634,7 +636,6 @@ struct _VariantCall { } static void _call_PackedByteArray_decompress(Variant &r_ret, Variant &p_self, const Variant **p_args) { - PackedByteArray *ba = reinterpret_cast<PackedByteArray *>(p_self._data._mem); PackedByteArray decompressed; Compression::Mode mode = (Compression::Mode)(int)(*p_args[1]); @@ -860,42 +861,58 @@ struct _VariantCall { VCALL_PTR1R(Transform2D, is_equal_approx); static void _call_Transform2D_xform(Variant &r_ret, Variant &p_self, const Variant **p_args) { - switch (p_args[0]->type) { - - case Variant::VECTOR2: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform(p_args[0]->operator Vector2()); return; - case Variant::RECT2: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform(p_args[0]->operator Rect2()); return; - case Variant::PACKED_VECTOR2_ARRAY: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform(p_args[0]->operator PackedVector2Array()); return; - default: r_ret = Variant(); + case Variant::VECTOR2: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform(p_args[0]->operator Vector2()); + return; + case Variant::RECT2: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform(p_args[0]->operator Rect2()); + return; + case Variant::PACKED_VECTOR2_ARRAY: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform(p_args[0]->operator PackedVector2Array()); + return; + default: + r_ret = Variant(); + ERR_PRINT("Invalid type in function 'xform' in base 'Transform2D'. Valid types are Vector2, Rect2, and PackedVector2Array."); } } static void _call_Transform2D_xform_inv(Variant &r_ret, Variant &p_self, const Variant **p_args) { - switch (p_args[0]->type) { - - case Variant::VECTOR2: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Vector2()); return; - case Variant::RECT2: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Rect2()); return; - case Variant::PACKED_VECTOR2_ARRAY: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform_inv(p_args[0]->operator PackedVector2Array()); return; - default: r_ret = Variant(); + case Variant::VECTOR2: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Vector2()); + return; + case Variant::RECT2: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Rect2()); + return; + case Variant::PACKED_VECTOR2_ARRAY: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->xform_inv(p_args[0]->operator PackedVector2Array()); + return; + default: + r_ret = Variant(); + ERR_PRINT("Invalid type in function 'xform_inv' in base 'Transform2D'. Valid types are Vector2, Rect2, and PackedVector2Array."); } } static void _call_Transform2D_basis_xform(Variant &r_ret, Variant &p_self, const Variant **p_args) { - switch (p_args[0]->type) { - - case Variant::VECTOR2: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->basis_xform(p_args[0]->operator Vector2()); return; - default: r_ret = Variant(); + case Variant::VECTOR2: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->basis_xform(p_args[0]->operator Vector2()); + return; + default: + r_ret = Variant(); + ERR_PRINT("Invalid type in function 'basis_xform' in base 'Transform2D'. Only Vector2 is valid."); } } static void _call_Transform2D_basis_xform_inv(Variant &r_ret, Variant &p_self, const Variant **p_args) { - switch (p_args[0]->type) { - - case Variant::VECTOR2: r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->basis_xform_inv(p_args[0]->operator Vector2()); return; - default: r_ret = Variant(); + case Variant::VECTOR2: + r_ret = reinterpret_cast<Transform2D *>(p_self._data._ptr)->basis_xform_inv(p_args[0]->operator Vector2()); + return; + default: + r_ret = Variant(); + ERR_PRINT("Invalid type in function 'basis_xform_inv' in base 'Transform2D'. Only Vector2 is valid."); } } @@ -928,39 +945,46 @@ struct _VariantCall { VCALL_PTR1R(Transform, is_equal_approx); static void _call_Transform_xform(Variant &r_ret, Variant &p_self, const Variant **p_args) { - switch (p_args[0]->type) { - - case Variant::VECTOR3: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator Vector3()); return; - case Variant::PLANE: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator Plane()); return; - case Variant::AABB: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator ::AABB()); return; - case Variant::PACKED_VECTOR3_ARRAY: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator ::PackedVector3Array()); return; - default: r_ret = Variant(); + case Variant::VECTOR3: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator Vector3()); + return; + case Variant::PLANE: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator Plane()); + return; + case Variant::AABB: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator ::AABB()); + return; + case Variant::PACKED_VECTOR3_ARRAY: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator ::PackedVector3Array()); + return; + default: + r_ret = Variant(); + ERR_PRINT("Invalid type in function 'xform' in base 'Transform'. Valid types are Vector3, Plane, AABB, and PackedVector3Array."); } } static void _call_Transform_xform_inv(Variant &r_ret, Variant &p_self, const Variant **p_args) { - switch (p_args[0]->type) { - - case Variant::VECTOR3: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Vector3()); return; - case Variant::PLANE: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Plane()); return; - case Variant::AABB: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator ::AABB()); return; - case Variant::PACKED_VECTOR3_ARRAY: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator ::PackedVector3Array()); return; - default: r_ret = Variant(); + case Variant::VECTOR3: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Vector3()); + return; + case Variant::PLANE: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Plane()); + return; + case Variant::AABB: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator ::AABB()); + return; + case Variant::PACKED_VECTOR3_ARRAY: + r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator ::PackedVector3Array()); + return; + default: + r_ret = Variant(); + ERR_PRINT("Invalid type in function 'xform_inv' in base 'Transform'. Valid types are Vector3, Plane, AABB, and PackedVector3Array."); } } - /* - VCALL_PTR0( Transform, invert ); - VCALL_PTR0( Transform, affine_invert ); - VCALL_PTR2( Transform, rotate ); - VCALL_PTR1( Transform, scale ); - VCALL_PTR1( Transform, translate ); - VCALL_PTR0( Transform, orthonormalize ); */ - struct ConstructData { - int arg_count; Vector<Variant::Type> arg_types; Vector<String> arg_names; @@ -968,50 +992,41 @@ struct _VariantCall { }; struct ConstructFunc { - List<ConstructData> constructors; }; static ConstructFunc *construct_funcs; static void Vector2_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Vector2(*p_args[0], *p_args[1]); } static void Vector2i_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Vector2i(*p_args[0], *p_args[1]); } static void Rect2_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Rect2(*p_args[0], *p_args[1]); } static void Rect2_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Rect2(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); } static void Rect2i_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Rect2i(*p_args[0], *p_args[1]); } static void Rect2i_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Rect2i(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); } static void Transform2D_init2(Variant &r_ret, const Variant **p_args) { - Transform2D m(*p_args[0], *p_args[1]); r_ret = m; } static void Transform2D_init3(Variant &r_ret, const Variant **p_args) { - Transform2D m; m[0] = *p_args[0]; m[1] = *p_args[1]; @@ -1020,76 +1035,65 @@ struct _VariantCall { } static void Vector3_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Vector3(*p_args[0], *p_args[1], *p_args[2]); } static void Vector3i_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Vector3i(*p_args[0], *p_args[1], *p_args[2]); } static void Plane_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Plane(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); } static void Plane_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Plane(*p_args[0], *p_args[1], *p_args[2]); } static void Plane_init3(Variant &r_ret, const Variant **p_args) { - r_ret = Plane(p_args[0]->operator Vector3(), p_args[1]->operator real_t()); } static void Plane_init4(Variant &r_ret, const Variant **p_args) { - r_ret = Plane(p_args[0]->operator Vector3(), p_args[1]->operator Vector3()); } static void Quat_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Quat(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); } static void Quat_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Quat(((Vector3)(*p_args[0])), ((real_t)(*p_args[1]))); } static void Quat_init3(Variant &r_ret, const Variant **p_args) { - r_ret = Quat(((Vector3)(*p_args[0]))); } static void Color_init1(Variant &r_ret, const Variant **p_args) { - r_ret = Color(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); } static void Color_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Color(*p_args[0], *p_args[1], *p_args[2]); } static void Color_init3(Variant &r_ret, const Variant **p_args) { - r_ret = Color::html(*p_args[0]); } static void Color_init4(Variant &r_ret, const Variant **p_args) { - r_ret = Color::hex(*p_args[0]); } - static void AABB_init1(Variant &r_ret, const Variant **p_args) { + static void Color_init5(Variant &r_ret, const Variant **p_args) { + r_ret = Color(((Color)(*p_args[0])), *p_args[1]); + } + static void AABB_init1(Variant &r_ret, const Variant **p_args) { r_ret = ::AABB(*p_args[0], *p_args[1]); } static void Basis_init1(Variant &r_ret, const Variant **p_args) { - Basis m; m.set_axis(0, *p_args[0]); m.set_axis(1, *p_args[1]); @@ -1098,12 +1102,10 @@ struct _VariantCall { } static void Basis_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Basis(p_args[0]->operator Vector3(), p_args[1]->operator real_t()); } static void Transform_init1(Variant &r_ret, const Variant **p_args) { - Transform t; t.basis.set_axis(0, *p_args[0]); t.basis.set_axis(1, *p_args[1]); @@ -1113,17 +1115,14 @@ struct _VariantCall { } static void Transform_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Transform(p_args[0]->operator Basis(), p_args[1]->operator Vector3()); } static void Callable_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Callable(p_args[0]->operator ObjectID(), p_args[1]->operator String()); } static void Signal_init2(Variant &r_ret, const Variant **p_args) { - r_ret = Signal(p_args[0]->operator ObjectID(), p_args[1]->operator String()); } @@ -1132,31 +1131,34 @@ struct _VariantCall { const String &p_name2 = "", const Variant::Type p_type2 = Variant::NIL, const String &p_name3 = "", const Variant::Type p_type3 = Variant::NIL, const String &p_name4 = "", const Variant::Type p_type4 = Variant::NIL) { - ConstructData cd; cd.func = p_func; cd.arg_count = 0; - if (p_name1 == "") + if (p_name1 == "") { goto end; + } cd.arg_count++; cd.arg_names.push_back(p_name1); cd.arg_types.push_back(p_type1); - if (p_name2 == "") + if (p_name2 == "") { goto end; + } cd.arg_count++; cd.arg_names.push_back(p_name2); cd.arg_types.push_back(p_type2); - if (p_name3 == "") + if (p_name3 == "") { goto end; + } cd.arg_count++; cd.arg_names.push_back(p_name3); cd.arg_types.push_back(p_type3); - if (p_name4 == "") + if (p_name4 == "") { goto end; + } cd.arg_count++; cd.arg_names.push_back(p_name4); cd.arg_types.push_back(p_type4); @@ -1167,7 +1169,6 @@ struct _VariantCall { } struct ConstantData { - Map<StringName, int> value; #ifdef DEBUG_ENABLED List<StringName> value_ordered; @@ -1178,7 +1179,6 @@ struct _VariantCall { static ConstantData *constant_data; static void add_constant(int p_type, StringName p_constant_name, int p_constant_value) { - constant_data[p_type].value[p_constant_name] = p_constant_value; #ifdef DEBUG_ENABLED constant_data[p_type].value_ordered.push_back(p_constant_name); @@ -1186,7 +1186,6 @@ struct _VariantCall { } static void add_variant_constant(int p_type, StringName p_constant_name, const Variant &p_constant_value) { - constant_data[p_type].variant_value[p_constant_name] = p_constant_value; } }; @@ -1196,7 +1195,6 @@ _VariantCall::ConstructFunc *_VariantCall::construct_funcs = nullptr; _VariantCall::ConstantData *_VariantCall::constant_data = nullptr; Variant Variant::call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) { - Variant ret; call_ptr(p_method, p_args, p_argcount, &ret, r_error); return ret; @@ -1224,13 +1222,11 @@ void Variant::call_ptr(const StringName &p_method, const Variant **p_args, int p //else if (type==Variant::METHOD) { } else { - r_error.error = Callable::CallError::CALL_OK; Map<StringName, _VariantCall::FuncData>::Element *E = _VariantCall::type_funcs[type].functions.find(p_method); if (E) { - _VariantCall::FuncData &funcdata = E->get(); funcdata.call(ret, *this, p_args, p_argcount, r_error); @@ -1239,7 +1235,6 @@ void Variant::call_ptr(const StringName &p_method, const Variant **p_args, int p bool valid = false; if (type == CALLABLE) { if (p_method == CoreStringNames::get_singleton()->call) { - reinterpret_cast<const Callable *>(_data._mem)->call(p_args, p_argcount, ret, r_error); valid = true; } @@ -1264,14 +1259,14 @@ void Variant::call_ptr(const StringName &p_method, const Variant **p_args, int p } } - if (r_error.error == Callable::CallError::CALL_OK && r_ret) + if (r_error.error == Callable::CallError::CALL_OK && r_ret) { *r_ret = ret; + } } #define VCALL(m_type, m_method) _VariantCall::_call_##m_type##_##m_method Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, int p_argcount, Callable::CallError &r_error, bool p_strict) { - r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD; ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, Variant()); @@ -1283,50 +1278,74 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i return Variant(); // atomic types - case BOOL: return Variant(false); - case INT: return 0; - case FLOAT: return 0.0f; + case BOOL: + return Variant(false); + case INT: + return 0; + case FLOAT: + return 0.0f; case STRING: return String(); // math types case VECTOR2: return Vector2(); - case RECT2: return Rect2(); - case VECTOR3: return Vector3(); - case TRANSFORM2D: return Transform2D(); - case PLANE: return Plane(); - case QUAT: return Quat(); + case RECT2: + return Rect2(); + case VECTOR3: + return Vector3(); + case TRANSFORM2D: + return Transform2D(); + case PLANE: + return Plane(); + case QUAT: + return Quat(); case AABB: return ::AABB(); - case BASIS: return Basis(); + case BASIS: + return Basis(); case TRANSFORM: return Transform(); // misc types - case COLOR: return Color(); + case COLOR: + return Color(); case STRING_NAME: return StringName(); case NODE_PATH: return NodePath(); - case _RID: return RID(); - case OBJECT: return (Object *)nullptr; - case CALLABLE: return Callable(); - case SIGNAL: return Signal(); - case DICTIONARY: return Dictionary(); + case _RID: + return RID(); + case OBJECT: + return (Object *)nullptr; + case CALLABLE: + return Callable(); + case SIGNAL: + return Signal(); + case DICTIONARY: + return Dictionary(); case ARRAY: return Array(); - case PACKED_BYTE_ARRAY: return PackedByteArray(); - case PACKED_INT32_ARRAY: return PackedInt32Array(); - case PACKED_INT64_ARRAY: return PackedInt64Array(); - case PACKED_FLOAT32_ARRAY: return PackedFloat32Array(); - case PACKED_FLOAT64_ARRAY: return PackedFloat64Array(); - case PACKED_STRING_ARRAY: return PackedStringArray(); + case PACKED_BYTE_ARRAY: + return PackedByteArray(); + case PACKED_INT32_ARRAY: + return PackedInt32Array(); + case PACKED_INT64_ARRAY: + return PackedInt64Array(); + case PACKED_FLOAT32_ARRAY: + return PackedFloat32Array(); + case PACKED_FLOAT64_ARRAY: + return PackedFloat64Array(); + case PACKED_STRING_ARRAY: + return PackedStringArray(); case PACKED_VECTOR2_ARRAY: return PackedVector2Array(); - case PACKED_VECTOR3_ARRAY: return PackedVector3Array(); - case PACKED_COLOR_ARRAY: return PackedColorArray(); - default: return Variant(); + case PACKED_VECTOR3_ARRAY: + return PackedVector3Array(); + case PACKED_COLOR_ARRAY: + return PackedColorArray(); + default: + return Variant(); } } else if (p_argcount == 1 && p_args[0]->type == p_type) { @@ -1336,7 +1355,6 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i switch (p_type) { case NIL: { - return Variant(); } break; case BOOL: { @@ -1357,54 +1375,78 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i case VECTOR2I: { return Vector2i(*p_args[0]); } - case RECT2: return (Rect2(*p_args[0])); - case RECT2I: return (Rect2i(*p_args[0])); - case VECTOR3: return (Vector3(*p_args[0])); - case VECTOR3I: return (Vector3i(*p_args[0])); - case PLANE: return (Plane(*p_args[0])); - case QUAT: return (p_args[0]->operator Quat()); + case RECT2: + return (Rect2(*p_args[0])); + case RECT2I: + return (Rect2i(*p_args[0])); + case VECTOR3: + return (Vector3(*p_args[0])); + case VECTOR3I: + return (Vector3i(*p_args[0])); + case TRANSFORM2D: + return (Transform2D(p_args[0]->operator Transform2D())); + case PLANE: + return (Plane(*p_args[0])); + case QUAT: + return (p_args[0]->operator Quat()); case AABB: return (::AABB(*p_args[0])); - case BASIS: return (Basis(p_args[0]->operator Basis())); + case BASIS: + return (Basis(p_args[0]->operator Basis())); case TRANSFORM: return (Transform(p_args[0]->operator Transform())); // misc types - case COLOR: return p_args[0]->type == Variant::STRING ? Color::html(*p_args[0]) : Color::hex(*p_args[0]); + case COLOR: + return p_args[0]->type == Variant::STRING ? Color::html(*p_args[0]) : Color::hex(*p_args[0]); case STRING_NAME: return (StringName(p_args[0]->operator StringName())); case NODE_PATH: return (NodePath(p_args[0]->operator NodePath())); - case _RID: return (RID(*p_args[0])); - case OBJECT: return ((Object *)(p_args[0]->operator Object *())); - case CALLABLE: return ((Callable)(p_args[0]->operator Callable())); - case SIGNAL: return ((Signal)(p_args[0]->operator Signal())); - case DICTIONARY: return p_args[0]->operator Dictionary(); + case _RID: + return (RID(*p_args[0])); + case OBJECT: + return ((Object *)(p_args[0]->operator Object *())); + case CALLABLE: + return ((Callable)(p_args[0]->operator Callable())); + case SIGNAL: + return ((Signal)(p_args[0]->operator Signal())); + case DICTIONARY: + return p_args[0]->operator Dictionary(); case ARRAY: return p_args[0]->operator Array(); // arrays - case PACKED_BYTE_ARRAY: return (PackedByteArray(*p_args[0])); - case PACKED_INT32_ARRAY: return (PackedInt32Array(*p_args[0])); - case PACKED_INT64_ARRAY: return (PackedInt64Array(*p_args[0])); - case PACKED_FLOAT32_ARRAY: return (PackedFloat32Array(*p_args[0])); - case PACKED_FLOAT64_ARRAY: return (PackedFloat64Array(*p_args[0])); - case PACKED_STRING_ARRAY: return (PackedStringArray(*p_args[0])); + case PACKED_BYTE_ARRAY: + return (PackedByteArray(*p_args[0])); + case PACKED_INT32_ARRAY: + return (PackedInt32Array(*p_args[0])); + case PACKED_INT64_ARRAY: + return (PackedInt64Array(*p_args[0])); + case PACKED_FLOAT32_ARRAY: + return (PackedFloat32Array(*p_args[0])); + case PACKED_FLOAT64_ARRAY: + return (PackedFloat64Array(*p_args[0])); + case PACKED_STRING_ARRAY: + return (PackedStringArray(*p_args[0])); case PACKED_VECTOR2_ARRAY: return (PackedVector2Array(*p_args[0])); - case PACKED_VECTOR3_ARRAY: return (PackedVector3Array(*p_args[0])); - case PACKED_COLOR_ARRAY: return (PackedColorArray(*p_args[0])); - default: return Variant(); + case PACKED_VECTOR3_ARRAY: + return (PackedVector3Array(*p_args[0])); + case PACKED_COLOR_ARRAY: + return (PackedColorArray(*p_args[0])); + default: + return Variant(); } } else if (p_argcount >= 1) { - _VariantCall::ConstructFunc &c = _VariantCall::construct_funcs[p_type]; for (List<_VariantCall::ConstructData>::Element *E = c.constructors.front(); E; E = E->next()) { const _VariantCall::ConstructData &cd = E->get(); - if (cd.arg_count != p_argcount) + if (cd.arg_count != p_argcount) { continue; + } //validate parameters for (int i = 0; i < cd.arg_count; i++) { @@ -1426,11 +1468,11 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i } bool Variant::has_method(const StringName &p_method) const { - if (type == OBJECT) { Object *obj = get_validated_object(); - if (!obj) + if (!obj) { return false; + } return obj->has_method(p_method); } @@ -1440,69 +1482,68 @@ bool Variant::has_method(const StringName &p_method) const { } Vector<Variant::Type> Variant::get_method_argument_types(Variant::Type p_type, const StringName &p_method) { - const _VariantCall::TypeFunc &tf = _VariantCall::type_funcs[p_type]; const Map<StringName, _VariantCall::FuncData>::Element *E = tf.functions.find(p_method); - if (!E) + if (!E) { return Vector<Variant::Type>(); + } return E->get().arg_types; } bool Variant::is_method_const(Variant::Type p_type, const StringName &p_method) { - const _VariantCall::TypeFunc &tf = _VariantCall::type_funcs[p_type]; const Map<StringName, _VariantCall::FuncData>::Element *E = tf.functions.find(p_method); - if (!E) + if (!E) { return false; + } return E->get()._const; } Vector<StringName> Variant::get_method_argument_names(Variant::Type p_type, const StringName &p_method) { - const _VariantCall::TypeFunc &tf = _VariantCall::type_funcs[p_type]; const Map<StringName, _VariantCall::FuncData>::Element *E = tf.functions.find(p_method); - if (!E) + if (!E) { return Vector<StringName>(); + } return E->get().arg_names; } Variant::Type Variant::get_method_return_type(Variant::Type p_type, const StringName &p_method, bool *r_has_return) { - const _VariantCall::TypeFunc &tf = _VariantCall::type_funcs[p_type]; const Map<StringName, _VariantCall::FuncData>::Element *E = tf.functions.find(p_method); - if (!E) + if (!E) { return Variant::NIL; + } - if (r_has_return) + if (r_has_return) { *r_has_return = E->get().returns; + } return E->get().return_type; } Vector<Variant> Variant::get_method_default_arguments(Variant::Type p_type, const StringName &p_method) { - const _VariantCall::TypeFunc &tf = _VariantCall::type_funcs[p_type]; const Map<StringName, _VariantCall::FuncData>::Element *E = tf.functions.find(p_method); - if (!E) + if (!E) { return Vector<Variant>(); + } return E->get().default_args; } void Variant::get_method_list(List<MethodInfo> *p_list) const { - const _VariantCall::TypeFunc &tf = _VariantCall::type_funcs[type]; for (const Map<StringName, _VariantCall::FuncData>::Element *E = tf.functions.front(); E; E = E->next()) { - const _VariantCall::FuncData &fd = E->get(); MethodInfo mi; @@ -1513,7 +1554,6 @@ void Variant::get_method_list(List<MethodInfo> *p_list) const { } for (int i = 0; i < fd.arg_types.size(); i++) { - PropertyInfo pi; pi.type = fd.arg_types[i]; #ifdef DEBUG_ENABLED @@ -1528,8 +1568,9 @@ void Variant::get_method_list(List<MethodInfo> *p_list) const { ret.type = fd.return_type; if (fd.returns) { ret.name = "ret"; - if (fd.return_type == Variant::NIL) + if (fd.return_type == Variant::NIL) { ret.usage = PROPERTY_USAGE_NIL_IS_VARIANT; + } } mi.return_val = ret; #endif @@ -1538,7 +1579,6 @@ void Variant::get_method_list(List<MethodInfo> *p_list) const { } if (type == CALLABLE) { - MethodInfo mi; mi.name = "call"; mi.return_val.usage = PROPERTY_USAGE_NIL_IS_VARIANT; @@ -1553,7 +1593,6 @@ void Variant::get_method_list(List<MethodInfo> *p_list) const { } if (type == SIGNAL) { - MethodInfo mi; mi.name = "emit"; mi.flags |= METHOD_FLAG_VARARG; @@ -1563,18 +1602,15 @@ void Variant::get_method_list(List<MethodInfo> *p_list) const { } void Variant::get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_list) { - ERR_FAIL_INDEX(p_type, VARIANT_MAX); //custom constructors for (const List<_VariantCall::ConstructData>::Element *E = _VariantCall::construct_funcs[p_type].constructors.front(); E; E = E->next()) { - const _VariantCall::ConstructData &cd = E->get(); MethodInfo mi; mi.name = Variant::get_type_name(p_type); mi.return_val.type = p_type; for (int i = 0; i < cd.arg_count; i++) { - PropertyInfo pi; pi.name = cd.arg_names[i]; pi.type = cd.arg_types[i]; @@ -1584,10 +1620,12 @@ void Variant::get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_lis } //default constructors for (int i = 0; i < VARIANT_MAX; i++) { - if (i == p_type) + if (i == p_type) { continue; - if (!Variant::can_convert(Variant::Type(i), p_type)) + } + if (!Variant::can_convert(Variant::Type(i), p_type)) { continue; + } MethodInfo mi; mi.name = Variant::get_type_name(p_type); @@ -1601,39 +1639,34 @@ void Variant::get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_lis } void Variant::get_constants_for_type(Variant::Type p_type, List<StringName> *p_constants) { - ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX); _VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type]; #ifdef DEBUG_ENABLED for (List<StringName>::Element *E = cd.value_ordered.front(); E; E = E->next()) { - p_constants->push_back(E->get()); #else for (Map<StringName, int>::Element *E = cd.value.front(); E; E = E->next()) { - p_constants->push_back(E->key()); #endif } for (Map<StringName, Variant>::Element *E = cd.variant_value.front(); E; E = E->next()) { - p_constants->push_back(E->key()); } } bool Variant::has_constant(Variant::Type p_type, const StringName &p_value) { - ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false); _VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type]; return cd.value.has(p_value) || cd.variant_value.has(p_value); } Variant Variant::get_constant_value(Variant::Type p_type, const StringName &p_value, bool *r_valid) { - - if (r_valid) + if (r_valid) { *r_valid = false; + } ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0); _VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type]; @@ -1642,21 +1675,22 @@ Variant Variant::get_constant_value(Variant::Type p_type, const StringName &p_va if (!E) { Map<StringName, Variant>::Element *F = cd.variant_value.find(p_value); if (F) { - if (r_valid) + if (r_valid) { *r_valid = true; + } return F->get(); } else { return -1; } } - if (r_valid) + if (r_valid) { *r_valid = true; + } return E->get(); } void register_variant_methods() { - _VariantCall::type_funcs = memnew_arr(_VariantCall::TypeFunc, Variant::VARIANT_MAX); _VariantCall::construct_funcs = memnew_arr(_VariantCall::ConstructFunc, Variant::VARIANT_MAX); @@ -1739,6 +1773,7 @@ void register_variant_methods() { ADDFUNC3R(STRING, PACKED_STRING_ARRAY, String, split, STRING, "delimiter", BOOL, "allow_empty", INT, "maxsplit", varray(true, 0)); ADDFUNC3R(STRING, PACKED_STRING_ARRAY, String, rsplit, STRING, "delimiter", BOOL, "allow_empty", INT, "maxsplit", varray(true, 0)); ADDFUNC2R(STRING, PACKED_FLOAT32_ARRAY, String, split_floats, STRING, "delimiter", BOOL, "allow_empty", varray(true)); + ADDFUNC1R(STRING, STRING, String, join, PACKED_STRING_ARRAY, "parts", varray()); ADDFUNC0R(STRING, STRING, String, to_upper, varray()); ADDFUNC0R(STRING, STRING, String, to_lower, varray()); @@ -1809,7 +1844,7 @@ void register_variant_methods() { ADDFUNC1R(VECTOR2, VECTOR2, Vector2, posmod, FLOAT, "mod", varray()); ADDFUNC1R(VECTOR2, VECTOR2, Vector2, posmodv, VECTOR2, "modv", varray()); ADDFUNC1R(VECTOR2, VECTOR2, Vector2, project, VECTOR2, "b", varray()); - ADDFUNC2R(VECTOR2, VECTOR2, Vector2, linear_interpolate, VECTOR2, "b", FLOAT, "t", varray()); + ADDFUNC2R(VECTOR2, VECTOR2, Vector2, lerp, VECTOR2, "b", FLOAT, "t", varray()); ADDFUNC2R(VECTOR2, VECTOR2, Vector2, slerp, VECTOR2, "b", FLOAT, "t", varray()); ADDFUNC4R(VECTOR2, VECTOR2, Vector2, cubic_interpolate, VECTOR2, "b", VECTOR2, "pre_a", VECTOR2, "post_b", FLOAT, "t", varray()); ADDFUNC2R(VECTOR2, VECTOR2, Vector2, move_toward, VECTOR2, "to", FLOAT, "delta", varray()); @@ -1874,7 +1909,7 @@ void register_variant_methods() { ADDFUNC0R(VECTOR3, VECTOR3, Vector3, inverse, varray()); ADDFUNC1R(VECTOR3, VECTOR3, Vector3, snapped, VECTOR3, "by", varray()); ADDFUNC2R(VECTOR3, VECTOR3, Vector3, rotated, VECTOR3, "axis", FLOAT, "phi", varray()); - ADDFUNC2R(VECTOR3, VECTOR3, Vector3, linear_interpolate, VECTOR3, "b", FLOAT, "t", varray()); + ADDFUNC2R(VECTOR3, VECTOR3, Vector3, lerp, VECTOR3, "b", FLOAT, "t", varray()); ADDFUNC2R(VECTOR3, VECTOR3, Vector3, slerp, VECTOR3, "b", FLOAT, "t", varray()); ADDFUNC4R(VECTOR3, VECTOR3, Vector3, cubic_interpolate, VECTOR3, "b", VECTOR3, "pre_a", VECTOR3, "post_b", FLOAT, "t", varray()); ADDFUNC2R(VECTOR3, VECTOR3, Vector3, move_toward, VECTOR3, "to", FLOAT, "delta", varray()); @@ -1933,7 +1968,7 @@ void register_variant_methods() { ADDFUNC0R(COLOR, INT, Color, to_rgba64, varray()); ADDFUNC0R(COLOR, COLOR, Color, inverted, varray()); ADDFUNC0R(COLOR, COLOR, Color, contrasted, varray()); - ADDFUNC2R(COLOR, COLOR, Color, linear_interpolate, COLOR, "b", FLOAT, "t", varray()); + ADDFUNC2R(COLOR, COLOR, Color, lerp, COLOR, "b", FLOAT, "t", varray()); ADDFUNC1R(COLOR, COLOR, Color, blend, COLOR, "over", varray()); ADDFUNC1R(COLOR, COLOR, Color, lightened, FLOAT, "amount", varray()); ADDFUNC1R(COLOR, COLOR, Color, darkened, FLOAT, "amount", varray()); @@ -2217,6 +2252,8 @@ void register_variant_methods() { _VariantCall::add_constructor(_VariantCall::Color_init1, Variant::COLOR, "r", Variant::FLOAT, "g", Variant::FLOAT, "b", Variant::FLOAT, "a", Variant::FLOAT); _VariantCall::add_constructor(_VariantCall::Color_init2, Variant::COLOR, "r", Variant::FLOAT, "g", Variant::FLOAT, "b", Variant::FLOAT); + // init3 and init4 are the constructors for HTML hex strings and integers respectively which don't need binding here, so we skip to init5. + _VariantCall::add_constructor(_VariantCall::Color_init5, Variant::COLOR, "c", Variant::COLOR, "a", Variant::FLOAT); _VariantCall::add_constructor(_VariantCall::AABB_init1, Variant::AABB, "position", Variant::VECTOR3, "size", Variant::VECTOR3); @@ -2314,7 +2351,6 @@ void register_variant_methods() { } void unregister_variant_methods() { - memdelete_arr(_VariantCall::type_funcs); memdelete_arr(_VariantCall::construct_funcs); memdelete_arr(_VariantCall::constant_data); |