mirror of
https://github.com/godotengine/godot.git
synced 2025-12-08 06:09:55 +00:00
Merge pull request #113132 from aaronp64/variant_op_eval
Reuse/optimize common `OperatorEvaluator*::evaluate` logic
This commit is contained in:
Rémi Verschelde
commit
37cfae845b
2 changed files with 269 additions and 571 deletions
|
|
@ -48,39 +48,27 @@ void register_op(Variant::Operator p_op, Variant::Type p_type_a, Variant::Type p
|
||||||
// Special cases that can't be done otherwise because of the forced casting to float.
|
// Special cases that can't be done otherwise because of the forced casting to float.
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
class OperatorEvaluatorMul<Vector2, Vector2i, double> {
|
class OperatorEvaluatorMul<Vector2, Vector2i, double> : public CommonEvaluate<OperatorEvaluatorMul<Vector2, Vector2i, double>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
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) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(left).x, VariantInternalAccessor<Vector2i>::get(left).y) * VariantInternalAccessor<double>::get(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) {
|
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);
|
PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(left).x, PtrToArg<Vector2i>::convert(left).y) * PtrToArg<double>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<Vector2>::VARIANT_TYPE; }
|
using ReturnType = Vector2;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
class OperatorEvaluatorMul<Vector2, double, Vector2i> {
|
class OperatorEvaluatorMul<Vector2, double, Vector2i> : public CommonEvaluate<OperatorEvaluatorMul<Vector2, double, Vector2i>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
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) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(right).x, VariantInternalAccessor<Vector2i>::get(right).y) * VariantInternalAccessor<double>::get(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) {
|
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);
|
PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(right).x, PtrToArg<Vector2i>::convert(right).y) * PtrToArg<double>::convert(left), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<Vector2>::VARIANT_TYPE; }
|
using ReturnType = Vector2;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
|
|
@ -107,39 +95,27 @@ public:
|
||||||
};
|
};
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
class OperatorEvaluatorMul<Vector3, Vector3i, double> {
|
class OperatorEvaluatorMul<Vector3, Vector3i, double> : public CommonEvaluate<OperatorEvaluatorMul<Vector3, Vector3i, double>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
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) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
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);
|
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) {
|
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);
|
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);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<Vector3>::VARIANT_TYPE; }
|
using ReturnType = Vector3;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
class OperatorEvaluatorMul<Vector3, double, Vector3i> {
|
class OperatorEvaluatorMul<Vector3, double, Vector3i> : public CommonEvaluate<OperatorEvaluatorMul<Vector3, double, Vector3i>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
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) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
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);
|
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) {
|
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);
|
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);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<Vector3>::VARIANT_TYPE; }
|
using ReturnType = Vector3;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
|
|
@ -168,39 +144,27 @@ public:
|
||||||
//
|
//
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
class OperatorEvaluatorMul<Vector4, Vector4i, double> {
|
class OperatorEvaluatorMul<Vector4, Vector4i, double> : public CommonEvaluate<OperatorEvaluatorMul<Vector4, Vector4i, double>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
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) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
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);
|
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) {
|
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);
|
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);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<Vector4>::VARIANT_TYPE; }
|
using ReturnType = Vector4;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
class OperatorEvaluatorMul<Vector4, double, Vector4i> {
|
class OperatorEvaluatorMul<Vector4, double, Vector4i> : public CommonEvaluate<OperatorEvaluatorMul<Vector4, double, Vector4i>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
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) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
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);
|
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) {
|
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);
|
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);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<Vector4>::VARIANT_TYPE; }
|
using ReturnType = Vector4;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <>
|
template <>
|
||||||
|
|
@ -520,7 +484,7 @@ void Variant::_register_variant_operators() {
|
||||||
register_op<OperatorEvaluatorBitXor<int64_t, int64_t, int64_t>>(Variant::OP_BIT_XOR, Variant::INT, Variant::INT);
|
register_op<OperatorEvaluatorBitXor<int64_t, int64_t, int64_t>>(Variant::OP_BIT_XOR, Variant::INT, Variant::INT);
|
||||||
register_op<OperatorEvaluatorBitNeg<int64_t, int64_t>>(Variant::OP_BIT_NEGATE, Variant::INT, Variant::NIL);
|
register_op<OperatorEvaluatorBitNeg<int64_t, int64_t>>(Variant::OP_BIT_NEGATE, Variant::INT, Variant::NIL);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_EQUAL, Variant::NIL, Variant::NIL>>(Variant::OP_EQUAL, Variant::NIL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_EQUAL, Variant::NIL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorEqual<bool, bool>>(Variant::OP_EQUAL, Variant::BOOL, Variant::BOOL);
|
register_op<OperatorEvaluatorEqual<bool, bool>>(Variant::OP_EQUAL, Variant::BOOL, Variant::BOOL);
|
||||||
register_op<OperatorEvaluatorEqual<int64_t, int64_t>>(Variant::OP_EQUAL, Variant::INT, Variant::INT);
|
register_op<OperatorEvaluatorEqual<int64_t, int64_t>>(Variant::OP_EQUAL, Variant::INT, Variant::INT);
|
||||||
register_op<OperatorEvaluatorEqual<int64_t, double>>(Variant::OP_EQUAL, Variant::INT, Variant::FLOAT);
|
register_op<OperatorEvaluatorEqual<int64_t, double>>(Variant::OP_EQUAL, Variant::INT, Variant::FLOAT);
|
||||||
|
|
@ -566,83 +530,83 @@ void Variant::_register_variant_operators() {
|
||||||
register_op<OperatorEvaluatorEqual<PackedColorArray, PackedColorArray>>(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY);
|
register_op<OperatorEvaluatorEqual<PackedColorArray, PackedColorArray>>(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY);
|
||||||
register_op<OperatorEvaluatorEqual<PackedVector4Array, PackedVector4Array>>(Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::PACKED_VECTOR4_ARRAY);
|
register_op<OperatorEvaluatorEqual<PackedVector4Array, PackedVector4Array>>(Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::PACKED_VECTOR4_ARRAY);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::BOOL, Variant::NIL>>(Variant::OP_EQUAL, Variant::BOOL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::BOOL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::INT, Variant::NIL>>(Variant::OP_EQUAL, Variant::INT, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::INT, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::FLOAT, Variant::NIL>>(Variant::OP_EQUAL, Variant::FLOAT, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::FLOAT, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::STRING, Variant::NIL>>(Variant::OP_EQUAL, Variant::STRING, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::STRING, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::VECTOR2, Variant::NIL>>(Variant::OP_EQUAL, Variant::VECTOR2, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::VECTOR2, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::VECTOR2I, Variant::NIL>>(Variant::OP_EQUAL, Variant::VECTOR2I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::VECTOR2I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::RECT2, Variant::NIL>>(Variant::OP_EQUAL, Variant::RECT2, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::RECT2, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::RECT2I, Variant::NIL>>(Variant::OP_EQUAL, Variant::RECT2I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::RECT2I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::VECTOR3, Variant::NIL>>(Variant::OP_EQUAL, Variant::VECTOR3, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::VECTOR3, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::VECTOR3I, Variant::NIL>>(Variant::OP_EQUAL, Variant::VECTOR3I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::VECTOR3I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::VECTOR4, Variant::NIL>>(Variant::OP_EQUAL, Variant::VECTOR4, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::VECTOR4, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::VECTOR4I, Variant::NIL>>(Variant::OP_EQUAL, Variant::VECTOR4I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::VECTOR4I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::TRANSFORM2D, Variant::NIL>>(Variant::OP_EQUAL, Variant::TRANSFORM2D, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::TRANSFORM2D, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PLANE, Variant::NIL>>(Variant::OP_EQUAL, Variant::PLANE, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PLANE, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::QUATERNION, Variant::NIL>>(Variant::OP_EQUAL, Variant::QUATERNION, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::QUATERNION, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::AABB, Variant::NIL>>(Variant::OP_EQUAL, Variant::AABB, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::AABB, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::BASIS, Variant::NIL>>(Variant::OP_EQUAL, Variant::BASIS, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::BASIS, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::TRANSFORM3D, Variant::NIL>>(Variant::OP_EQUAL, Variant::TRANSFORM3D, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::TRANSFORM3D, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PROJECTION, Variant::NIL>>(Variant::OP_EQUAL, Variant::PROJECTION, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PROJECTION, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::COLOR, Variant::NIL>>(Variant::OP_EQUAL, Variant::COLOR, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::COLOR, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::STRING_NAME, Variant::NIL>>(Variant::OP_EQUAL, Variant::STRING_NAME, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::STRING_NAME, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NODE_PATH, Variant::NIL>>(Variant::OP_EQUAL, Variant::NODE_PATH, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NODE_PATH, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::RID, Variant::NIL>>(Variant::OP_EQUAL, Variant::RID, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::RID, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::CALLABLE, Variant::NIL>>(Variant::OP_EQUAL, Variant::CALLABLE, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::CALLABLE, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::SIGNAL, Variant::NIL>>(Variant::OP_EQUAL, Variant::SIGNAL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::SIGNAL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::DICTIONARY, Variant::NIL>>(Variant::OP_EQUAL, Variant::DICTIONARY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::DICTIONARY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL>>(Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::BOOL>>(Variant::OP_EQUAL, Variant::NIL, Variant::BOOL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::BOOL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::INT>>(Variant::OP_EQUAL, Variant::NIL, Variant::INT);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::INT);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::FLOAT>>(Variant::OP_EQUAL, Variant::NIL, Variant::FLOAT);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::FLOAT);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::STRING>>(Variant::OP_EQUAL, Variant::NIL, Variant::STRING);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::STRING);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2>>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2I>>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2I);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2I);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::RECT2>>(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::RECT2I>>(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2I);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2I);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3>>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3I>>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3I);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3I);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4>>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4I>>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4I);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4I);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM2D>>(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM2D);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM2D);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PLANE>>(Variant::OP_EQUAL, Variant::NIL, Variant::PLANE);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PLANE);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::QUATERNION>>(Variant::OP_EQUAL, Variant::NIL, Variant::QUATERNION);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::QUATERNION);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::AABB>>(Variant::OP_EQUAL, Variant::NIL, Variant::AABB);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::AABB);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::BASIS>>(Variant::OP_EQUAL, Variant::NIL, Variant::BASIS);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::BASIS);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM3D>>(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM3D);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM3D);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PROJECTION>>(Variant::OP_EQUAL, Variant::NIL, Variant::PROJECTION);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PROJECTION);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::COLOR>>(Variant::OP_EQUAL, Variant::NIL, Variant::COLOR);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::COLOR);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::STRING_NAME>>(Variant::OP_EQUAL, Variant::NIL, Variant::STRING_NAME);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::STRING_NAME);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::NODE_PATH>>(Variant::OP_EQUAL, Variant::NIL, Variant::NODE_PATH);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::NODE_PATH);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::RID>>(Variant::OP_EQUAL, Variant::NIL, Variant::RID);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::RID);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::CALLABLE>>(Variant::OP_EQUAL, Variant::NIL, Variant::CALLABLE);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::CALLABLE);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::SIGNAL>>(Variant::OP_EQUAL, Variant::NIL, Variant::SIGNAL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::SIGNAL);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::DICTIONARY>>(Variant::OP_EQUAL, Variant::NIL, Variant::DICTIONARY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::DICTIONARY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY>>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorNotEqual<bool, bool>>(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::BOOL);
|
register_op<OperatorEvaluatorNotEqual<bool, bool>>(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::BOOL);
|
||||||
register_op<OperatorEvaluatorNotEqual<int64_t, int64_t>>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::INT);
|
register_op<OperatorEvaluatorNotEqual<int64_t, int64_t>>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::INT);
|
||||||
register_op<OperatorEvaluatorNotEqual<int64_t, double>>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::FLOAT);
|
register_op<OperatorEvaluatorNotEqual<int64_t, double>>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::FLOAT);
|
||||||
|
|
@ -688,81 +652,81 @@ void Variant::_register_variant_operators() {
|
||||||
register_op<OperatorEvaluatorNotEqual<PackedColorArray, PackedColorArray>>(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY);
|
register_op<OperatorEvaluatorNotEqual<PackedColorArray, PackedColorArray>>(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY);
|
||||||
register_op<OperatorEvaluatorNotEqual<PackedVector4Array, PackedVector4Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::PACKED_VECTOR4_ARRAY);
|
register_op<OperatorEvaluatorNotEqual<PackedVector4Array, PackedVector4Array>>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::PACKED_VECTOR4_ARRAY);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::INT, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::FLOAT, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::FLOAT, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::FLOAT, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::STRING, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::STRING, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::STRING, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::VECTOR2, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::VECTOR2, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::VECTOR2, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::VECTOR2I, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::VECTOR2I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::VECTOR2I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::RECT2, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::RECT2, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::RECT2, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::RECT2I, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::RECT2I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::RECT2I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::VECTOR3, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::VECTOR3, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::VECTOR3, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::VECTOR3I, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::VECTOR3I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::VECTOR3I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::TRANSFORM2D, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM2D, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM2D, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::VECTOR4, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::VECTOR4, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::VECTOR4, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::VECTOR4I, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::VECTOR4I, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::VECTOR4I, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PLANE, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PLANE, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PLANE, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::QUATERNION, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::QUATERNION, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::QUATERNION, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::AABB, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::AABB, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::AABB, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::BASIS, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::BASIS, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::BASIS, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::TRANSFORM3D, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM3D, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM3D, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PROJECTION, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PROJECTION, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PROJECTION, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::COLOR, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::COLOR, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::COLOR, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::STRING_NAME, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::STRING_NAME, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::STRING_NAME, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NODE_PATH, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::NODE_PATH, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NODE_PATH, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::RID, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::RID, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::RID, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::CALLABLE, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::CALLABLE, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::CALLABLE, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::SIGNAL, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::SIGNAL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::SIGNAL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::DICTIONARY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::DICTIONARY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::DICTIONARY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL>>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BOOL>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BOOL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BOOL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::INT>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::INT);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::INT);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::FLOAT>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::FLOAT);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::FLOAT);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2I>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2I);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2I);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2I>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2I);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2I);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3I>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3I);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3I);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4I>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4I);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4I);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM2D>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM2D);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM2D);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PLANE>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PLANE);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PLANE);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::QUATERNION>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::QUATERNION);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::QUATERNION);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::AABB>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::AABB);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::AABB);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BASIS>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BASIS);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BASIS);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM3D>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM3D);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM3D);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PROJECTION>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PROJECTION);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PROJECTION);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::COLOR>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::COLOR);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::COLOR);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING_NAME>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING_NAME);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING_NAME);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NODE_PATH>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NODE_PATH);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NODE_PATH);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RID>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RID);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RID);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::CALLABLE>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::CALLABLE);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::CALLABLE);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::SIGNAL>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::SIGNAL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::SIGNAL);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::DICTIONARY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::DICTIONARY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::DICTIONARY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY);
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY>>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorLess<bool, bool>>(Variant::OP_LESS, Variant::BOOL, Variant::BOOL);
|
register_op<OperatorEvaluatorLess<bool, bool>>(Variant::OP_LESS, Variant::BOOL, Variant::BOOL);
|
||||||
register_op<OperatorEvaluatorLess<int64_t, int64_t>>(Variant::OP_LESS, Variant::INT, Variant::INT);
|
register_op<OperatorEvaluatorLess<int64_t, int64_t>>(Variant::OP_LESS, Variant::INT, Variant::INT);
|
||||||
|
|
@ -826,7 +790,7 @@ void Variant::_register_variant_operators() {
|
||||||
register_op<OperatorEvaluatorGreaterEqual<::RID, ::RID>>(Variant::OP_GREATER_EQUAL, Variant::RID, Variant::RID);
|
register_op<OperatorEvaluatorGreaterEqual<::RID, ::RID>>(Variant::OP_GREATER_EQUAL, Variant::RID, Variant::RID);
|
||||||
register_op<OperatorEvaluatorGreaterEqual<Array, Array>>(Variant::OP_GREATER_EQUAL, Variant::ARRAY, Variant::ARRAY);
|
register_op<OperatorEvaluatorGreaterEqual<Array, Array>>(Variant::OP_GREATER_EQUAL, Variant::ARRAY, Variant::ARRAY);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysFalse<Variant::OP_OR, Variant::NIL, Variant::NIL>>(Variant::OP_OR, Variant::NIL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysFalse>(Variant::OP_OR, Variant::NIL, Variant::NIL);
|
||||||
|
|
||||||
// OR
|
// OR
|
||||||
register_op<OperatorEvaluatorNilXBoolOr>(Variant::OP_OR, Variant::NIL, Variant::BOOL);
|
register_op<OperatorEvaluatorNilXBoolOr>(Variant::OP_OR, Variant::NIL, Variant::BOOL);
|
||||||
|
|
@ -915,7 +879,7 @@ void Variant::_register_variant_operators() {
|
||||||
register_op<OperatorEvaluatorObjectXFloatXor>(Variant::OP_XOR, Variant::OBJECT, Variant::FLOAT);
|
register_op<OperatorEvaluatorObjectXFloatXor>(Variant::OP_XOR, Variant::OBJECT, Variant::FLOAT);
|
||||||
register_op<OperatorEvaluatorObjectXObjectXor>(Variant::OP_XOR, Variant::OBJECT, Variant::OBJECT);
|
register_op<OperatorEvaluatorObjectXObjectXor>(Variant::OP_XOR, Variant::OBJECT, Variant::OBJECT);
|
||||||
|
|
||||||
register_op<OperatorEvaluatorAlwaysTrue<Variant::OP_NOT, Variant::NIL, Variant::NIL>>(Variant::OP_NOT, Variant::NIL, Variant::NIL);
|
register_op<OperatorEvaluatorAlwaysTrue>(Variant::OP_NOT, Variant::NIL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorNotBool>(Variant::OP_NOT, Variant::BOOL, Variant::NIL);
|
register_op<OperatorEvaluatorNotBool>(Variant::OP_NOT, Variant::BOOL, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorNotInt>(Variant::OP_NOT, Variant::INT, Variant::NIL);
|
register_op<OperatorEvaluatorNotInt>(Variant::OP_NOT, Variant::INT, Variant::NIL);
|
||||||
register_op<OperatorEvaluatorNotFloat>(Variant::OP_NOT, Variant::FLOAT, Variant::NIL);
|
register_op<OperatorEvaluatorNotFloat>(Variant::OP_NOT, Variant::FLOAT, Variant::NIL);
|
||||||
|
|
|
||||||
|
|
@ -35,130 +35,99 @@
|
||||||
#include "core/debugger/engine_debugger.h"
|
#include "core/debugger/engine_debugger.h"
|
||||||
#include "core/object/class_db.h"
|
#include "core/object/class_db.h"
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename Evaluator>
|
||||||
class OperatorEvaluatorAdd {
|
class CommonEvaluate {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
VariantTypeChanger<typename Evaluator::ReturnType>::change(r_ret);
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
Evaluator::validated_evaluate(&p_left, &p_right, r_ret);
|
||||||
*r_ret = a + b;
|
|
||||||
r_valid = true;
|
r_valid = true;
|
||||||
}
|
}
|
||||||
|
static Variant::Type get_return_type() { return GetTypeInfo<typename Evaluator::ReturnType>::VARIANT_TYPE; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A, typename B>
|
||||||
|
class OperatorEvaluatorAdd : public CommonEvaluate<OperatorEvaluatorAdd<R, A, B>> {
|
||||||
|
public:
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) + VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) + VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) + PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) + PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorSub {
|
class OperatorEvaluatorSub : public CommonEvaluate<OperatorEvaluatorSub<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a - b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) - VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) - VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) - PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) - PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorMul {
|
class OperatorEvaluatorMul : public CommonEvaluate<OperatorEvaluatorMul<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a * b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) * VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) * VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) * PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) * PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorPow {
|
class OperatorEvaluatorPow : public CommonEvaluate<OperatorEvaluatorPow<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = R(Math::pow((double)a, (double)b));
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = R(Math::pow((double)VariantInternalAccessor<A>::get(left), (double)VariantInternalAccessor<B>::get(right)));
|
VariantInternalAccessor<R>::get(r_ret) = R(Math::pow((double)VariantInternalAccessor<A>::get(left), (double)VariantInternalAccessor<B>::get(right)));
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(R(Math::pow((double)PtrToArg<A>::convert(left), (double)PtrToArg<B>::convert(right))), r_ret);
|
PtrToArg<R>::encode(R(Math::pow((double)PtrToArg<A>::convert(left), (double)PtrToArg<B>::convert(right))), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorXForm {
|
class OperatorEvaluatorXForm : public CommonEvaluate<OperatorEvaluatorXForm<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a.xform(b);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left).xform(VariantInternalAccessor<B>::get(right));
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left).xform(VariantInternalAccessor<B>::get(right));
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left).xform(PtrToArg<B>::convert(right)), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left).xform(PtrToArg<B>::convert(right)), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorXFormInv {
|
class OperatorEvaluatorXFormInv : public CommonEvaluate<OperatorEvaluatorXFormInv<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = b.xform_inv(a);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<B>::get(right).xform_inv(VariantInternalAccessor<A>::get(left));
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<B>::get(right).xform_inv(VariantInternalAccessor<A>::get(left));
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<B>::convert(right).xform_inv(PtrToArg<A>::convert(left)), r_ret);
|
PtrToArg<R>::encode(PtrToArg<B>::convert(right).xform_inv(PtrToArg<A>::convert(left)), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorDiv {
|
class OperatorEvaluatorDiv : public CommonEvaluate<OperatorEvaluatorDiv<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a / b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) / VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) / VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
|
|
@ -257,21 +226,15 @@ public:
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorMod {
|
class OperatorEvaluatorMod : public CommonEvaluate<OperatorEvaluatorMod<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a % b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) % VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) % VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
|
|
@ -370,37 +333,27 @@ public:
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A>
|
template <typename R, typename A>
|
||||||
class OperatorEvaluatorNeg {
|
class OperatorEvaluatorNeg : public CommonEvaluate<OperatorEvaluatorNeg<R, A>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
*r_ret = -a;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = -VariantInternalAccessor<A>::get(left);
|
VariantInternalAccessor<R>::get(r_ret) = -VariantInternalAccessor<A>::get(left);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(-PtrToArg<A>::convert(left), r_ret);
|
PtrToArg<R>::encode(-PtrToArg<A>::convert(left), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A>
|
template <typename R, typename A>
|
||||||
class OperatorEvaluatorPos {
|
class OperatorEvaluatorPos : public CommonEvaluate<OperatorEvaluatorPos<R, A>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
*r_ret = a;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
|
|
@ -456,102 +409,67 @@ public:
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorBitOr {
|
class OperatorEvaluatorBitOr : public CommonEvaluate<OperatorEvaluatorBitOr<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a | b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) | VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) | VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) | PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) | PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorBitAnd {
|
class OperatorEvaluatorBitAnd : public CommonEvaluate<OperatorEvaluatorBitAnd<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a & b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) & VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) & VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) & PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) & PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A, typename B>
|
template <typename R, typename A, typename B>
|
||||||
class OperatorEvaluatorBitXor {
|
class OperatorEvaluatorBitXor : public CommonEvaluate<OperatorEvaluatorBitXor<R, A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a ^ b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) ^ VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) ^ VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(PtrToArg<A>::convert(left) ^ PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<R>::encode(PtrToArg<A>::convert(left) ^ PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename R, typename A>
|
template <typename R, typename A>
|
||||||
class OperatorEvaluatorBitNeg {
|
class OperatorEvaluatorBitNeg : public CommonEvaluate<OperatorEvaluatorBitNeg<R, A>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
*r_ret = ~a;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<R>::get(r_ret) = ~VariantInternalAccessor<A>::get(left);
|
VariantInternalAccessor<R>::get(r_ret) = ~VariantInternalAccessor<A>::get(left);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<R>::encode(~PtrToArg<A>::convert(left), r_ret);
|
PtrToArg<R>::encode(~PtrToArg<A>::convert(left), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
|
using ReturnType = R;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorEqual {
|
class OperatorEvaluatorEqual : public CommonEvaluate<OperatorEvaluatorEqual<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a == b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) == VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) == VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorEqualObject {
|
class OperatorEvaluatorEqualObject : public CommonEvaluate<OperatorEvaluatorEqualObject> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Object *a = p_left.get_validated_object();
|
|
||||||
const Object *b = p_right.get_validated_object();
|
|
||||||
*r_ret = a == b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Object *a = left->get_validated_object();
|
const Object *a = left->get_validated_object();
|
||||||
const Object *b = right->get_validated_object();
|
const Object *b = right->get_validated_object();
|
||||||
|
|
@ -560,16 +478,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == PtrToArg<Object *>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == PtrToArg<Object *>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorEqualObjectNil {
|
class OperatorEvaluatorEqualObjectNil : public CommonEvaluate<OperatorEvaluatorEqualObjectNil> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Object *a = p_left.get_validated_object();
|
|
||||||
*r_ret = a == nullptr;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Object *a = left->get_validated_object();
|
const Object *a = left->get_validated_object();
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = a == nullptr;
|
VariantInternalAccessor<bool>::get(r_ret) = a == nullptr;
|
||||||
|
|
@ -577,16 +490,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorEqualNilObject {
|
class OperatorEvaluatorEqualNilObject : public CommonEvaluate<OperatorEvaluatorEqualNilObject> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Object *b = p_right.get_validated_object();
|
|
||||||
*r_ret = nullptr == b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Object *b = right->get_validated_object();
|
const Object *b = right->get_validated_object();
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = nullptr == b;
|
VariantInternalAccessor<bool>::get(r_ret) = nullptr == b;
|
||||||
|
|
@ -594,35 +502,23 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(nullptr == PtrToArg<Object *>::convert(right), r_ret);
|
PtrToArg<bool>::encode(nullptr == PtrToArg<Object *>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorNotEqual {
|
class OperatorEvaluatorNotEqual : public CommonEvaluate<OperatorEvaluatorNotEqual<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a != b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) != VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) != VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) != PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) != PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorNotEqualObject {
|
class OperatorEvaluatorNotEqualObject : public CommonEvaluate<OperatorEvaluatorNotEqualObject> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
Object *a = p_left.get_validated_object();
|
|
||||||
Object *b = p_right.get_validated_object();
|
|
||||||
*r_ret = a != b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
Object *a = left->get_validated_object();
|
Object *a = left->get_validated_object();
|
||||||
Object *b = right->get_validated_object();
|
Object *b = right->get_validated_object();
|
||||||
|
|
@ -631,16 +527,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != PtrToArg<Object *>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != PtrToArg<Object *>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorNotEqualObjectNil {
|
class OperatorEvaluatorNotEqualObjectNil : public CommonEvaluate<OperatorEvaluatorNotEqualObjectNil> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
Object *a = p_left.get_validated_object();
|
|
||||||
*r_ret = a != nullptr;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
Object *a = left->get_validated_object();
|
Object *a = left->get_validated_object();
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = a != nullptr;
|
VariantInternalAccessor<bool>::get(r_ret) = a != nullptr;
|
||||||
|
|
@ -648,16 +539,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != nullptr, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != nullptr, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorNotEqualNilObject {
|
class OperatorEvaluatorNotEqualNilObject : public CommonEvaluate<OperatorEvaluatorNotEqualNilObject> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
Object *b = p_right.get_validated_object();
|
|
||||||
*r_ret = nullptr != b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
Object *b = right->get_validated_object();
|
Object *b = right->get_validated_object();
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = nullptr != b;
|
VariantInternalAccessor<bool>::get(r_ret) = nullptr != b;
|
||||||
|
|
@ -665,159 +551,112 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(nullptr != PtrToArg<Object *>::convert(right), r_ret);
|
PtrToArg<bool>::encode(nullptr != PtrToArg<Object *>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorLess {
|
class OperatorEvaluatorLess : public CommonEvaluate<OperatorEvaluatorLess<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a < b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) < VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) < VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) < PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) < PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorLessEqual {
|
class OperatorEvaluatorLessEqual : public CommonEvaluate<OperatorEvaluatorLessEqual<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a <= b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) <= VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) <= VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) <= PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) <= PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorGreater {
|
class OperatorEvaluatorGreater : public CommonEvaluate<OperatorEvaluatorGreater<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a > b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) > VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) > VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) > PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) > PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorGreaterEqual {
|
class OperatorEvaluatorGreaterEqual : public CommonEvaluate<OperatorEvaluatorGreaterEqual<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a >= b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) >= VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) >= VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) >= PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) >= PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorAnd {
|
class OperatorEvaluatorAnd : public CommonEvaluate<OperatorEvaluatorAnd<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a && b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) && VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) && VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) && PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) && PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorOr {
|
class OperatorEvaluatorOr : public CommonEvaluate<OperatorEvaluatorOr<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = a || b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) || VariantInternalAccessor<B>::get(right);
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) || VariantInternalAccessor<B>::get(right);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) || PtrToArg<B>::convert(right), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) || PtrToArg<B>::convert(right), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
#define XOR_OP(m_a, m_b) (((m_a) || (m_b)) && !((m_a) && (m_b)))
|
#define XOR_OP(m_a, m_b) (((m_a) || (m_b)) && !((m_a) && (m_b)))
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorXor {
|
class OperatorEvaluatorXor : public CommonEvaluate<OperatorEvaluatorXor<A, B>> {
|
||||||
public:
|
public:
|
||||||
_FORCE_INLINE_ static bool xor_op(const A &a, const B &b) {
|
_FORCE_INLINE_ static bool xor_op(const A &a, const B &b) {
|
||||||
return ((a) || (b)) && !((a) && (b));
|
return ((a) || (b)) && !((a) && (b));
|
||||||
}
|
}
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
*r_ret = xor_op(a, b);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = xor_op(VariantInternalAccessor<A>::get(left), VariantInternalAccessor<B>::get(right));
|
VariantInternalAccessor<bool>::get(r_ret) = xor_op(VariantInternalAccessor<A>::get(left), VariantInternalAccessor<B>::get(right));
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(xor_op(PtrToArg<A>::convert(left), PtrToArg<B>::convert(right)), r_ret);
|
PtrToArg<bool>::encode(xor_op(PtrToArg<A>::convert(left), PtrToArg<B>::convert(right)), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A>
|
template <typename A>
|
||||||
class OperatorEvaluatorNot {
|
class OperatorEvaluatorNot : public CommonEvaluate<OperatorEvaluatorNot<A>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
*r_ret = a == A();
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) == A();
|
VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) == A();
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == A(), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == A(), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
//// CUSTOM ////
|
//// CUSTOM ////
|
||||||
|
|
||||||
class OperatorEvaluatorAddArray {
|
class OperatorEvaluatorAddArray : public CommonEvaluate<OperatorEvaluatorAddArray> {
|
||||||
public:
|
public:
|
||||||
_FORCE_INLINE_ static void _add_arrays(Array &sum, const Array &array_a, const Array &array_b) {
|
_FORCE_INLINE_ static void _add_arrays(Array &sum, const Array &array_a, const Array &array_b) {
|
||||||
int asize = array_a.size();
|
int asize = array_a.size();
|
||||||
|
|
@ -835,14 +674,6 @@ public:
|
||||||
sum[i + asize] = array_b[i];
|
sum[i + asize] = array_b[i];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Array &array_a = VariantInternalAccessor<Array>::get(&p_left);
|
|
||||||
const Array &array_b = VariantInternalAccessor<Array>::get(&p_right);
|
|
||||||
Array sum;
|
|
||||||
_add_arrays(sum, array_a, array_b);
|
|
||||||
*r_ret = sum;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
*r_ret = Array();
|
*r_ret = Array();
|
||||||
_add_arrays(VariantInternalAccessor<Array>::get(r_ret), VariantInternalAccessor<Array>::get(left), VariantInternalAccessor<Array>::get(right));
|
_add_arrays(VariantInternalAccessor<Array>::get(r_ret), VariantInternalAccessor<Array>::get(left), VariantInternalAccessor<Array>::get(right));
|
||||||
|
|
@ -852,20 +683,12 @@ public:
|
||||||
_add_arrays(ret, PtrToArg<Array>::convert(left), PtrToArg<Array>::convert(right));
|
_add_arrays(ret, PtrToArg<Array>::convert(left), PtrToArg<Array>::convert(right));
|
||||||
PtrToArg<Array>::encode(ret, r_ret);
|
PtrToArg<Array>::encode(ret, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::ARRAY; }
|
using ReturnType = Array;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
class OperatorEvaluatorAppendArray {
|
class OperatorEvaluatorAppendArray : public CommonEvaluate<OperatorEvaluatorAppendArray<T>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Vector<T> &array_a = VariantInternalAccessor<Vector<T>>::get(&p_left);
|
|
||||||
const Vector<T> &array_b = VariantInternalAccessor<Vector<T>>::get(&p_right);
|
|
||||||
Vector<T> sum = array_a;
|
|
||||||
sum.append_array(array_b);
|
|
||||||
*r_ret = sum;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<Vector<T>>::get(r_ret) = VariantInternalAccessor<Vector<T>>::get(left);
|
VariantInternalAccessor<Vector<T>>::get(r_ret) = VariantInternalAccessor<Vector<T>>::get(left);
|
||||||
VariantInternalAccessor<Vector<T>>::get(r_ret).append_array(VariantInternalAccessor<Vector<T>>::get(right));
|
VariantInternalAccessor<Vector<T>>::get(r_ret).append_array(VariantInternalAccessor<Vector<T>>::get(right));
|
||||||
|
|
@ -875,18 +698,12 @@ public:
|
||||||
sum.append_array(PtrToArg<Vector<T>>::convert(right));
|
sum.append_array(PtrToArg<Vector<T>>::convert(right));
|
||||||
PtrToArg<Vector<T>>::encode(sum, r_ret);
|
PtrToArg<Vector<T>>::encode(sum, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return GetTypeInfo<Vector<T>>::VARIANT_TYPE; }
|
using ReturnType = Vector<T>;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename Left, typename Right>
|
template <typename Left, typename Right>
|
||||||
class OperatorEvaluatorStringConcat {
|
class OperatorEvaluatorStringConcat : public CommonEvaluate<OperatorEvaluatorStringConcat<Left, Right>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const String a(VariantInternalAccessor<Left>::get(&p_left));
|
|
||||||
const String b(VariantInternalAccessor<Right>::get(&p_right));
|
|
||||||
*r_ret = a + b;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const String a(VariantInternalAccessor<Left>::get(left));
|
const String a(VariantInternalAccessor<Left>::get(left));
|
||||||
const String b(VariantInternalAccessor<Right>::get(right));
|
const String b(VariantInternalAccessor<Right>::get(right));
|
||||||
|
|
@ -897,7 +714,7 @@ public:
|
||||||
const String b(PtrToArg<Right>::convert(right));
|
const String b(PtrToArg<Right>::convert(right));
|
||||||
PtrToArg<String>::encode(a + b, r_ret);
|
PtrToArg<String>::encode(a + b, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::STRING; }
|
using ReturnType = String;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename S, typename T>
|
template <typename S, typename T>
|
||||||
|
|
@ -1019,36 +836,26 @@ public:
|
||||||
static Variant::Type get_return_type() { return Variant::STRING; }
|
static Variant::Type get_return_type() { return Variant::STRING; }
|
||||||
};
|
};
|
||||||
|
|
||||||
template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
|
class OperatorEvaluatorAlwaysTrue : public CommonEvaluate<OperatorEvaluatorAlwaysTrue> {
|
||||||
class OperatorEvaluatorAlwaysTrue {
|
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
*r_ret = true;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = true;
|
VariantInternalAccessor<bool>::get(r_ret) = true;
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(true, r_ret);
|
PtrToArg<bool>::encode(true, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
|
class OperatorEvaluatorAlwaysFalse : public CommonEvaluate<OperatorEvaluatorAlwaysFalse> {
|
||||||
class OperatorEvaluatorAlwaysFalse {
|
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
*r_ret = false;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = false;
|
VariantInternalAccessor<bool>::get(r_ret) = false;
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(false, r_ret);
|
PtrToArg<bool>::encode(false, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
///// OR ///////
|
///// OR ///////
|
||||||
|
|
@ -1106,13 +913,8 @@ _FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) {
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op) \
|
#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op) \
|
||||||
class m_class_name { \
|
class m_class_name : public CommonEvaluate<m_class_name> { \
|
||||||
public: \
|
public: \
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { \
|
|
||||||
*r_ret = m_op(_operate_get_##m_left(&p_left), _operate_get_##m_right(&p_right)); \
|
|
||||||
r_valid = true; \
|
|
||||||
} \
|
|
||||||
\
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { \
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { \
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \
|
VariantInternalAccessor<bool>::get(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \
|
||||||
} \
|
} \
|
||||||
|
|
@ -1121,9 +923,7 @@ _FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) {
|
||||||
PtrToArg<bool>::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret); \
|
PtrToArg<bool>::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret); \
|
||||||
} \
|
} \
|
||||||
\
|
\
|
||||||
static Variant::Type get_return_type() { \
|
using ReturnType = bool; \
|
||||||
return Variant::BOOL; \
|
|
||||||
} \
|
|
||||||
};
|
};
|
||||||
|
|
||||||
// OR
|
// OR
|
||||||
|
|
@ -1261,64 +1061,48 @@ OP_EVALUATOR(OperatorEvaluatorObjectXFloatXor, object, float, _operate_xor)
|
||||||
// object
|
// object
|
||||||
OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor)
|
OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor)
|
||||||
|
|
||||||
class OperatorEvaluatorNotBool {
|
class OperatorEvaluatorNotBool : public CommonEvaluate<OperatorEvaluatorNotBool> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
*r_ret = !VariantInternalAccessor<bool>::get(&p_left);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<bool>::get(left);
|
VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<bool>::get(left);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(!PtrToArg<bool>::convert(left), r_ret);
|
PtrToArg<bool>::encode(!PtrToArg<bool>::convert(left), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorNotInt {
|
class OperatorEvaluatorNotInt : public CommonEvaluate<OperatorEvaluatorNotInt> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
*r_ret = !VariantInternalAccessor<int64_t>::get(&p_left);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<int64_t>::get(left);
|
VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<int64_t>::get(left);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(!PtrToArg<int64_t>::convert(left), r_ret);
|
PtrToArg<bool>::encode(!PtrToArg<int64_t>::convert(left), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorNotFloat {
|
class OperatorEvaluatorNotFloat : public CommonEvaluate<OperatorEvaluatorNotFloat> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
*r_ret = !VariantInternalAccessor<double>::get(&p_left);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<double>::get(left);
|
VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<double>::get(left);
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(!PtrToArg<double>::convert(left), r_ret);
|
PtrToArg<bool>::encode(!PtrToArg<double>::convert(left), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorNotObject {
|
class OperatorEvaluatorNotObject : public CommonEvaluate<OperatorEvaluatorNotObject> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
*r_ret = p_left.get_validated_object() == nullptr;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = left->get_validated_object() == nullptr;
|
VariantInternalAccessor<bool>::get(r_ret) = left->get_validated_object() == nullptr;
|
||||||
}
|
}
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
////
|
////
|
||||||
|
|
@ -1327,15 +1111,8 @@ template <typename Left, typename Right>
|
||||||
class OperatorEvaluatorInStringFind;
|
class OperatorEvaluatorInStringFind;
|
||||||
|
|
||||||
template <typename Left>
|
template <typename Left>
|
||||||
class OperatorEvaluatorInStringFind<Left, String> {
|
class OperatorEvaluatorInStringFind<Left, String> : public CommonEvaluate<OperatorEvaluatorInStringFind<Left, String>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Left &str_a = VariantInternalAccessor<Left>::get(&p_left);
|
|
||||||
const String &str_b = VariantInternalAccessor<String>::get(&p_right);
|
|
||||||
|
|
||||||
*r_ret = str_b.find(str_a) != -1;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Left &str_a = VariantInternalAccessor<Left>::get(left);
|
const Left &str_a = VariantInternalAccessor<Left>::get(left);
|
||||||
const String &str_b = VariantInternalAccessor<String>::get(right);
|
const String &str_b = VariantInternalAccessor<String>::get(right);
|
||||||
|
|
@ -1344,19 +1121,12 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<String>::convert(right).find(PtrToArg<Left>::convert(left)) != -1, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<String>::convert(right).find(PtrToArg<Left>::convert(left)) != -1, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename Left>
|
template <typename Left>
|
||||||
class OperatorEvaluatorInStringFind<Left, StringName> {
|
class OperatorEvaluatorInStringFind<Left, StringName> : public CommonEvaluate<OperatorEvaluatorInStringFind<Left, StringName>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Left &str_a = VariantInternalAccessor<Left>::get(&p_left);
|
|
||||||
const String str_b = VariantInternalAccessor<StringName>::get(&p_right).operator String();
|
|
||||||
|
|
||||||
*r_ret = str_b.find(str_a) != -1;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Left &str_a = VariantInternalAccessor<Left>::get(left);
|
const Left &str_a = VariantInternalAccessor<Left>::get(left);
|
||||||
const String str_b = VariantInternalAccessor<StringName>::get(right).operator String();
|
const String str_b = VariantInternalAccessor<StringName>::get(right).operator String();
|
||||||
|
|
@ -1365,19 +1135,12 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<StringName>::convert(right).operator String().find(PtrToArg<Left>::convert(left)) != -1, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<StringName>::convert(right).operator String().find(PtrToArg<Left>::convert(left)) != -1, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A, typename B>
|
template <typename A, typename B>
|
||||||
class OperatorEvaluatorInArrayFind {
|
class OperatorEvaluatorInArrayFind : public CommonEvaluate<OperatorEvaluatorInArrayFind<A, B>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
const B &b = VariantInternalAccessor<B>::get(&p_right);
|
|
||||||
|
|
||||||
*r_ret = b.find(a) != -1;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const A &a = VariantInternalAccessor<A>::get(left);
|
const A &a = VariantInternalAccessor<A>::get(left);
|
||||||
const B &b = VariantInternalAccessor<B>::get(right);
|
const B &b = VariantInternalAccessor<B>::get(right);
|
||||||
|
|
@ -1386,16 +1149,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<B>::convert(right).find(PtrToArg<A>::convert(left)) != -1, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<B>::convert(right).find(PtrToArg<A>::convert(left)) != -1, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorInArrayFindNil {
|
class OperatorEvaluatorInArrayFindNil : public CommonEvaluate<OperatorEvaluatorInArrayFindNil> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Array &b = VariantInternalAccessor<Array>::get(&p_right);
|
|
||||||
*r_ret = b.find(Variant()) != -1;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Array &b = VariantInternalAccessor<Array>::get(right);
|
const Array &b = VariantInternalAccessor<Array>::get(right);
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = b.find(Variant()) != -1;
|
VariantInternalAccessor<bool>::get(r_ret) = b.find(Variant()) != -1;
|
||||||
|
|
@ -1403,16 +1161,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(Variant()) != -1, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(Variant()) != -1, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorInArrayFindObject {
|
class OperatorEvaluatorInArrayFindObject : public CommonEvaluate<OperatorEvaluatorInArrayFindObject> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Array &b = VariantInternalAccessor<Array>::get(&p_right);
|
|
||||||
*r_ret = b.find(p_left) != -1;
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Array &b = VariantInternalAccessor<Array>::get(right);
|
const Array &b = VariantInternalAccessor<Array>::get(right);
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = b.find(*left) != -1;
|
VariantInternalAccessor<bool>::get(r_ret) = b.find(*left) != -1;
|
||||||
|
|
@ -1420,19 +1173,12 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(PtrToArg<Object *>::convert(left)) != -1, r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(PtrToArg<Object *>::convert(left)) != -1, r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename A>
|
template <typename A>
|
||||||
class OperatorEvaluatorInDictionaryHas {
|
class OperatorEvaluatorInDictionaryHas : public CommonEvaluate<OperatorEvaluatorInDictionaryHas<A>> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(&p_right);
|
|
||||||
const A &a = VariantInternalAccessor<A>::get(&p_left);
|
|
||||||
|
|
||||||
*r_ret = b.has(a);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
|
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
|
||||||
const A &a = VariantInternalAccessor<A>::get(left);
|
const A &a = VariantInternalAccessor<A>::get(left);
|
||||||
|
|
@ -1441,17 +1187,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<A>::convert(left)), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<A>::convert(left)), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorInDictionaryHasNil {
|
class OperatorEvaluatorInDictionaryHasNil : public CommonEvaluate<OperatorEvaluatorInDictionaryHasNil> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(&p_right);
|
|
||||||
|
|
||||||
*r_ret = b.has(Variant());
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
|
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = b.has(Variant());
|
VariantInternalAccessor<bool>::get(r_ret) = b.has(Variant());
|
||||||
|
|
@ -1459,17 +1199,11 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(Variant()), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(Variant()), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorInDictionaryHasObject {
|
class OperatorEvaluatorInDictionaryHasObject : public CommonEvaluate<OperatorEvaluatorInDictionaryHasObject> {
|
||||||
public:
|
public:
|
||||||
static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
|
|
||||||
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(&p_right);
|
|
||||||
|
|
||||||
*r_ret = b.has(p_left);
|
|
||||||
r_valid = true;
|
|
||||||
}
|
|
||||||
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
|
||||||
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
|
const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
|
||||||
VariantInternalAccessor<bool>::get(r_ret) = b.has(*left);
|
VariantInternalAccessor<bool>::get(r_ret) = b.has(*left);
|
||||||
|
|
@ -1477,7 +1211,7 @@ public:
|
||||||
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
|
||||||
PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<Object *>::convert(left)), r_ret);
|
PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<Object *>::convert(left)), r_ret);
|
||||||
}
|
}
|
||||||
static Variant::Type get_return_type() { return Variant::BOOL; }
|
using ReturnType = bool;
|
||||||
};
|
};
|
||||||
|
|
||||||
class OperatorEvaluatorObjectHasPropertyString {
|
class OperatorEvaluatorObjectHasPropertyString {
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue