Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-10-19 16:03:29 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #105254 from Ivorforce/no-get-internal-ptr

Browse source 
Delete `VariantGetInternalPtr` and `VariantImplicitConvert`, replace with `VariantInternalAccessor`
This commit is contained in:
Thaddeus Crews 2025-09-18 21:02:28 -05:00
commit f8dedf68e2
No known key found for this signature in database
GPG key ID: 8C6E5FEB5FC03CCC
11 changed files with 1015 additions and 1534 deletions
Download patch file Download diff file Expand all files Collapse all files

10
core/variant/binder_common.h
View file

@ -531,27 +531,27 @@ void call_with_ptr_args_static_method(void (*p_method)(P...), const void **p_arg
template <typename T, typename... P>
void call_with_validated_variant_args(Variant *base, void (T::*p_method)(P...), const Variant **p_args) {
call_with_validated_variant_args_helper<T, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
call_with_validated_variant_args_helper<T, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
}
template <typename T, typename R, typename... P>
void call_with_validated_variant_args_ret(Variant *base, R (T::*p_method)(P...), const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_ret_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
call_with_validated_variant_args_ret_helper<T, R, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename T, typename R, typename... P>
void call_with_validated_variant_args_retc(Variant *base, R (T::*p_method)(P...) const, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_retc_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
call_with_validated_variant_args_retc_helper<T, R, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename T, typename... P>
void call_with_validated_variant_args_static(Variant *base, void (*p_method)(T *, P...), const Variant **p_args) {
call_with_validated_variant_args_static_helper<T, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
call_with_validated_variant_args_static_helper<T, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
}
template <typename T, typename R, typename... P>
void call_with_validated_variant_args_static_retc(Variant *base, R (*p_method)(T *, P...), const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_static_retc_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
call_with_validated_variant_args_static_retc_helper<T, R, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename... P>

6
core/variant/variant.h
View file

@ -173,6 +173,12 @@ private:
friend struct _VariantCall;
friend class VariantInternal;
template <typename>
friend struct _VariantInternalAccessorLocal;
template <typename>
friend struct _VariantInternalAccessorElsewhere;
template <typename>
friend struct _VariantInternalAccessorPackedArrayRef;
// Variant takes 24 bytes when real_t is float, and 40 bytes if double.
// It only allocates extra memory for AABB/Transform2D (24, 48 if double),
// Basis/Transform3D (48, 96 if double), Projection (64, 128 if double),

40
core/variant/variant_call.cpp
View file

@ -54,58 +54,58 @@ static _FORCE_INLINE_ void vc_static_method_call(void (*method)(P...), const Var
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_ret_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
call_with_variant_args_ret_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_retc_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
call_with_variant_args_retc_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
VariantInternal::clear(&r_ret);
call_with_variant_args_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals);
call_with_variant_args_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_error, p_defvals);
}
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
VariantInternal::clear(&r_ret);
call_with_variant_argsc_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals);
call_with_variant_argsc_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_error, p_defvals);
}
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_variant_args_ret_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_variant_args_retc_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_variant_args_dv(&converted, method, p_args, p_argcount, r_error, p_defvals);
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_variant_argsc_dv(&converted, method, p_args, p_argcount, r_error, p_defvals);
}
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call_static(R (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_retc_static_helper_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, p_defvals, r_error);
call_with_variant_args_retc_static_helper_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_ret, p_defvals, r_error);
}
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call_static(void (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_static_helper_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, p_defvals, r_error);
call_with_variant_args_static_helper_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, p_defvals, r_error);
}
template <typename R, typename T, typename... P>
@ -129,24 +129,24 @@ static _FORCE_INLINE_ void vc_validated_call(void (T::*method)(P...) const, Vari
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_validated_variant_args_ret_helper<T, R, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_validated_variant_args_retc_helper<T, R, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_validated_variant_args_helper<T, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
call_with_validated_variant_argsc_helper<T, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
@ -1168,17 +1168,17 @@ struct _VariantCall {
}
static void func_Callable_call(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
Callable *callable = &VariantInternalAccessor<Callable>::get(v);
callable->callp(p_args, p_argcount, r_ret, r_error);
}
static void func_Callable_call_deferred(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
Callable *callable = &VariantInternalAccessor<Callable>::get(v);
callable->call_deferredp(p_args, p_argcount);
}
static void func_Callable_rpc(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
Callable *callable = &VariantInternalAccessor<Callable>::get(v);
callable->rpcp(0, p_args, p_argcount, r_error);
}
@ -1191,13 +1191,13 @@ struct _VariantCall {
r_error.argument = 0;
r_error.expected = Variant::INT;
} else {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
Callable *callable = &VariantInternalAccessor<Callable>::get(v);
callable->rpcp(*p_args[0], &p_args[1], p_argcount - 1, r_error);
}
}
static void func_Callable_bind(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
Callable *callable = &VariantInternalAccessor<Callable>::get(v);
r_ret = callable->bindp(p_args, p_argcount);
}
@ -1206,7 +1206,7 @@ struct _VariantCall {
}
static void func_Signal_emit(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Signal *signal = VariantGetInternalPtr<Signal>::get_ptr(v);
Signal *signal = &VariantInternalAccessor<Signal>::get(v);
signal->emit(p_args, p_argcount);
}

4
core/variant/variant_construct.cpp
View file

@ -125,8 +125,8 @@ void Variant::_register_variant_constructors() {
add_constructor<VariantConstructNoArgs<Transform2D>>(sarray());
add_constructor<VariantConstructor<Transform2D, Transform2D>>(sarray("from"));
add_constructor<VariantConstructor<Transform2D, float, Vector2>>(sarray("rotation", "position"));
add_constructor<VariantConstructor<Transform2D, float, Size2, float, Vector2>>(sarray("rotation", "scale", "skew", "position"));
add_constructor<VariantConstructor<Transform2D, double, Vector2>>(sarray("rotation", "position"));
add_constructor<VariantConstructor<Transform2D, double, Size2, double, Vector2>>(sarray("rotation", "scale", "skew", "position"));
add_constructor<VariantConstructor<Transform2D, Vector2, Vector2, Vector2>>(sarray("x_axis", "y_axis", "origin"));
add_constructor<VariantConstructNoArgs<Plane>>(sarray());

58
core/variant/variant_construct.h
View file

@ -113,7 +113,7 @@ class VariantConstructor {
template <size_t... Is>
static _FORCE_INLINE_ void validated_construct_helper(T &base, const Variant **p_args, IndexSequence<Is...>) {
base = T((*VariantGetInternalPtr<P>::get_ptr(p_args[Is]))...);
base = T((VariantInternalAccessor<P>::get(p_args[Is]))...);
}
template <size_t... Is>
@ -125,12 +125,12 @@ public:
static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
r_error.error = Callable::CallError::CALL_OK;
VariantTypeChanger<T>::change(&r_ret);
construct_helper(*VariantGetInternalPtr<T>::get_ptr(&r_ret), p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
construct_helper(VariantInternalAccessor<T>::get(&r_ret), p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
}
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
VariantTypeChanger<T>::change(r_ret);
validated_construct_helper(*VariantGetInternalPtr<T>::get_ptr(r_ret), p_args, BuildIndexSequence<sizeof...(P)>{});
validated_construct_helper(VariantInternalAccessor<T>::get(r_ret), p_args, BuildIndexSequence<sizeof...(P)>{});
}
static void ptr_construct(void *base, const void **p_args) {
ptr_construct_helper(base, p_args, BuildIndexSequence<sizeof...(P)>{});
@ -249,7 +249,7 @@ public:
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
VariantTypeChanger<T>::change(r_ret);
const String &src_str = *VariantGetInternalPtr<String>::get_ptr(p_args[0]);
const String &src_str = VariantInternalAccessor<String>::get(p_args[0]);
T ret = Variant();
if (r_ret->get_type() == Variant::Type::INT) {
ret = src_str.to_int();
@ -302,9 +302,9 @@ public:
}
if (p_args[1]->get_type() == Variant::STRING_NAME) {
method = *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]);
method = VariantInternalAccessor<StringName>::get(p_args[1]);
} else if (p_args[1]->get_type() == Variant::STRING) {
method = *VariantGetInternalPtr<String>::get_ptr(p_args[1]);
method = VariantInternalAccessor<String>::get(p_args[1]);
} else {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 1;
@ -313,12 +313,12 @@ public:
}
VariantTypeChanger<Callable>::change(&r_ret);
*VariantGetInternalPtr<Callable>::get_ptr(&r_ret) = Callable(object_id, method);
VariantInternalAccessor<Callable>::get(&r_ret) = Callable(object_id, method);
}
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
VariantTypeChanger<Callable>::change(r_ret);
*VariantGetInternalPtr<Callable>::get_ptr(r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
VariantInternalAccessor<Callable>::get(r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), VariantInternalAccessor<StringName>::get(p_args[1]));
}
static void ptr_construct(void *base, const void **p_args) {
PtrConstruct<Callable>::construct(Callable(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
@ -359,9 +359,9 @@ public:
}
if (p_args[1]->get_type() == Variant::STRING_NAME) {
method = *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]);
method = VariantInternalAccessor<StringName>::get(p_args[1]);
} else if (p_args[1]->get_type() == Variant::STRING) {
method = *VariantGetInternalPtr<String>::get_ptr(p_args[1]);
method = VariantInternalAccessor<String>::get(p_args[1]);
} else {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 1;
@ -370,12 +370,12 @@ public:
}
VariantTypeChanger<Signal>::change(&r_ret);
*VariantGetInternalPtr<Signal>::get_ptr(&r_ret) = Signal(object_id, method);
VariantInternalAccessor<Signal>::get(&r_ret) = Signal(object_id, method);
}
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
VariantTypeChanger<Signal>::change(r_ret);
*VariantGetInternalPtr<Signal>::get_ptr(r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
VariantInternalAccessor<Signal>::get(r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), VariantInternalAccessor<StringName>::get(p_args[1]));
}
static void ptr_construct(void *base, const void **p_args) {
PtrConstruct<Signal>::construct(Signal(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
@ -436,20 +436,20 @@ public:
return;
}
const Dictionary &base_dict = *VariantGetInternalPtr<Dictionary>::get_ptr(p_args[0]);
const Dictionary &base_dict = VariantInternalAccessor<Dictionary>::get(p_args[0]);
const uint32_t key_type = p_args[1]->operator uint32_t();
const StringName &key_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
const StringName &key_class_name = VariantInternalAccessor<StringName>::get(p_args[2]);
const uint32_t value_type = p_args[4]->operator uint32_t();
const StringName &value_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[5]);
const StringName &value_class_name = VariantInternalAccessor<StringName>::get(p_args[5]);
r_ret = Dictionary(base_dict, key_type, key_class_name, *p_args[3], value_type, value_class_name, *p_args[6]);
}
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
const Dictionary &base_dict = *VariantGetInternalPtr<Dictionary>::get_ptr(p_args[0]);
const Dictionary &base_dict = VariantInternalAccessor<Dictionary>::get(p_args[0]);
const uint32_t key_type = p_args[1]->operator uint32_t();
const StringName &key_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
const StringName &key_class_name = VariantInternalAccessor<StringName>::get(p_args[2]);
const uint32_t value_type = p_args[4]->operator uint32_t();
const StringName &value_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[5]);
const StringName &value_class_name = VariantInternalAccessor<StringName>::get(p_args[5]);
*r_ret = Dictionary(base_dict, key_type, key_class_name, *p_args[3], value_type, value_class_name, *p_args[6]);
}
@ -528,15 +528,15 @@ public:
return;
}
const Array &base_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
const Array &base_arr = VariantInternalAccessor<Array>::get(p_args[0]);
const uint32_t type = p_args[1]->operator uint32_t();
r_ret = Array(base_arr, type, *p_args[2], *p_args[3]);
}
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
const Array &base_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
const Array &base_arr = VariantInternalAccessor<Array>::get(p_args[0]);
const uint32_t type = p_args[1]->operator uint32_t();
const StringName &class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
const StringName &class_name = VariantInternalAccessor<StringName>::get(p_args[2]);
*r_ret = Array(base_arr, type, class_name, *p_args[3]);
}
@ -591,8 +591,8 @@ public:
}
r_ret = Array();
Array &dst_arr = *VariantGetInternalPtr<Array>::get_ptr(&r_ret);
const T &src_arr = *VariantGetInternalPtr<T>::get_ptr(p_args[0]);
Array &dst_arr = VariantInternalAccessor<Array>::get(&r_ret);
const T &src_arr = VariantInternalAccessor<T>::get(p_args[0]);
int size = src_arr.size();
dst_arr.resize(size);
@ -603,8 +603,8 @@ public:
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
*r_ret = Array();
Array &dst_arr = *VariantGetInternalPtr<Array>::get_ptr(r_ret);
const T &src_arr = *VariantGetInternalPtr<T>::get_ptr(p_args[0]);
Array &dst_arr = VariantInternalAccessor<Array>::get(r_ret);
const T &src_arr = VariantInternalAccessor<T>::get(p_args[0]);
int size = src_arr.size();
dst_arr.resize(size);
@ -650,8 +650,8 @@ public:
}
VariantTypeChanger<T>::change(&r_ret);
const Array &src_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
T &dst_arr = *VariantGetInternalPtr<T>::get_ptr(&r_ret);
const Array &src_arr = VariantInternalAccessor<Array>::get(p_args[0]);
T &dst_arr = VariantInternalAccessor<T>::get(&r_ret);
int size = src_arr.size();
dst_arr.resize(size);
@ -662,8 +662,8 @@ public:
static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
VariantTypeChanger<T>::change(r_ret);
const Array &src_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
T &dst_arr = *VariantGetInternalPtr<T>::get_ptr(r_ret);
const Array &src_arr = VariantInternalAccessor<Array>::get(p_args[0]);
T &dst_arr = VariantInternalAccessor<T>::get(r_ret);
int size = src_arr.size();
dst_arr.resize(size);

887
core/variant/variant_internal.h
View file

@ -30,6 +30,7 @@
#pragma once
#include "type_info.h"
#include "variant.h"
#include "core/templates/simple_type.h"
@ -44,6 +45,10 @@ class VariantInternal {
public:
// Set type.
_FORCE_INLINE_ static void set_type(Variant &v, Variant::Type p_type) {
v.type = p_type;
}
_FORCE_INLINE_ static void initialize(Variant *v, Variant::Type p_type) {
v->clear();
v->type = p_type;
@ -529,281 +534,35 @@ public:
}
};
template <typename T, typename = void>
struct VariantGetInternalPtr;
template <typename T>
struct VariantGetInternalPtr<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantGetInternalPtr<GetSimpleTypeT<T>> {};
template <>
struct VariantGetInternalPtr<bool> {
static bool *get_ptr(Variant *v) { return VariantInternal::get_bool(v); }
static const bool *get_ptr(const Variant *v) { return VariantInternal::get_bool(v); }
};
template <typename T>
struct VariantGetInternalPtr<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
};
template <typename T>
struct VariantGetInternalPtr<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
};
template <>
struct VariantGetInternalPtr<ObjectID> {
static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
};
template <>
struct VariantGetInternalPtr<float> {
static double *get_ptr(Variant *v) { return VariantInternal::get_float(v); }
static const double *get_ptr(const Variant *v) { return VariantInternal::get_float(v); }
};
template <>
struct VariantGetInternalPtr<double> {
static double *get_ptr(Variant *v) { return VariantInternal::get_float(v); }
static const double *get_ptr(const Variant *v) { return VariantInternal::get_float(v); }
};
template <>
struct VariantGetInternalPtr<String> {
static String *get_ptr(Variant *v) { return VariantInternal::get_string(v); }
static const String *get_ptr(const Variant *v) { return VariantInternal::get_string(v); }
};
template <>
struct VariantGetInternalPtr<Vector2> {
static Vector2 *get_ptr(Variant *v) { return VariantInternal::get_vector2(v); }
static const Vector2 *get_ptr(const Variant *v) { return VariantInternal::get_vector2(v); }
};
template <>
struct VariantGetInternalPtr<Vector2i> {
static Vector2i *get_ptr(Variant *v) { return VariantInternal::get_vector2i(v); }
static const Vector2i *get_ptr(const Variant *v) { return VariantInternal::get_vector2i(v); }
};
template <>
struct VariantGetInternalPtr<Rect2> {
static Rect2 *get_ptr(Variant *v) { return VariantInternal::get_rect2(v); }
static const Rect2 *get_ptr(const Variant *v) { return VariantInternal::get_rect2(v); }
};
template <>
struct VariantGetInternalPtr<Rect2i> {
static Rect2i *get_ptr(Variant *v) { return VariantInternal::get_rect2i(v); }
static const Rect2i *get_ptr(const Variant *v) { return VariantInternal::get_rect2i(v); }
};
template <>
struct VariantGetInternalPtr<Vector3> {
static Vector3 *get_ptr(Variant *v) { return VariantInternal::get_vector3(v); }
static const Vector3 *get_ptr(const Variant *v) { return VariantInternal::get_vector3(v); }
};
template <>
struct VariantGetInternalPtr<Vector3i> {
static Vector3i *get_ptr(Variant *v) { return VariantInternal::get_vector3i(v); }
static const Vector3i *get_ptr(const Variant *v) { return VariantInternal::get_vector3i(v); }
};
template <>
struct VariantGetInternalPtr<Vector4> {
static Vector4 *get_ptr(Variant *v) { return VariantInternal::get_vector4(v); }
static const Vector4 *get_ptr(const Variant *v) { return VariantInternal::get_vector4(v); }
};
template <>
struct VariantGetInternalPtr<Vector4i> {
static Vector4i *get_ptr(Variant *v) { return VariantInternal::get_vector4i(v); }
static const Vector4i *get_ptr(const Variant *v) { return VariantInternal::get_vector4i(v); }
};
template <>
struct VariantGetInternalPtr<Transform2D> {
static Transform2D *get_ptr(Variant *v) { return VariantInternal::get_transform2d(v); }
static const Transform2D *get_ptr(const Variant *v) { return VariantInternal::get_transform2d(v); }
};
template <>
struct VariantGetInternalPtr<Transform3D> {
static Transform3D *get_ptr(Variant *v) { return VariantInternal::get_transform(v); }
static const Transform3D *get_ptr(const Variant *v) { return VariantInternal::get_transform(v); }
};
template <>
struct VariantGetInternalPtr<Projection> {
static Projection *get_ptr(Variant *v) { return VariantInternal::get_projection(v); }
static const Projection *get_ptr(const Variant *v) { return VariantInternal::get_projection(v); }
};
template <>
struct VariantGetInternalPtr<Plane> {
static Plane *get_ptr(Variant *v) { return VariantInternal::get_plane(v); }
static const Plane *get_ptr(const Variant *v) { return VariantInternal::get_plane(v); }
};
template <>
struct VariantGetInternalPtr<Quaternion> {
static Quaternion *get_ptr(Variant *v) { return VariantInternal::get_quaternion(v); }
static const Quaternion *get_ptr(const Variant *v) { return VariantInternal::get_quaternion(v); }
};
template <>
struct VariantGetInternalPtr<::AABB> {
static ::AABB *get_ptr(Variant *v) { return VariantInternal::get_aabb(v); }
static const ::AABB *get_ptr(const Variant *v) { return VariantInternal::get_aabb(v); }
};
template <>
struct VariantGetInternalPtr<Basis> {
static Basis *get_ptr(Variant *v) { return VariantInternal::get_basis(v); }
static const Basis *get_ptr(const Variant *v) { return VariantInternal::get_basis(v); }
};
//
template <>
struct VariantGetInternalPtr<Color> {
static Color *get_ptr(Variant *v) { return VariantInternal::get_color(v); }
static const Color *get_ptr(const Variant *v) { return VariantInternal::get_color(v); }
};
template <>
struct VariantGetInternalPtr<StringName> {
static StringName *get_ptr(Variant *v) { return VariantInternal::get_string_name(v); }
static const StringName *get_ptr(const Variant *v) { return VariantInternal::get_string_name(v); }
};
template <>
struct VariantGetInternalPtr<NodePath> {
static NodePath *get_ptr(Variant *v) { return VariantInternal::get_node_path(v); }
static const NodePath *get_ptr(const Variant *v) { return VariantInternal::get_node_path(v); }
};
template <>
struct VariantGetInternalPtr<::RID> {
static ::RID *get_ptr(Variant *v) { return VariantInternal::get_rid(v); }
static const ::RID *get_ptr(const Variant *v) { return VariantInternal::get_rid(v); }
};
template <>
struct VariantGetInternalPtr<Callable> {
static Callable *get_ptr(Variant *v) { return VariantInternal::get_callable(v); }
static const Callable *get_ptr(const Variant *v) { return VariantInternal::get_callable(v); }
};
template <>
struct VariantGetInternalPtr<Signal> {
static Signal *get_ptr(Variant *v) { return VariantInternal::get_signal(v); }
static const Signal *get_ptr(const Variant *v) { return VariantInternal::get_signal(v); }
};
template <>
struct VariantGetInternalPtr<Dictionary> {
static Dictionary *get_ptr(Variant *v) { return VariantInternal::get_dictionary(v); }
static const Dictionary *get_ptr(const Variant *v) { return VariantInternal::get_dictionary(v); }
};
template <>
struct VariantGetInternalPtr<Array> {
static Array *get_ptr(Variant *v) { return VariantInternal::get_array(v); }
static const Array *get_ptr(const Variant *v) { return VariantInternal::get_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedByteArray> {
static PackedByteArray *get_ptr(Variant *v) { return VariantInternal::get_byte_array(v); }
static const PackedByteArray *get_ptr(const Variant *v) { return VariantInternal::get_byte_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedInt32Array> {
static PackedInt32Array *get_ptr(Variant *v) { return VariantInternal::get_int32_array(v); }
static const PackedInt32Array *get_ptr(const Variant *v) { return VariantInternal::get_int32_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedInt64Array> {
static PackedInt64Array *get_ptr(Variant *v) { return VariantInternal::get_int64_array(v); }
static const PackedInt64Array *get_ptr(const Variant *v) { return VariantInternal::get_int64_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedFloat32Array> {
static PackedFloat32Array *get_ptr(Variant *v) { return VariantInternal::get_float32_array(v); }
static const PackedFloat32Array *get_ptr(const Variant *v) { return VariantInternal::get_float32_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedFloat64Array> {
static PackedFloat64Array *get_ptr(Variant *v) { return VariantInternal::get_float64_array(v); }
static const PackedFloat64Array *get_ptr(const Variant *v) { return VariantInternal::get_float64_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedStringArray> {
static PackedStringArray *get_ptr(Variant *v) { return VariantInternal::get_string_array(v); }
static const PackedStringArray *get_ptr(const Variant *v) { return VariantInternal::get_string_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedVector2Array> {
static PackedVector2Array *get_ptr(Variant *v) { return VariantInternal::get_vector2_array(v); }
static const PackedVector2Array *get_ptr(const Variant *v) { return VariantInternal::get_vector2_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedVector3Array> {
static PackedVector3Array *get_ptr(Variant *v) { return VariantInternal::get_vector3_array(v); }
static const PackedVector3Array *get_ptr(const Variant *v) { return VariantInternal::get_vector3_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedColorArray> {
static PackedColorArray *get_ptr(Variant *v) { return VariantInternal::get_color_array(v); }
static const PackedColorArray *get_ptr(const Variant *v) { return VariantInternal::get_color_array(v); }
};
template <>
struct VariantGetInternalPtr<PackedVector4Array> {
static PackedVector4Array *get_ptr(Variant *v) { return VariantInternal::get_vector4_array(v); }
static const PackedVector4Array *get_ptr(const Variant *v) { return VariantInternal::get_vector4_array(v); }
};
template <typename T, typename = void>
struct VariantInternalAccessor;
template <typename T>
struct VariantInternalAccessor<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantInternalAccessor<GetSimpleTypeT<T>> {};
template <>
struct VariantInternalAccessor<bool> {
static _FORCE_INLINE_ bool get(const Variant *v) { return *VariantInternal::get_bool(v); }
static _FORCE_INLINE_ void set(Variant *v, bool p_value) { *VariantInternal::get_bool(v) = p_value; }
template <typename T>
struct _VariantInternalAccessorLocal {
using declared_when_native_type = void;
static constexpr bool is_local = true;
static _FORCE_INLINE_ T &get(Variant *v) { return *reinterpret_cast<T *>(v->_data._mem); }
static _FORCE_INLINE_ const T &get(const Variant *v) { return *reinterpret_cast<const T *>(v->_data._mem); }
static _FORCE_INLINE_ void set(Variant *v, T p_value) { *reinterpret_cast<T *>(v->_data._mem) = std::move(p_value); }
};
template <typename T>
struct VariantInternalAccessor<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
static _FORCE_INLINE_ T get(const Variant *v) { return static_cast<T>(*VariantInternal::get_int(v)); }
static _FORCE_INLINE_ void set(Variant *v, T p_value) { *VariantInternal::get_int(v) = static_cast<int64_t>(p_value); }
struct _VariantInternalAccessorElsewhere {
using declared_when_native_type = void;
static _FORCE_INLINE_ T &get(Variant *v) { return *reinterpret_cast<T *>(v->_data._ptr); }
static _FORCE_INLINE_ const T &get(const Variant *v) { return *reinterpret_cast<const T *>(v->_data._ptr); }
static _FORCE_INLINE_ void set(Variant *v, T p_value) { *reinterpret_cast<T *>(v->_data._ptr) = std::move(p_value); }
};
template <typename T>
struct VariantInternalAccessor<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
static _FORCE_INLINE_ BitField<T> get(const Variant *v) { return BitField<T>(static_cast<T>(*VariantInternal::get_int(v))); }
static _FORCE_INLINE_ void set(Variant *v, BitField<T> p_value) { *VariantInternal::get_int(v) = static_cast<int64_t>(p_value); }
};
template <>
struct VariantInternalAccessor<ObjectID> {
static _FORCE_INLINE_ ObjectID get(const Variant *v) { return ObjectID(*VariantInternal::get_int(v)); }
static _FORCE_INLINE_ void set(Variant *v, ObjectID p_value) { *VariantInternal::get_int(v) = p_value; }
struct _VariantInternalAccessorPackedArrayRef {
using declared_when_native_type = void;
static _FORCE_INLINE_ Vector<T> &get(Variant *v) { return static_cast<Variant::PackedArrayRef<T> *>(v->_data.packed_array)->array; }
static _FORCE_INLINE_ const Vector<T> &get(const Variant *v) { return static_cast<const Variant::PackedArrayRef<T> *>(v->_data.packed_array)->array; }
static _FORCE_INLINE_ void set(Variant *v, Vector<T> p_value) { static_cast<Variant::PackedArrayRef<T> *>(v->_data.packed_array)->array = std::move(p_value); }
};
template <typename T>
@ -824,221 +583,6 @@ struct VariantInternalAccessor<IPAddress> {
static _FORCE_INLINE_ void set(Variant *v, IPAddress p_value) { *VariantInternal::get_string(v) = String(p_value); }
};
template <>
struct VariantInternalAccessor<float> {
static _FORCE_INLINE_ float get(const Variant *v) { return *VariantInternal::get_float(v); }
static _FORCE_INLINE_ void set(Variant *v, float p_value) { *VariantInternal::get_float(v) = p_value; }
};
template <>
struct VariantInternalAccessor<double> {
static _FORCE_INLINE_ double get(const Variant *v) { return *VariantInternal::get_float(v); }
static _FORCE_INLINE_ void set(Variant *v, double p_value) { *VariantInternal::get_float(v) = p_value; }
};
template <>
struct VariantInternalAccessor<String> {
static _FORCE_INLINE_ const String &get(const Variant *v) { return *VariantInternal::get_string(v); }
static _FORCE_INLINE_ void set(Variant *v, const String &p_value) { *VariantInternal::get_string(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Vector2> {
static _FORCE_INLINE_ const Vector2 &get(const Variant *v) { return *VariantInternal::get_vector2(v); }
static _FORCE_INLINE_ void set(Variant *v, const Vector2 &p_value) { *VariantInternal::get_vector2(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Vector2i> {
static _FORCE_INLINE_ const Vector2i &get(const Variant *v) { return *VariantInternal::get_vector2i(v); }
static _FORCE_INLINE_ void set(Variant *v, const Vector2i &p_value) { *VariantInternal::get_vector2i(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Rect2> {
static _FORCE_INLINE_ const Rect2 &get(const Variant *v) { return *VariantInternal::get_rect2(v); }
static _FORCE_INLINE_ void set(Variant *v, const Rect2 &p_value) { *VariantInternal::get_rect2(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Rect2i> {
static _FORCE_INLINE_ const Rect2i &get(const Variant *v) { return *VariantInternal::get_rect2i(v); }
static _FORCE_INLINE_ void set(Variant *v, const Rect2i &p_value) { *VariantInternal::get_rect2i(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Vector3> {
static _FORCE_INLINE_ const Vector3 &get(const Variant *v) { return *VariantInternal::get_vector3(v); }
static _FORCE_INLINE_ void set(Variant *v, const Vector3 &p_value) { *VariantInternal::get_vector3(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Vector3i> {
static _FORCE_INLINE_ const Vector3i &get(const Variant *v) { return *VariantInternal::get_vector3i(v); }
static _FORCE_INLINE_ void set(Variant *v, const Vector3i &p_value) { *VariantInternal::get_vector3i(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Vector4> {
static _FORCE_INLINE_ const Vector4 &get(const Variant *v) { return *VariantInternal::get_vector4(v); }
static _FORCE_INLINE_ void set(Variant *v, const Vector4 &p_value) { *VariantInternal::get_vector4(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Vector4i> {
static _FORCE_INLINE_ const Vector4i &get(const Variant *v) { return *VariantInternal::get_vector4i(v); }
static _FORCE_INLINE_ void set(Variant *v, const Vector4i &p_value) { *VariantInternal::get_vector4i(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Transform2D> {
static _FORCE_INLINE_ const Transform2D &get(const Variant *v) { return *VariantInternal::get_transform2d(v); }
static _FORCE_INLINE_ void set(Variant *v, const Transform2D &p_value) { *VariantInternal::get_transform2d(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Transform3D> {
static _FORCE_INLINE_ const Transform3D &get(const Variant *v) { return *VariantInternal::get_transform(v); }
static _FORCE_INLINE_ void set(Variant *v, const Transform3D &p_value) { *VariantInternal::get_transform(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Projection> {
static _FORCE_INLINE_ const Projection &get(const Variant *v) { return *VariantInternal::get_projection(v); }
static _FORCE_INLINE_ void set(Variant *v, const Projection &p_value) { *VariantInternal::get_projection(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Plane> {
static _FORCE_INLINE_ const Plane &get(const Variant *v) { return *VariantInternal::get_plane(v); }
static _FORCE_INLINE_ void set(Variant *v, const Plane &p_value) { *VariantInternal::get_plane(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Quaternion> {
static _FORCE_INLINE_ const Quaternion &get(const Variant *v) { return *VariantInternal::get_quaternion(v); }
static _FORCE_INLINE_ void set(Variant *v, const Quaternion &p_value) { *VariantInternal::get_quaternion(v) = p_value; }
};
template <>
struct VariantInternalAccessor<AABB> {
static _FORCE_INLINE_ const AABB &get(const Variant *v) { return *VariantInternal::get_aabb(v); }
static _FORCE_INLINE_ void set(Variant *v, const AABB &p_value) { *VariantInternal::get_aabb(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Basis> {
static _FORCE_INLINE_ const Basis &get(const Variant *v) { return *VariantInternal::get_basis(v); }
static _FORCE_INLINE_ void set(Variant *v, const Basis &p_value) { *VariantInternal::get_basis(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Color> {
static _FORCE_INLINE_ const Color &get(const Variant *v) { return *VariantInternal::get_color(v); }
static _FORCE_INLINE_ void set(Variant *v, const Color &p_value) { *VariantInternal::get_color(v) = p_value; }
};
template <>
struct VariantInternalAccessor<StringName> {
static _FORCE_INLINE_ const StringName &get(const Variant *v) { return *VariantInternal::get_string_name(v); }
static _FORCE_INLINE_ void set(Variant *v, const StringName &p_value) { *VariantInternal::get_string_name(v) = p_value; }
};
template <>
struct VariantInternalAccessor<NodePath> {
static _FORCE_INLINE_ const NodePath &get(const Variant *v) { return *VariantInternal::get_node_path(v); }
static _FORCE_INLINE_ void set(Variant *v, const NodePath &p_value) { *VariantInternal::get_node_path(v) = p_value; }
};
template <>
struct VariantInternalAccessor<::RID> {
static _FORCE_INLINE_ const ::RID &get(const Variant *v) { return *VariantInternal::get_rid(v); }
static _FORCE_INLINE_ void set(Variant *v, const ::RID &p_value) { *VariantInternal::get_rid(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Callable> {
static _FORCE_INLINE_ const Callable &get(const Variant *v) { return *VariantInternal::get_callable(v); }
static _FORCE_INLINE_ void set(Variant *v, const Callable &p_value) { *VariantInternal::get_callable(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Signal> {
static _FORCE_INLINE_ const Signal &get(const Variant *v) { return *VariantInternal::get_signal(v); }
static _FORCE_INLINE_ void set(Variant *v, const Signal &p_value) { *VariantInternal::get_signal(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Dictionary> {
static _FORCE_INLINE_ const Dictionary &get(const Variant *v) { return *VariantInternal::get_dictionary(v); }
static _FORCE_INLINE_ void set(Variant *v, const Dictionary &p_value) { *VariantInternal::get_dictionary(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Array> {
static _FORCE_INLINE_ const Array &get(const Variant *v) { return *VariantInternal::get_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const Array &p_value) { *VariantInternal::get_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedByteArray> {
static _FORCE_INLINE_ const PackedByteArray &get(const Variant *v) { return *VariantInternal::get_byte_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedByteArray &p_value) { *VariantInternal::get_byte_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedInt32Array> {
static _FORCE_INLINE_ const PackedInt32Array &get(const Variant *v) { return *VariantInternal::get_int32_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedInt32Array &p_value) { *VariantInternal::get_int32_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedInt64Array> {
static _FORCE_INLINE_ const PackedInt64Array &get(const Variant *v) { return *VariantInternal::get_int64_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedInt64Array &p_value) { *VariantInternal::get_int64_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedFloat32Array> {
static _FORCE_INLINE_ const PackedFloat32Array &get(const Variant *v) { return *VariantInternal::get_float32_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedFloat32Array &p_value) { *VariantInternal::get_float32_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedFloat64Array> {
static _FORCE_INLINE_ const PackedFloat64Array &get(const Variant *v) { return *VariantInternal::get_float64_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedFloat64Array &p_value) { *VariantInternal::get_float64_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedStringArray> {
static _FORCE_INLINE_ const PackedStringArray &get(const Variant *v) { return *VariantInternal::get_string_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedStringArray &p_value) { *VariantInternal::get_string_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedVector2Array> {
static _FORCE_INLINE_ const PackedVector2Array &get(const Variant *v) { return *VariantInternal::get_vector2_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedVector2Array &p_value) { *VariantInternal::get_vector2_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedVector3Array> {
static _FORCE_INLINE_ const PackedVector3Array &get(const Variant *v) { return *VariantInternal::get_vector3_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedVector3Array &p_value) { *VariantInternal::get_vector3_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedColorArray> {
static _FORCE_INLINE_ const PackedColorArray &get(const Variant *v) { return *VariantInternal::get_color_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedColorArray &p_value) { *VariantInternal::get_color_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<PackedVector4Array> {
static _FORCE_INLINE_ const PackedVector4Array &get(const Variant *v) { return *VariantInternal::get_vector4_array(v); }
static _FORCE_INLINE_ void set(Variant *v, const PackedVector4Array &p_value) { *VariantInternal::get_vector4_array(v) = p_value; }
};
template <>
struct VariantInternalAccessor<Object *> {
static _FORCE_INLINE_ Object *get(const Variant *v) { return const_cast<Object *>(*VariantInternal::get_object(v)); }
@ -1073,14 +617,165 @@ struct VariantInternalAccessor<Vector<Variant>> {
}
};
template <>
struct VariantInternalAccessor<bool> : _VariantInternalAccessorLocal<bool> {};
template <>
struct VariantInternalAccessor<int64_t> : _VariantInternalAccessorLocal<int64_t> {};
template <>
struct VariantInternalAccessor<double> : _VariantInternalAccessorLocal<double> {};
template <>
struct VariantInternalAccessor<String> : _VariantInternalAccessorLocal<String> {};
template <>
struct VariantInternalAccessor<Vector2> : _VariantInternalAccessorLocal<Vector2> {};
template <>
struct VariantInternalAccessor<Vector2i> : _VariantInternalAccessorLocal<Vector2i> {};
template <>
struct VariantInternalAccessor<Rect2> : _VariantInternalAccessorLocal<Rect2> {};
template <>
struct VariantInternalAccessor<Rect2i> : _VariantInternalAccessorLocal<Rect2i> {};
template <>
struct VariantInternalAccessor<Vector3> : _VariantInternalAccessorLocal<Vector3> {};
template <>
struct VariantInternalAccessor<Vector3i> : _VariantInternalAccessorLocal<Vector3i> {};
template <>
struct VariantInternalAccessor<Vector4> : _VariantInternalAccessorLocal<Vector4> {};
template <>
struct VariantInternalAccessor<Vector4i> : _VariantInternalAccessorLocal<Vector4i> {};
template <>
struct VariantInternalAccessor<Transform2D> : _VariantInternalAccessorElsewhere<Transform2D> {};
template <>
struct VariantInternalAccessor<Transform3D> : _VariantInternalAccessorElsewhere<Transform3D> {};
template <>
struct VariantInternalAccessor<Projection> : _VariantInternalAccessorElsewhere<Projection> {};
template <>
struct VariantInternalAccessor<Plane> : _VariantInternalAccessorLocal<Plane> {};
template <>
struct VariantInternalAccessor<Quaternion> : _VariantInternalAccessorLocal<Quaternion> {};
template <>
struct VariantInternalAccessor<::AABB> : _VariantInternalAccessorElsewhere<::AABB> {};
template <>
struct VariantInternalAccessor<Basis> : _VariantInternalAccessorElsewhere<Basis> {};
template <>
struct VariantInternalAccessor<Color> : _VariantInternalAccessorLocal<Color> {};
template <>
struct VariantInternalAccessor<StringName> : _VariantInternalAccessorLocal<StringName> {};
template <>
struct VariantInternalAccessor<NodePath> : _VariantInternalAccessorLocal<NodePath> {};
template <>
struct VariantInternalAccessor<::RID> : _VariantInternalAccessorLocal<::RID> {};
// template <>
// struct VariantInternalAccessor<Variant::ObjData> : _VariantInternalAccessorLocal<Variant::ObjData> {};
template <>
struct VariantInternalAccessor<Callable> : _VariantInternalAccessorLocal<Callable> {};
template <>
struct VariantInternalAccessor<Signal> : _VariantInternalAccessorLocal<Signal> {};
template <>
struct VariantInternalAccessor<Dictionary> : _VariantInternalAccessorLocal<Dictionary> {};
template <>
struct VariantInternalAccessor<Array> : _VariantInternalAccessorLocal<Array> {};
template <>
struct VariantInternalAccessor<PackedByteArray> : _VariantInternalAccessorPackedArrayRef<uint8_t> {};
template <>
struct VariantInternalAccessor<PackedInt32Array> : _VariantInternalAccessorPackedArrayRef<int32_t> {};
template <>
struct VariantInternalAccessor<PackedInt64Array> : _VariantInternalAccessorPackedArrayRef<int64_t> {};
template <>
struct VariantInternalAccessor<PackedFloat32Array> : _VariantInternalAccessorPackedArrayRef<float> {};
template <>
struct VariantInternalAccessor<PackedFloat64Array> : _VariantInternalAccessorPackedArrayRef<double> {};
template <>
struct VariantInternalAccessor<PackedStringArray> : _VariantInternalAccessorPackedArrayRef<String> {};
template <>
struct VariantInternalAccessor<PackedVector2Array> : _VariantInternalAccessorPackedArrayRef<Vector2> {};
template <>
struct VariantInternalAccessor<PackedVector3Array> : _VariantInternalAccessorPackedArrayRef<Vector3> {};
template <>
struct VariantInternalAccessor<PackedColorArray> : _VariantInternalAccessorPackedArrayRef<Color> {};
template <>
struct VariantInternalAccessor<PackedVector4Array> : _VariantInternalAccessorPackedArrayRef<Vector4> {};
template <typename T, typename = std::void_t<>>
struct IsVariantType : std::false_type {};
template <typename T>
struct IsVariantType<T, std::void_t<typename VariantInternalAccessor<T>::declared_when_native_type>> : std::true_type {};
template <typename T>
constexpr bool IsVariantTypeT = IsVariantType<T>::value;
template <typename T, typename S>
struct _VariantInternalAccessorConvert {
static _FORCE_INLINE_ T get(const Variant *v) {
return T(VariantInternalAccessor<S>::get(v));
}
static _FORCE_INLINE_ void set(Variant *v, const T p_value) {
VariantInternalAccessor<S>::get(v) = S(std::move(p_value));
}
};
// Integer types.
template <typename T>
struct VariantInternalAccessor<T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool> && !std::is_same_v<T, int64_t>>> : _VariantInternalAccessorConvert<T, int64_t> {};
template <typename T>
struct VariantInternalAccessor<T, std::enable_if_t<std::is_enum_v<T>>> : _VariantInternalAccessorConvert<T, int64_t> {};
template <typename T>
struct VariantInternalAccessor<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> : _VariantInternalAccessorConvert<BitField<T>, int64_t> {};
template <>
struct VariantInternalAccessor<ObjectID> : _VariantInternalAccessorConvert<ObjectID, int64_t> {};
// Float types.
template <>
struct VariantInternalAccessor<float> : _VariantInternalAccessorConvert<float, double> {};
template <typename T, typename = void>
struct VariantInitializer {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<T>(v); }
};
template <>
struct VariantInitializer<String> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string(v); }
template <typename T>
struct VariantInitializer<T, std::enable_if_t<VariantInternalAccessor<T>::is_local>> {
static _FORCE_INLINE_ void init(Variant *v) {
memnew_placement(&VariantInternalAccessor<T>::get(v), T);
VariantInternal::set_type(*v, GetTypeInfo<T>::VARIANT_TYPE);
}
};
template <>
@ -1108,36 +803,6 @@ struct VariantInitializer<Projection> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_projection(v); }
};
template <>
struct VariantInitializer<StringName> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string_name(v); }
};
template <>
struct VariantInitializer<NodePath> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_node_path(v); }
};
template <>
struct VariantInitializer<Callable> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_callable(v); }
};
template <>
struct VariantInitializer<Signal> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_signal(v); }
};
template <>
struct VariantInitializer<Dictionary> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_dictionary(v); }
};
template <>
struct VariantInitializer<Array> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_array(v); }
};
template <>
struct VariantInitializer<PackedByteArray> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_byte_array(v); }
@ -1193,205 +858,15 @@ struct VariantInitializer<Object *> {
static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_object(v); }
};
/// Note: This struct assumes that the argument type is already of the correct type.
template <typename T, typename = void>
struct VariantDefaultInitializer;
template <typename T>
struct VariantDefaultInitializer<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantDefaultInitializer<GetSimpleTypeT<T>> {};
template <>
struct VariantDefaultInitializer<bool> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_bool(v) = false; }
};
template <typename T>
struct VariantDefaultInitializer<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int(v) = 0; }
};
template <typename T>
struct VariantDefaultInitializer<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int(v) = 0; }
};
template <>
struct VariantDefaultInitializer<double> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
};
template <>
struct VariantDefaultInitializer<float> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
};
template <>
struct VariantDefaultInitializer<String> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string(v) = String(); }
};
template <>
struct VariantDefaultInitializer<Vector2> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2(v) = Vector2(); }
};
template <>
struct VariantDefaultInitializer<Vector2i> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2i(v) = Vector2i(); }
};
template <>
struct VariantDefaultInitializer<Rect2> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rect2(v) = Rect2(); }
};
template <>
struct VariantDefaultInitializer<Rect2i> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rect2i(v) = Rect2i(); }
};
template <>
struct VariantDefaultInitializer<Vector3> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3(v) = Vector3(); }
};
template <>
struct VariantDefaultInitializer<Vector3i> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3i(v) = Vector3i(); }
};
template <>
struct VariantDefaultInitializer<Vector4> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4(v) = Vector4(); }
};
template <>
struct VariantDefaultInitializer<Vector4i> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4i(v) = Vector4i(); }
};
template <>
struct VariantDefaultInitializer<Transform2D> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_transform2d(v) = Transform2D(); }
};
template <>
struct VariantDefaultInitializer<Plane> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_plane(v) = Plane(); }
};
template <>
struct VariantDefaultInitializer<Quaternion> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_quaternion(v) = Quaternion(); }
};
template <>
struct VariantDefaultInitializer<AABB> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_aabb(v) = AABB(); }
};
template <>
struct VariantDefaultInitializer<Basis> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_basis(v) = Basis(); }
};
template <>
struct VariantDefaultInitializer<Transform3D> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_transform(v) = Transform3D(); }
};
template <>
struct VariantDefaultInitializer<Projection> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_projection(v) = Projection(); }
};
template <>
struct VariantDefaultInitializer<Color> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_color(v) = Color(); }
};
template <>
struct VariantDefaultInitializer<StringName> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string_name(v) = StringName(); }
};
template <>
struct VariantDefaultInitializer<NodePath> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_node_path(v) = NodePath(); }
};
template <>
struct VariantDefaultInitializer<::RID> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rid(v) = RID(); }
};
template <>
struct VariantDefaultInitializer<Callable> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_callable(v) = Callable(); }
};
template <>
struct VariantDefaultInitializer<Signal> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_signal(v) = Signal(); }
};
template <>
struct VariantDefaultInitializer<Dictionary> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_dictionary(v) = Dictionary(); }
};
template <>
struct VariantDefaultInitializer<Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_array(v) = Array(); }
};
template <>
struct VariantDefaultInitializer<PackedByteArray> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_byte_array(v) = PackedByteArray(); }
};
template <>
struct VariantDefaultInitializer<PackedInt32Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int32_array(v) = PackedInt32Array(); }
};
template <>
struct VariantDefaultInitializer<PackedInt64Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int64_array(v) = PackedInt64Array(); }
};
template <>
struct VariantDefaultInitializer<PackedFloat32Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float32_array(v) = PackedFloat32Array(); }
};
template <>
struct VariantDefaultInitializer<PackedFloat64Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float64_array(v) = PackedFloat64Array(); }
};
template <>
struct VariantDefaultInitializer<PackedStringArray> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string_array(v) = PackedStringArray(); }
};
template <>
struct VariantDefaultInitializer<PackedVector2Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2_array(v) = PackedVector2Array(); }
};
template <>
struct VariantDefaultInitializer<PackedVector3Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3_array(v) = PackedVector3Array(); }
};
template <>
struct VariantDefaultInitializer<PackedColorArray> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_color_array(v) = PackedColorArray(); }
};
template <>
struct VariantDefaultInitializer<PackedVector4Array> {
static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4_array(v) = PackedVector4Array(); }
struct VariantDefaultInitializer<T, std::enable_if_t<IsVariantTypeT<T>>> {
static _FORCE_INLINE_ void init(Variant *v) {
VariantInternalAccessor<T>::get(v) = T();
}
};
template <typename T>

56
core/variant/variant_op.cpp
View file

@ -51,13 +51,13 @@ template <>
class OperatorEvaluatorMul<Vector2, Vector2i, double> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_left);
const double &b = VariantInternalAccessor<double>::get(&p_right);
*r_ret = Vector2(a.x, a.y) * b;
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector2>::get_ptr(r_ret) = Vector2(VariantGetInternalPtr<Vector2i>::get_ptr(left)->x, VariantGetInternalPtr<Vector2i>::get_ptr(left)->y) * *VariantGetInternalPtr<double>::get_ptr(right);
VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(left).x, VariantInternalAccessor<Vector2i>::get(left).y) * VariantInternalAccessor<double>::get(right);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(left).x, PtrToArg<Vector2i>::convert(left).y) * PtrToArg<double>::convert(right), r_ret);
@ -69,13 +69,13 @@ template <>
class OperatorEvaluatorMul<Vector2, double, Vector2i> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_right);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_left);
const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_right);
const double &b = VariantInternalAccessor<double>::get(&p_left);
*r_ret = Vector2(a.x, a.y) * b;
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector2>::get_ptr(r_ret) = Vector2(VariantGetInternalPtr<Vector2i>::get_ptr(right)->x, VariantGetInternalPtr<Vector2i>::get_ptr(right)->y) * *VariantGetInternalPtr<double>::get_ptr(left);
VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(right).x, VariantInternalAccessor<Vector2i>::get(right).y) * VariantInternalAccessor<double>::get(left);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(right).x, PtrToArg<Vector2i>::convert(right).y) * PtrToArg<double>::convert(left), r_ret);
@ -87,8 +87,8 @@ template <>
class OperatorEvaluatorDivNZ<Vector2, Vector2i, double> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_left);
const double &b = VariantInternalAccessor<double>::get(&p_right);
if (unlikely(b == 0)) {
r_valid = false;
*r_ret = "Division by zero error";
@ -98,7 +98,7 @@ public:
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector2>::get_ptr(r_ret) = Vector2(VariantGetInternalPtr<Vector2i>::get_ptr(left)->x, VariantGetInternalPtr<Vector2i>::get_ptr(left)->y) / *VariantGetInternalPtr<double>::get_ptr(right);
VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(left).x, VariantInternalAccessor<Vector2i>::get(left).y) / VariantInternalAccessor<double>::get(right);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(left).x, PtrToArg<Vector2i>::convert(left).y) / PtrToArg<double>::convert(right), r_ret);
@ -110,13 +110,13 @@ template <>
class OperatorEvaluatorMul<Vector3, Vector3i, double> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_left);
const double &b = VariantInternalAccessor<double>::get(&p_right);
*r_ret = Vector3(a.x, a.y, a.z) * b;
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector3>::get_ptr(r_ret) = Vector3(VariantGetInternalPtr<Vector3i>::get_ptr(left)->x, VariantGetInternalPtr<Vector3i>::get_ptr(left)->y, VariantGetInternalPtr<Vector3i>::get_ptr(left)->z) * *VariantGetInternalPtr<double>::get_ptr(right);
VariantInternalAccessor<Vector3>::get(r_ret) = Vector3(VariantInternalAccessor<Vector3i>::get(left).x, VariantInternalAccessor<Vector3i>::get(left).y, VariantInternalAccessor<Vector3i>::get(left).z) * VariantInternalAccessor<double>::get(right);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector3>::encode(Vector3(PtrToArg<Vector3i>::convert(left).x, PtrToArg<Vector3i>::convert(left).y, PtrToArg<Vector3i>::convert(left).z) * PtrToArg<double>::convert(right), r_ret);
@ -128,13 +128,13 @@ template <>
class OperatorEvaluatorMul<Vector3, double, Vector3i> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_right);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_left);
const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_right);
const double &b = VariantInternalAccessor<double>::get(&p_left);
*r_ret = Vector3(a.x, a.y, a.z) * b;
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector3>::get_ptr(r_ret) = Vector3(VariantGetInternalPtr<Vector3i>::get_ptr(right)->x, VariantGetInternalPtr<Vector3i>::get_ptr(right)->y, VariantGetInternalPtr<Vector3i>::get_ptr(right)->z) * *VariantGetInternalPtr<double>::get_ptr(left);
VariantInternalAccessor<Vector3>::get(r_ret) = Vector3(VariantInternalAccessor<Vector3i>::get(right).x, VariantInternalAccessor<Vector3i>::get(right).y, VariantInternalAccessor<Vector3i>::get(right).z) * VariantInternalAccessor<double>::get(left);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector3>::encode(Vector3(PtrToArg<Vector3i>::convert(right).x, PtrToArg<Vector3i>::convert(right).y, PtrToArg<Vector3i>::convert(right).z) * PtrToArg<double>::convert(left), r_ret);
@ -146,8 +146,8 @@ template <>
class OperatorEvaluatorDivNZ<Vector3, Vector3i, double> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_left);
const double &b = VariantInternalAccessor<double>::get(&p_right);
if (unlikely(b == 0)) {
r_valid = false;
*r_ret = "Division by zero error";
@ -157,7 +157,7 @@ public:
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector3>::get_ptr(r_ret) = Vector3(VariantGetInternalPtr<Vector3i>::get_ptr(left)->x, VariantGetInternalPtr<Vector3i>::get_ptr(left)->y, VariantGetInternalPtr<Vector3i>::get_ptr(left)->z) / *VariantGetInternalPtr<double>::get_ptr(right);
VariantInternalAccessor<Vector3>::get(r_ret) = Vector3(VariantInternalAccessor<Vector3i>::get(left).x, VariantInternalAccessor<Vector3i>::get(left).y, VariantInternalAccessor<Vector3i>::get(left).z) / VariantInternalAccessor<double>::get(right);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector3>::encode(Vector3(PtrToArg<Vector3i>::convert(left).x, PtrToArg<Vector3i>::convert(left).y, PtrToArg<Vector3i>::convert(left).z) / PtrToArg<double>::convert(right), r_ret);
@ -171,13 +171,13 @@ template <>
class OperatorEvaluatorMul<Vector4, Vector4i, double> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_left);
const double &b = VariantInternalAccessor<double>::get(&p_right);
*r_ret = Vector4(a.x, a.y, a.z, a.w) * b;
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector4>::get_ptr(r_ret) = Vector4(VariantGetInternalPtr<Vector4i>::get_ptr(left)->x, VariantGetInternalPtr<Vector4i>::get_ptr(left)->y, VariantGetInternalPtr<Vector4i>::get_ptr(left)->z, VariantGetInternalPtr<Vector4i>::get_ptr(left)->w) * *VariantGetInternalPtr<double>::get_ptr(right);
VariantInternalAccessor<Vector4>::get(r_ret) = Vector4(VariantInternalAccessor<Vector4i>::get(left).x, VariantInternalAccessor<Vector4i>::get(left).y, VariantInternalAccessor<Vector4i>::get(left).z, VariantInternalAccessor<Vector4i>::get(left).w) * VariantInternalAccessor<double>::get(right);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector4>::encode(Vector4(PtrToArg<Vector4i>::convert(left).x, PtrToArg<Vector4i>::convert(left).y, PtrToArg<Vector4i>::convert(left).z, PtrToArg<Vector4i>::convert(left).w) * PtrToArg<double>::convert(right), r_ret);
@ -189,13 +189,13 @@ template <>
class OperatorEvaluatorMul<Vector4, double, Vector4i> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_right);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_left);
const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_right);
const double &b = VariantInternalAccessor<double>::get(&p_left);
*r_ret = Vector4(a.x, a.y, a.z, a.w) * b;
r_valid = true;
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector4>::get_ptr(r_ret) = Vector4(VariantGetInternalPtr<Vector4i>::get_ptr(right)->x, VariantGetInternalPtr<Vector4i>::get_ptr(right)->y, VariantGetInternalPtr<Vector4i>::get_ptr(right)->z, VariantGetInternalPtr<Vector4i>::get_ptr(right)->w) * *VariantGetInternalPtr<double>::get_ptr(left);
VariantInternalAccessor<Vector4>::get(r_ret) = Vector4(VariantInternalAccessor<Vector4i>::get(right).x, VariantInternalAccessor<Vector4i>::get(right).y, VariantInternalAccessor<Vector4i>::get(right).z, VariantInternalAccessor<Vector4i>::get(right).w) * VariantInternalAccessor<double>::get(left);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
PtrToArg<Vector4>::encode(Vector4(PtrToArg<Vector4i>::convert(right).x, PtrToArg<Vector4i>::convert(right).y, PtrToArg<Vector4i>::convert(right).z, PtrToArg<Vector4i>::convert(right).w) * PtrToArg<double>::convert(left), r_ret);
@ -207,8 +207,8 @@ template <>
class OperatorEvaluatorDivNZ<Vector4, Vector4i, double> {
public:
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_left);
const double &b = VariantInternalAccessor<double>::get(&p_right);
if (unlikely(b == 0)) {
r_valid = false;
*r_ret = "Division by zero error";
@ -219,7 +219,7 @@ public:
}
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
*VariantGetInternalPtr<Vector4>::get_ptr(r_ret) = Vector4(VariantGetInternalPtr<Vector4i>::get_ptr(left)->x, VariantGetInternalPtr<Vector4i>::get_ptr(left)->y, VariantGetInternalPtr<Vector4i>::get_ptr(left)->z, VariantGetInternalPtr<Vector4i>::get_ptr(left)->w) / *VariantGetInternalPtr<double>::get_ptr(right);
VariantInternalAccessor<Vector4>::get(r_ret) = Vector4(VariantInternalAccessor<Vector4i>::get(left).x, VariantInternalAccessor<Vector4i>::get(left).y, VariantInternalAccessor<Vector4i>::get(left).z, VariantInternalAccessor<Vector4i>::get(left).w) / VariantInternalAccessor<double>::get(right);
}
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
@ -1166,7 +1166,7 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const {
}
if (valid) {
ERR_FAIL_COND_V(ret.type != BOOL, false);
return *VariantGetInternalPtr<bool>::get_ptr(&ret);
return VariantInternalAccessor<bool>::get(&ret);
} else {
return false;
}

406
core/variant/variant_op.h
View file

File diff suppressed because it is too large Load diff

626
core/variant/variant_setget.cpp
View file

@ -256,7 +256,7 @@ void Variant::set_named(const StringName &p_member, const Variant &p_value, bool
return;
}
} else if (type == Variant::DICTIONARY) {
Dictionary &dict = *VariantGetInternalPtr<Dictionary>::get_ptr(this);
Dictionary &dict = VariantInternalAccessor<Dictionary>::get(this);
r_valid = dict.set(p_member, p_value);
} else {
r_valid = false;
@ -287,7 +287,7 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
}
} break;
case Variant::DICTIONARY: {
const Variant *v = VariantGetInternalPtr<Dictionary>::get_ptr(this)->getptr(p_member);
const Variant *v = VariantInternalAccessor<Dictionary>::get(this).getptr(p_member);
if (v) {
r_valid = true;
return *v;
@ -329,207 +329,67 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
#endif
#define INDEXED_SETGET_STRUCT_TYPED(m_base_type, m_elem_type) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index]; \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
PtrToArg<m_elem_type>::encode(v[index], member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) { \
*oob = false; \
*valid = false; \
return; \
} \
int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
*valid = false; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
v.write[index] = PtrToArg<m_elem_type>::convert(member); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
} \
};
#define INDEXED_SETGET_STRUCT_TYPED_NUMERIC(m_base_type, m_elem_type, m_assign_type) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index]; \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
PtrToArg<m_elem_type>::encode(v[index], member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
*valid = false; \
return; \
} \
m_assign_type num; \
if (value->get_type() == Variant::INT) { \
num = (m_assign_type) * VariantGetInternalPtr<int64_t>::get_ptr(value); \
} else if (value->get_type() == Variant::FLOAT) { \
num = (m_assign_type) * VariantGetInternalPtr<double>::get_ptr(value); \
} else { \
*oob = false; \
*valid = false; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = num; \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
v.write[index] = PtrToArg<m_elem_type>::convert(member); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return VariantGetInternalPtr<m_base_type>::get_ptr(base)->size(); \
} \
};
#define INDEXED_SETGET_STRUCT_BUILTIN_NUMERIC(m_base_type, m_elem_type, m_assign_type, m_max) \
#define INDEXED_SETGET_STRUCT_TYPED(m_base_type, m_elem_type) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
int64_t size = VariantInternalAccessor<m_base_type>::get(base).size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index]; \
VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))[index]; \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
OOB_TEST(index, m_max); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
PtrToArg<m_elem_type>::encode(v[index], member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
*valid = false; \
return; \
} \
m_assign_type num; \
if (value->get_type() == Variant::INT) { \
num = (m_assign_type) * VariantGetInternalPtr<int64_t>::get_ptr(value); \
} else if (value->get_type() == Variant::FLOAT) { \
num = (m_assign_type) * VariantGetInternalPtr<double>::get_ptr(value); \
} else { \
if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) { \
*oob = false; \
*valid = false; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = num; \
int64_t size = VariantInternalAccessor<m_base_type>::get(base).size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
*valid = false; \
return; \
} \
(VariantInternalAccessor<m_base_type>::get(base)).write[index] = VariantInternalAccessor<m_elem_type>::get(value); \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
int64_t size = VariantInternalAccessor<m_base_type>::get(base).size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
(VariantInternalAccessor<m_base_type>::get(base)).write[index] = VariantInternalAccessor<m_elem_type>::get(value); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
OOB_TEST(index, m_max); \
v[index] = PtrToArg<m_elem_type>::convert(member); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
v.write[index] = PtrToArg<m_elem_type>::convert(member); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
@ -538,125 +398,265 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return m_max; \
return VariantInternalAccessor<m_base_type>::get(base).size(); \
} \
};
#define INDEXED_SETGET_STRUCT_BUILTIN_ACCESSOR(m_base_type, m_elem_type, m_accessor, m_max) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))m_accessor[index]; \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
OOB_TEST(index, m_max); \
PtrToArg<m_elem_type>::encode(v m_accessor[index], member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) { \
*oob = false; \
*valid = false; \
} \
if (index < 0 || index >= m_max) { \
*oob = true; \
*valid = false; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
(*VariantGetInternalPtr<m_base_type>::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
OOB_TEST(index, m_max); \
v m_accessor[index] = PtrToArg<m_elem_type>::convert(member); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return m_max; \
} \
#define INDEXED_SETGET_STRUCT_TYPED_NUMERIC(m_base_type, m_elem_type, m_assign_type) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
int64_t size = VariantInternalAccessor<m_base_type>::get(base).size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))[index]; \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
PtrToArg<m_elem_type>::encode(v[index], member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
int64_t size = VariantInternalAccessor<m_base_type>::get(base).size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
*valid = false; \
return; \
} \
m_assign_type num; \
if (value->get_type() == Variant::INT) { \
num = (m_assign_type) * &VariantInternalAccessor<int64_t>::get(value); \
} else if (value->get_type() == Variant::FLOAT) { \
num = (m_assign_type) * &VariantInternalAccessor<double>::get(value); \
} else { \
*oob = false; \
*valid = false; \
return; \
} \
(VariantInternalAccessor<m_base_type>::get(base)).write[index] = num; \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
int64_t size = VariantInternalAccessor<m_base_type>::get(base).size(); \
if (index < 0) { \
index += size; \
} \
if (index < 0 || index >= size) { \
*oob = true; \
return; \
} \
(VariantInternalAccessor<m_base_type>::get(base)).write[index] = VariantInternalAccessor<m_elem_type>::get(value); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
if (index < 0) \
index += v.size(); \
OOB_TEST(index, v.size()); \
v.write[index] = PtrToArg<m_elem_type>::convert(member); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return VariantInternalAccessor<m_base_type>::get(base).size(); \
} \
};
#define INDEXED_SETGET_STRUCT_BUILTIN_FUNC(m_base_type, m_elem_type, m_set, m_get, m_max) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_get(index); \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
OOB_TEST(index, m_max); \
PtrToArg<m_elem_type>::encode(v.m_get(index), member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) { \
*oob = false; \
*valid = false; \
} \
if (index < 0 || index >= m_max) { \
*oob = true; \
*valid = false; \
return; \
} \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_set(index, *VariantGetInternalPtr<m_elem_type>::get_ptr(value)); \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_set(index, *VariantGetInternalPtr<m_elem_type>::get_ptr(value)); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
OOB_TEST(index, m_max); \
v.m_set(index, PtrToArg<m_elem_type>::convert(member)); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return m_max; \
} \
#define INDEXED_SETGET_STRUCT_BUILTIN_NUMERIC(m_base_type, m_elem_type, m_assign_type, m_max) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))[index]; \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
OOB_TEST(index, m_max); \
PtrToArg<m_elem_type>::encode(v[index], member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
*valid = false; \
return; \
} \
m_assign_type num; \
if (value->get_type() == Variant::INT) { \
num = (m_assign_type) * &VariantInternalAccessor<int64_t>::get(value); \
} else if (value->get_type() == Variant::FLOAT) { \
num = (m_assign_type) * &VariantInternalAccessor<double>::get(value); \
} else { \
*oob = false; \
*valid = false; \
return; \
} \
(VariantInternalAccessor<m_base_type>::get(base))[index] = num; \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
(VariantInternalAccessor<m_base_type>::get(base))[index] = VariantInternalAccessor<m_elem_type>::get(value); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
OOB_TEST(index, m_max); \
v[index] = PtrToArg<m_elem_type>::convert(member); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return m_max; \
} \
};
#define INDEXED_SETGET_STRUCT_BUILTIN_ACCESSOR(m_base_type, m_elem_type, m_accessor, m_max) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))m_accessor[index]; \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
OOB_TEST(index, m_max); \
PtrToArg<m_elem_type>::encode(v m_accessor[index], member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) { \
*oob = false; \
*valid = false; \
} \
if (index < 0 || index >= m_max) { \
*oob = true; \
*valid = false; \
return; \
} \
(VariantInternalAccessor<m_base_type>::get(base)) m_accessor[index] = VariantInternalAccessor<m_elem_type>::get(value); \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
(VariantInternalAccessor<m_base_type>::get(base)) m_accessor[index] = VariantInternalAccessor<m_elem_type>::get(value); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
OOB_TEST(index, m_max); \
v m_accessor[index] = PtrToArg<m_elem_type>::convert(member); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return m_max; \
} \
};
#define INDEXED_SETGET_STRUCT_BUILTIN_FUNC(m_base_type, m_elem_type, m_set, m_get, m_max) \
struct VariantIndexedSetGet_##m_base_type { \
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
VariantTypeAdjust<m_elem_type>::adjust(value); \
VariantInternalAccessor<m_elem_type>::get(value) = VariantInternalAccessor<m_base_type>::get(base).m_get(index); \
*oob = false; \
} \
static void ptr_get(const void *base, int64_t index, void *member) { \
/* avoid ptrconvert for performance*/ \
const m_base_type &v = *reinterpret_cast<const m_base_type *>(base); \
OOB_TEST(index, m_max); \
PtrToArg<m_elem_type>::encode(v.m_get(index), member); \
} \
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \
if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) { \
*oob = false; \
*valid = false; \
} \
if (index < 0 || index >= m_max) { \
*oob = true; \
*valid = false; \
return; \
} \
VariantInternalAccessor<m_base_type>::get(base).m_set(index, VariantInternalAccessor<m_elem_type>::get(value)); \
*oob = false; \
*valid = true; \
} \
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \
if (index < 0 || index >= m_max) { \
*oob = true; \
return; \
} \
VariantInternalAccessor<m_base_type>::get(base).m_set(index, VariantInternalAccessor<m_elem_type>::get(value)); \
*oob = false; \
} \
static void ptr_set(void *base, int64_t index, const void *member) { \
/* avoid ptrconvert for performance*/ \
m_base_type &v = *reinterpret_cast<m_base_type *>(base); \
OOB_TEST(index, m_max); \
v.m_set(index, PtrToArg<m_elem_type>::convert(member)); \
} \
static Variant::Type get_index_type() { \
return GetTypeInfo<m_elem_type>::VARIANT_TYPE; \
} \
static uint32_t get_index_usage() { \
return GetTypeInfo<m_elem_type>::get_class_info().usage; \
} \
static uint64_t get_indexed_size(const Variant *base) { \
return m_max; \
} \
};
struct VariantIndexedSetGet_Array {
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {
int64_t size = VariantGetInternalPtr<Array>::get_ptr(base)->size();
int64_t size = VariantInternalAccessor<Array>::get(base).size();
if (index < 0) {
index += size;
}
@ -664,7 +664,7 @@ struct VariantIndexedSetGet_Array {
*oob = true;
return;
}
*value = (*VariantGetInternalPtr<Array>::get_ptr(base))[index];
*value = (VariantInternalAccessor<Array>::get(base))[index];
*oob = false;
}
static void ptr_get(const void *base, int64_t index, void *member) {
@ -677,12 +677,12 @@ struct VariantIndexedSetGet_Array {
PtrToArg<Variant>::encode(v[index], member);
}
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {
if (VariantGetInternalPtr<Array>::get_ptr(base)->is_read_only()) {
if (VariantInternalAccessor<Array>::get(base).is_read_only()) {
*valid = false;
*oob = true;
return;
}
int64_t size = VariantGetInternalPtr<Array>::get_ptr(base)->size();
int64_t size = VariantInternalAccessor<Array>::get(base).size();
if (index < 0) {
index += size;
}
@ -691,16 +691,16 @@ struct VariantIndexedSetGet_Array {
*valid = false;
return;
}
VariantGetInternalPtr<Array>::get_ptr(base)->set(index, *value);
VariantInternalAccessor<Array>::get(base).set(index, *value);
*oob = false;
*valid = true;
}
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {
if (VariantGetInternalPtr<Array>::get_ptr(base)->is_read_only()) {
if (VariantInternalAccessor<Array>::get(base).is_read_only()) {
*oob = true;
return;
}
int64_t size = VariantGetInternalPtr<Array>::get_ptr(base)->size();
int64_t size = VariantInternalAccessor<Array>::get(base).size();
if (index < 0) {
index += size;
}
@ -708,7 +708,7 @@ struct VariantIndexedSetGet_Array {
*oob = true;
return;
}
VariantGetInternalPtr<Array>::get_ptr(base)->set(index, *value);
VariantInternalAccessor<Array>::get(base).set(index, *value);
*oob = false;
}
static void ptr_set(void *base, int64_t index, const void *member) {
@ -727,7 +727,7 @@ struct VariantIndexedSetGet_Array {
struct VariantIndexedSetGet_Dictionary {
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {
const Variant *ptr = VariantGetInternalPtr<Dictionary>::get_ptr(base)->getptr(index);
const Variant *ptr = VariantInternalAccessor<Dictionary>::get(base).getptr(index);
if (!ptr) {
*oob = true;
return;
@ -743,12 +743,12 @@ struct VariantIndexedSetGet_Dictionary {
PtrToArg<Variant>::encode(*ptr, member);
}
static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {
*valid = VariantGetInternalPtr<Dictionary>::get_ptr(base)->set(index, *value);
*oob = VariantGetInternalPtr<Dictionary>::get_ptr(base)->is_read_only();
*valid = VariantInternalAccessor<Dictionary>::get(base).set(index, *value);
*oob = VariantInternalAccessor<Dictionary>::get(base).is_read_only();
}
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {
VariantGetInternalPtr<Dictionary>::get_ptr(base)->set(index, *value);
*oob = VariantGetInternalPtr<Dictionary>::get_ptr(base)->is_read_only();
VariantInternalAccessor<Dictionary>::get(base).set(index, *value);
*oob = VariantInternalAccessor<Dictionary>::get(base).is_read_only();
}
static void ptr_set(void *base, int64_t index, const void *member) {
Dictionary &v = *reinterpret_cast<Dictionary *>(base);
@ -756,12 +756,12 @@ struct VariantIndexedSetGet_Dictionary {
}
static Variant::Type get_index_type() { return Variant::NIL; }
static uint32_t get_index_usage() { return PROPERTY_USAGE_DEFAULT; }
static uint64_t get_indexed_size(const Variant *base) { return VariantGetInternalPtr<Dictionary>::get_ptr(base)->size(); }
static uint64_t get_indexed_size(const Variant *base) { return VariantInternalAccessor<Dictionary>::get(base).size(); }
};
struct VariantIndexedSetGet_String {
static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {
int64_t length = VariantGetInternalPtr<String>::get_ptr(base)->length();
int64_t length = VariantInternalAccessor<String>::get(base).length();
if (index < 0) {
index += length;
}
@ -769,7 +769,7 @@ struct VariantIndexedSetGet_String {
*oob = true;
return;
}
*value = String::chr((*VariantGetInternalPtr<String>::get_ptr(base))[index]);
*value = String::chr((VariantInternalAccessor<String>::get(base))[index]);
*oob = false;
}
static void ptr_get(const void *base, int64_t index, void *member) {
@ -787,7 +787,7 @@ struct VariantIndexedSetGet_String {
*valid = false;
return;
}
int64_t length = VariantGetInternalPtr<String>::get_ptr(base)->length();
int64_t length = VariantInternalAccessor<String>::get(base).length();
if (index < 0) {
index += length;
}
@ -796,7 +796,7 @@ struct VariantIndexedSetGet_String {
*valid = false;
return;
}
String *b = VariantGetInternalPtr<String>::get_ptr(base);
String *b = &VariantInternalAccessor<String>::get(base);
const String *v = VariantInternal::get_string(value);
if (v->length() == 0) {
b->remove_at(index);
@ -807,7 +807,7 @@ struct VariantIndexedSetGet_String {
*valid = true;
}
static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {
int64_t length = VariantGetInternalPtr<String>::get_ptr(base)->length();
int64_t length = VariantInternalAccessor<String>::get(base).length();
if (index < 0) {
index += length;
}
@ -815,7 +815,7 @@ struct VariantIndexedSetGet_String {
*oob = true;
return;
}
String *b = VariantGetInternalPtr<String>::get_ptr(base);
String *b = &VariantInternalAccessor<String>::get(base);
const String *v = VariantInternal::get_string(value);
if (v->length() == 0) {
b->remove_at(index);
@ -1004,7 +1004,7 @@ uint64_t Variant::get_indexed_size() const {
struct VariantKeyedSetGetDictionary {
static void get(const Variant *base, const Variant *key, Variant *value, bool *r_valid) {
const Variant *ptr = VariantGetInternalPtr<Dictionary>::get_ptr(base)->getptr(*key);
const Variant *ptr = VariantInternalAccessor<Dictionary>::get(base).getptr(*key);
if (!ptr) {
*r_valid = false;
return;
@ -1020,7 +1020,7 @@ struct VariantKeyedSetGetDictionary {
PtrToArg<Variant>::encode(*ptr, value);
}
static void set(Variant *base, const Variant *key, const Variant *value, bool *r_valid) {
*r_valid = VariantGetInternalPtr<Dictionary>::get_ptr(base)->set(*key, *value);
*r_valid = VariantInternalAccessor<Dictionary>::get(base).set(*key, *value);
}
static void ptr_set(void *base, const void *key, const void *value) {
Dictionary &v = *reinterpret_cast<Dictionary *>(base);
@ -1029,7 +1029,7 @@ struct VariantKeyedSetGetDictionary {
static bool has(const Variant *base, const Variant *key, bool *r_valid) {
*r_valid = true;
return VariantGetInternalPtr<Dictionary>::get_ptr(base)->has(*key);
return VariantInternalAccessor<Dictionary>::get(base).has(*key);
}
static uint32_t ptr_has(const void *base, const void *key) {
/* avoid ptrconvert for performance*/
@ -1197,13 +1197,13 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid,
} else {
bool valid = false;
if (p_index.get_type() == STRING_NAME) {
set_named(*VariantGetInternalPtr<StringName>::get_ptr(&p_index), p_value, valid);
set_named(VariantInternalAccessor<StringName>::get(&p_index), p_value, valid);
if (!valid && err_code) {
*err_code = VariantSetError::SET_NAMED_ERR;
}
} else if (p_index.get_type() == INT) {
bool obb;
set_indexed(*VariantGetInternalPtr<int64_t>::get_ptr(&p_index), p_value, valid, obb);
set_indexed(VariantInternalAccessor<int64_t>::get(&p_index), p_value, valid, obb);
if (obb) {
valid = false;
if (err_code) {
@ -1211,13 +1211,13 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid,
}
}
} else if (p_index.get_type() == STRING) { // less efficient version of named
set_named(*VariantGetInternalPtr<String>::get_ptr(&p_index), p_value, valid);
set_named(VariantInternalAccessor<String>::get(&p_index), p_value, valid);
if (!valid && err_code) {
*err_code = VariantSetError::SET_NAMED_ERR;
}
} else if (p_index.get_type() == FLOAT) { // less efficient version of indexed
bool obb;
set_indexed(*VariantGetInternalPtr<double>::get_ptr(&p_index), p_value, valid, obb);
set_indexed(VariantInternalAccessor<double>::get(&p_index), p_value, valid, obb);
if (obb) {
valid = false;
if (err_code) {
@ -1248,13 +1248,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid, VariantGetError *err
} else {
bool valid = false;
if (p_index.get_type() == STRING_NAME) {
ret = get_named(*VariantGetInternalPtr<StringName>::get_ptr(&p_index), valid);
ret = get_named(VariantInternalAccessor<StringName>::get(&p_index), valid);
if (!valid && err_code) {
*err_code = VariantGetError::GET_NAMED_ERR;
}
} else if (p_index.get_type() == INT) {
bool obb;
ret = get_indexed(*VariantGetInternalPtr<int64_t>::get_ptr(&p_index), valid, obb);
ret = get_indexed(VariantInternalAccessor<int64_t>::get(&p_index), valid, obb);
if (obb) {
valid = false;
if (err_code) {
@ -1262,13 +1262,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid, VariantGetError *err
}
}
} else if (p_index.get_type() == STRING) { // less efficient version of named
ret = get_named(*VariantGetInternalPtr<String>::get_ptr(&p_index), valid);
ret = get_named(VariantInternalAccessor<String>::get(&p_index), valid);
if (!valid && err_code) {
*err_code = VariantGetError::GET_NAMED_ERR;
}
} else if (p_index.get_type() == FLOAT) { // less efficient version of indexed
bool obb;
ret = get_indexed(*VariantGetInternalPtr<double>::get_ptr(&p_index), valid, obb);
ret = get_indexed(VariantInternalAccessor<double>::get(&p_index), valid, obb);
if (obb) {
valid = false;
if (err_code) {

452
core/variant/variant_setget.h
View file

@ -38,244 +38,244 @@
/**** NAMED SETTERS AND GETTERS ****/
#define SETGET_STRUCT(m_base_type, m_member_type, m_member) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_member = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
#define SETGET_STRUCT(m_base_type, m_member_type, m_member) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<m_member_type>::get(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<m_member_type>::get(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_member = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
};
#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == Variant::FLOAT) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<double>::get_ptr(value); \
valid = true; \
} else if (value->get_type() == Variant::INT) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<int64_t>::get_ptr(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_member = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == Variant::FLOAT) { \
VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<double>::get(value); \
valid = true; \
} else if (value->get_type() == Variant::INT) { \
VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<int64_t>::get(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<m_member_type>::get(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_member = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
};
#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_custom = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<m_member_type>::get(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<m_member_type>::get(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_custom = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
};
#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == Variant::FLOAT) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<double>::get_ptr(value); \
valid = true; \
} else if (value->get_type() == Variant::INT) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<int64_t>::get_ptr(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_custom = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom; \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom; \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == Variant::FLOAT) { \
VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<double>::get(value); \
valid = true; \
} else if (value->get_type() == Variant::INT) { \
VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<int64_t>::get(value); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<m_member_type>::get(value); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_custom = PtrToArg<m_member_type>::convert(member); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
};
#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_setter(PtrToArg<m_member_type>::convert(member)); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<m_member_type>::get(value)); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<m_member_type>::get(value)); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_setter(PtrToArg<m_member_type>::convert(member)); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
};
#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == Variant::FLOAT) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<double>::get_ptr(value)); \
valid = true; \
} else if (value->get_type() == Variant::INT) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<int64_t>::get_ptr(value)); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_setter(PtrToArg<m_member_type>::convert(member)); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == Variant::FLOAT) { \
VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<double>::get(value)); \
valid = true; \
} else if (value->get_type() == Variant::INT) { \
VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<int64_t>::get(value)); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<m_member_type>::get(value)); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_setter(PtrToArg<m_member_type>::convert(member)); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
};
#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index); \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index); \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(m_index), member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_setter(m_index, PtrToArg<m_member_type>::convert(member)); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index) \
struct VariantSetGet_##m_base_type##_##m_member { \
static void get(const Variant *base, Variant *member) { \
VariantTypeAdjust<m_member_type>::adjust(member); \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(m_index); \
} \
static inline void validated_get(const Variant *base, Variant *member) { \
VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(m_index); \
} \
static void ptr_get(const void *base, void *member) { \
PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(m_index), member); \
} \
static void set(Variant *base, const Variant *value, bool &valid) { \
if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) { \
VariantInternalAccessor<m_base_type>::get(base).m_setter(m_index, VariantInternalAccessor<m_member_type>::get(value)); \
valid = true; \
} else { \
valid = false; \
} \
} \
static inline void validated_set(Variant *base, const Variant *value) { \
VariantInternalAccessor<m_base_type>::get(base).m_setter(m_index, VariantInternalAccessor<m_member_type>::get(value)); \
} \
static void ptr_set(void *base, const void *member) { \
m_base_type b = PtrToArg<m_base_type>::convert(base); \
b.m_setter(m_index, PtrToArg<m_member_type>::convert(member)); \
PtrToArg<m_base_type>::encode(b, base); \
} \
static Variant::Type get_type() { \
return GetTypeInfo<m_member_type>::VARIANT_TYPE; \
} \
};
SETGET_NUMBER_STRUCT(Vector2, double, x)

4
servers/rendering/shader_language.cpp
View file

@ -4726,8 +4726,8 @@ Variant ShaderLanguage::get_default_datatype_value(DataType p_type, int p_array_
}
value = Variant(array);
} else {
VariantInitializer<float>::init(&value);
VariantDefaultInitializer<float>::init(&value);
VariantInitializer<double>::init(&value);
VariantDefaultInitializer<double>::init(&value);
}
break;
case ShaderLanguage::TYPE_VEC2: