diff options
Diffstat (limited to 'core/variant_op.cpp')
| -rw-r--r-- | core/variant_op.cpp | 848 |
1 files changed, 425 insertions, 423 deletions
diff --git a/core/variant_op.cpp b/core/variant_op.cpp index f173c88054..0c9a4a992a 100644 --- a/core/variant_op.cpp +++ b/core/variant_op.cpp @@ -78,43 +78,44 @@ #define TYPE(PREFIX, OP, TYPE) &&PREFIX##_##OP##_##TYPE /* clang-format off */ -#define TYPES(PREFIX, OP) { \ - TYPE(PREFIX, OP, NIL), \ - TYPE(PREFIX, OP, BOOL), \ - TYPE(PREFIX, OP, INT), \ - TYPE(PREFIX, OP, FLOAT), \ - TYPE(PREFIX, OP, STRING), \ - TYPE(PREFIX, OP, VECTOR2), \ - TYPE(PREFIX, OP, VECTOR2I), \ - TYPE(PREFIX, OP, RECT2), \ - TYPE(PREFIX, OP, RECT2I), \ - TYPE(PREFIX, OP, VECTOR3), \ - TYPE(PREFIX, OP, VECTOR3I), \ - TYPE(PREFIX, OP, TRANSFORM2D), \ - TYPE(PREFIX, OP, PLANE), \ - TYPE(PREFIX, OP, QUAT), \ - TYPE(PREFIX, OP, AABB), \ - TYPE(PREFIX, OP, BASIS), \ - TYPE(PREFIX, OP, TRANSFORM), \ - TYPE(PREFIX, OP, COLOR), \ +#define TYPES(PREFIX, OP) { \ + TYPE(PREFIX, OP, NIL), \ + TYPE(PREFIX, OP, BOOL), \ + TYPE(PREFIX, OP, INT), \ + TYPE(PREFIX, OP, FLOAT), \ + TYPE(PREFIX, OP, STRING), \ + TYPE(PREFIX, OP, VECTOR2), \ + TYPE(PREFIX, OP, VECTOR2I), \ + TYPE(PREFIX, OP, RECT2), \ + TYPE(PREFIX, OP, RECT2I), \ + TYPE(PREFIX, OP, VECTOR3), \ + TYPE(PREFIX, OP, VECTOR3I), \ + TYPE(PREFIX, OP, TRANSFORM2D), \ + TYPE(PREFIX, OP, PLANE), \ + TYPE(PREFIX, OP, QUAT), \ + TYPE(PREFIX, OP, AABB), \ + TYPE(PREFIX, OP, BASIS), \ + TYPE(PREFIX, OP, TRANSFORM), \ + TYPE(PREFIX, OP, COLOR), \ TYPE(PREFIX, OP, STRING_NAME), \ - TYPE(PREFIX, OP, NODE_PATH), \ - TYPE(PREFIX, OP, _RID), \ - TYPE(PREFIX, OP, OBJECT), \ + TYPE(PREFIX, OP, NODE_PATH), \ + TYPE(PREFIX, OP, _RID), \ + TYPE(PREFIX, OP, OBJECT), \ TYPE(PREFIX, OP, CALLABLE), \ - TYPE(PREFIX, OP, SIGNAL), \ - TYPE(PREFIX, OP, DICTIONARY), \ - TYPE(PREFIX, OP, ARRAY), \ + TYPE(PREFIX, OP, SIGNAL), \ + TYPE(PREFIX, OP, DICTIONARY), \ + TYPE(PREFIX, OP, ARRAY), \ TYPE(PREFIX, OP, PACKED_BYTE_ARRAY), \ - TYPE(PREFIX, OP, PACKED_INT32_ARRAY), \ - TYPE(PREFIX, OP, PACKED_INT64_ARRAY), \ - TYPE(PREFIX, OP, PACKED_FLOAT32_ARRAY), \ - TYPE(PREFIX, OP, PACKED_FLOAT64_ARRAY), \ + TYPE(PREFIX, OP, PACKED_INT32_ARRAY), \ + TYPE(PREFIX, OP, PACKED_INT64_ARRAY), \ + TYPE(PREFIX, OP, PACKED_FLOAT32_ARRAY), \ + TYPE(PREFIX, OP, PACKED_FLOAT64_ARRAY), \ TYPE(PREFIX, OP, PACKED_STRING_ARRAY), \ TYPE(PREFIX, OP, PACKED_VECTOR2_ARRAY), \ TYPE(PREFIX, OP, PACKED_VECTOR3_ARRAY), \ TYPE(PREFIX, OP, PACKED_COLOR_ARRAY), \ } + /* clang-format on */ #define CASES(PREFIX) static const void *switch_table_##PREFIX[25][Variant::VARIANT_MAX] = { \ @@ -159,7 +160,6 @@ #endif Variant::operator bool() const { - return booleanize(); } @@ -181,22 +181,27 @@ bool Variant::booleanize() const { return; \ } -#define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \ - if (p_b.type == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \ - \ - _RETURN_FAIL \ - }; - -#define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \ - if (p_b.type == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \ - if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \ - \ - _RETURN_FAIL \ - }; +#define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type m_op p_b._data._int); \ + if (p_b.type == FLOAT) \ + _RETURN(p_a._data.m_type m_op p_b._data._float); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type m_op p_b._data._int); \ + if (p_b.type == FLOAT) \ + _RETURN(p_a._data.m_type m_op p_b._data._float); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + } #ifdef DEBUG_ENABLED #define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \ @@ -217,84 +222,108 @@ bool Variant::booleanize() const { } \ \ _RETURN_FAIL \ - }; + } #else -#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == INT) _RETURN(p_a._data.m_type / p_b._data._int); \ - if (p_b.type == FLOAT) _RETURN(p_a._data.m_type / p_b._data._float); \ - \ - _RETURN_FAIL \ - }; +#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type / p_b._data._int); \ + if (p_b.type == FLOAT) \ + _RETURN(p_a._data.m_type / p_b._data._float); \ + \ + _RETURN_FAIL \ + } #endif #define DEFAULT_OP_NUM_NEG(m_prefix, m_op_name, m_name, m_type) \ CASE_TYPE(m_prefix, m_op_name, m_name) { \ _RETURN(-p_a._data.m_type); \ - }; + } #define DEFAULT_OP_NUM_POS(m_prefix, m_op_name, m_name, m_type) \ CASE_TYPE(m_prefix, m_op_name, m_name) { \ _RETURN(p_a._data.m_type); \ - }; - -#define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \ - if (p_b.type == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \ - if (p_b.type == VECTOR2) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \ - if (p_b.type == VECTOR3) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \ - if (p_b.type == VECTOR2I) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \ - if (p_b.type == VECTOR3I) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \ - \ - _RETURN_FAIL \ - }; - -#define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const String *>(p_a._data._mem)); \ - if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const StringName *>(p_a._data._mem)); \ - if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const NodePath *>(p_a._data._mem)); \ - \ - _RETURN_FAIL \ - }; - -#define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ - if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \ - if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \ - \ - _RETURN_FAIL \ - }; - -#define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ - if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \ - if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \ - if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \ - \ - _RETURN_FAIL \ - }; - -#define DEFAULT_OP_STR_NULL_NP(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ - if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \ - if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \ - \ - _RETURN_FAIL \ - }; - -#define DEFAULT_OP_STR_NULL_SN(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ - if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \ - if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \ - \ - _RETURN_FAIL \ - }; + } + +#define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type m_op p_b._data._int); \ + if (p_b.type == FLOAT) \ + _RETURN(p_a._data.m_type m_op p_b._data._float); \ + if (p_b.type == VECTOR2) \ + _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \ + if (p_b.type == VECTOR3) \ + _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \ + if (p_b.type == VECTOR2I) \ + _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \ + if (p_b.type == VECTOR3I) \ + _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const String *>(p_a._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const StringName *>(p_a._data._mem)); \ + if (p_b.type == NODE_PATH) \ + _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const NodePath *>(p_a._data._mem)); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \ + if (p_b.type == NODE_PATH) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \ + if (p_b.type == NODE_PATH) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_STR_NULL_NP(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ + if (p_b.type == NODE_PATH) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_STR_NULL_SN(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + } #define DEFAULT_OP_LOCALMEM_REV(m_prefix, m_op_name, m_name, m_op, m_type) \ CASE_TYPE(m_prefix, m_op_name, m_name) { \ @@ -302,7 +331,7 @@ bool Variant::booleanize() const { _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const m_type *>(p_a._data._mem)); \ \ _RETURN_FAIL \ - }; + } #define DEFAULT_OP_LOCALMEM(m_prefix, m_op_name, m_name, m_op, m_type) \ CASE_TYPE(m_prefix, m_op_name, m_name) { \ @@ -310,7 +339,7 @@ bool Variant::booleanize() const { _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \ \ _RETURN_FAIL \ - }; + } #define DEFAULT_OP_LOCALMEM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ CASE_TYPE(m_prefix, m_op_name, m_name) { \ @@ -320,7 +349,7 @@ bool Variant::booleanize() const { _RETURN(!(p_b.type m_op NIL)); \ \ _RETURN_FAIL \ - }; + } #define DEFAULT_OP_LOCALMEM_NEG(m_prefix, m_op_name, m_name, m_type) \ CASE_TYPE(m_prefix, m_op_name, m_name) { \ @@ -332,13 +361,16 @@ bool Variant::booleanize() const { _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem)); \ } -#define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \ - CASE_TYPE(m_prefix, m_op_name, m_name) { \ - if (p_b.type == m_name) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \ - if (p_b.type == INT) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._int); \ - if (p_b.type == FLOAT) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._float); \ - \ - _RETURN_FAIL \ +#define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \ + if (p_b.type == INT) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._int); \ + if (p_b.type == FLOAT) \ + _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._float); \ + \ + _RETURN_FAIL \ } #define DEFAULT_OP_PTR(m_op, m_name, m_sub) \ @@ -403,7 +435,6 @@ bool Variant::booleanize() const { if (a_len m_opa array_b.size()) { \ _RETURN(m_ret_s); \ } else { \ - \ const m_type *ra = array_a.ptr(); \ const m_type *rb = array_b.ptr(); \ \ @@ -429,14 +460,14 @@ bool Variant::booleanize() const { void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b, Variant &r_ret, bool &r_valid) { - CASES(math); r_valid = true; SWITCH(math, p_op, p_a.type) { SWITCH_OP(math, OP_EQUAL, p_a.type) { CASE_TYPE(math, OP_EQUAL, NIL) { - if (p_b.type == NIL) _RETURN(true); + if (p_b.type == NIL) + _RETURN(true); if (p_b.type == OBJECT) _RETURN(p_b._get_obj().obj == nullptr); @@ -532,7 +563,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, SWITCH_OP(math, OP_NOT_EQUAL, p_a.type) { CASE_TYPE(math, OP_NOT_EQUAL, NIL) { - if (p_b.type == NIL) _RETURN(false); + if (p_b.type == NIL) + _RETURN(false); if (p_b.type == OBJECT) _RETURN(p_b._get_obj().obj != nullptr); @@ -884,10 +916,12 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, int asize = array_a.size(); int bsize = array_b.size(); sum.resize(asize + bsize); - for (int i = 0; i < asize; i++) + for (int i = 0; i < asize; i++) { sum[i] = array_a[i]; - for (int i = 0; i < bsize; i++) + } + for (int i = 0; i < bsize; i++) { sum[i + asize] = array_b[i]; + } _RETURN(sum); } @@ -981,7 +1015,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, case VECTOR2: { _RETURN(p_a._data._transform2d->xform(*(const Vector2 *)p_b._data._mem)); } - default: _RETURN_FAIL; + default: + _RETURN_FAIL; } } @@ -996,7 +1031,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, case FLOAT: { _RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * p_b._data._float); } - default: _RETURN_FAIL; + default: + _RETURN_FAIL; } } @@ -1008,7 +1044,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, case BASIS: { _RETURN(*p_a._data._basis * *p_b._data._basis); } - default: _RETURN_FAIL; + default: + _RETURN_FAIL; } } @@ -1020,7 +1057,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, case TRANSFORM: { _RETURN(*p_a._data._transform * *p_b._data._transform); } - default: _RETURN_FAIL; + default: + _RETURN_FAIL; } } @@ -1380,7 +1418,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, } void Variant::set_named(const StringName &p_index, const Variant &p_value, bool *r_valid) { - bool valid = false; switch (type) { case VECTOR2: { @@ -1428,7 +1465,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } break; case RECT2: { - if (p_value.type == Variant::VECTOR2) { Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem); //scalar name @@ -1445,7 +1481,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } } break; case RECT2I: { - if (p_value.type == Variant::VECTOR2I) { Rect2i *v = reinterpret_cast<Rect2i *>(_data._mem); //scalar name @@ -1462,7 +1497,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } } break; case TRANSFORM2D: { - if (p_value.type == Variant::VECTOR2) { Transform2D *v = _data._transform2d; if (p_index == CoreStringNames::singleton->x) { @@ -1479,7 +1513,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } break; case VECTOR3: { - if (p_value.type == Variant::INT) { Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { @@ -1508,7 +1541,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } break; case VECTOR3I: { - if (p_value.type == Variant::INT) { Vector3i *v = reinterpret_cast<Vector3i *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { @@ -1537,7 +1569,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } break; case PLANE: { - if (p_value.type == Variant::INT) { Plane *v = reinterpret_cast<Plane *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { @@ -1579,7 +1610,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } break; case QUAT: { - if (p_value.type == Variant::INT) { Quat *v = reinterpret_cast<Quat *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { @@ -1614,7 +1644,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } break; case AABB: { - if (p_value.type == Variant::VECTOR3) { ::AABB *v = _data._aabb; //scalar name @@ -1631,7 +1660,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } } break; case BASIS: { - if (p_value.type == Variant::VECTOR3) { Basis *v = _data._basis; //scalar name @@ -1648,7 +1676,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } } break; case TRANSFORM: { - if (p_value.type == Variant::BASIS && p_index == CoreStringNames::singleton->basis) { _data._transform->basis = *p_value._data._basis; valid = true; @@ -1659,7 +1686,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } break; case COLOR: { - if (p_value.type == Variant::INT) { Color *v = reinterpret_cast<Color *>(_data._mem); if (p_index == CoreStringNames::singleton->r) { @@ -1735,7 +1761,6 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } } break; case OBJECT: { - #ifdef DEBUG_ENABLED if (!_get_obj().obj) { break; @@ -1758,10 +1783,10 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool } Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { - if (r_valid) { *r_valid = true; } + switch (type) { case VECTOR2: { const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem); @@ -1782,7 +1807,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case RECT2: { - const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem); //scalar name if (p_index == CoreStringNames::singleton->position) { @@ -1794,7 +1818,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } } break; case RECT2I: { - const Rect2i *v = reinterpret_cast<const Rect2i *>(_data._mem); //scalar name if (p_index == CoreStringNames::singleton->position) { @@ -1806,7 +1829,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } } break; case TRANSFORM2D: { - const Transform2D *v = _data._transform2d; if (p_index == CoreStringNames::singleton->x) { return v->elements[0]; @@ -1818,7 +1840,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case VECTOR3: { - const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { return v->x; @@ -1830,7 +1851,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case VECTOR3I: { - const Vector3i *v = reinterpret_cast<const Vector3i *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { return v->x; @@ -1842,7 +1862,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case PLANE: { - const Plane *v = reinterpret_cast<const Plane *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { return v->normal.x; @@ -1858,7 +1877,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case QUAT: { - const Quat *v = reinterpret_cast<const Quat *>(_data._mem); if (p_index == CoreStringNames::singleton->x) { return v->x; @@ -1872,7 +1890,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case AABB: { - const ::AABB *v = _data._aabb; //scalar name if (p_index == CoreStringNames::singleton->position) { @@ -1884,7 +1901,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } } break; case BASIS: { - const Basis *v = _data._basis; //scalar name if (p_index == CoreStringNames::singleton->x) { @@ -1897,7 +1913,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case TRANSFORM: { - if (p_index == CoreStringNames::singleton->basis) { return _data._transform->basis; } else if (p_index == CoreStringNames::singleton->origin) { @@ -1906,7 +1921,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; case COLOR: { - const Color *v = reinterpret_cast<const Color *>(_data._mem); if (p_index == CoreStringNames::singleton->r) { return v->r; @@ -1933,17 +1947,17 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } } break; case OBJECT: { - #ifdef DEBUG_ENABLED if (!_get_obj().obj) { - if (r_valid) + if (r_valid) { *r_valid = false; + } return "Instance base is null."; } else { - if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) { - if (r_valid) + if (r_valid) { *r_valid = false; + } return "Attempted use of stray pointer object."; } } @@ -1983,7 +1997,8 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { #define DEFAULT_OP_DVECTOR_SET(m_name, m_type, skip_cond) \ case m_name: { \ - if (skip_cond) return; \ + if (skip_cond) \ + return; \ \ if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { \ int index = p_index; \ @@ -2000,7 +2015,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { #define DEFAULT_OP_DVECTOR_GET(m_name, m_type) \ case m_name: { \ - \ if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { \ int index = p_index; \ const Vector<m_type> *arr = &PackedArrayRef<m_type>::get_array(_data.packed_array); \ @@ -2015,7 +2029,6 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { } break; void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) { - static bool _dummy = false; bool &valid = r_valid ? *r_valid : _dummy; @@ -2035,24 +2048,24 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) return; } break; case STRING: { - - if (p_index.type != Variant::INT && p_index.type != Variant::FLOAT) + if (p_index.type != Variant::INT && p_index.type != Variant::FLOAT) { return; + } int idx = p_index; String *str = reinterpret_cast<String *>(_data._mem); int len = str->length(); - if (idx < 0) + if (idx < 0) { idx += len; - if (idx < 0 || idx >= len) + } + if (idx < 0 || idx >= len) { return; + } String chr; if (p_value.type == Variant::INT || p_value.type == Variant::FLOAT) { - chr = String::chr(p_value); } else if (p_value.type == Variant::STRING) { - chr = p_value; } else { return; @@ -2064,18 +2077,18 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case VECTOR2: { - - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { // scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 2; + } if (idx >= 0 && idx < 2) { - Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem); valid = true; (*v)[idx] = p_value; @@ -2099,18 +2112,18 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case VECTOR2I: { - - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { // scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 2; + } if (idx >= 0 && idx < 2) { - Vector2i *v = reinterpret_cast<Vector2i *>(_data._mem); valid = true; (*v)[idx] = p_value; @@ -2134,9 +2147,9 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case RECT2: { - - if (p_value.type != Variant::VECTOR2) + if (p_value.type != Variant::VECTOR2) { return; + } if (p_index.get_type() == Variant::STRING) { //scalar name @@ -2159,9 +2172,9 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } } break; case RECT2I: { - - if (p_value.type != Variant::VECTOR2I) + if (p_value.type != Variant::VECTOR2I) { return; + } if (p_index.get_type() == Variant::STRING) { //scalar name @@ -2184,16 +2197,16 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } } break; case TRANSFORM2D: { - - if (p_value.type != Variant::VECTOR2) + if (p_value.type != Variant::VECTOR2) { return; + } if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int index = p_index; - if (index < 0) + if (index < 0) { index += 3; + } if (index >= 0 && index < 3) { Transform2D *v = _data._transform2d; @@ -2202,7 +2215,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) return; } } else if (p_index.get_type() == Variant::STRING && p_value.get_type() == Variant::VECTOR2) { - //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); Transform2D *v = _data._transform2d; @@ -2223,24 +2235,23 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case VECTOR3: { - - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { //scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 3; + } if (idx >= 0 && idx < 3) { - Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem); valid = true; (*v)[idx] = p_value; return; } } else if (p_index.get_type() == Variant::STRING) { - //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem); @@ -2261,24 +2272,23 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case VECTOR3I: { - - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { //scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 3; + } if (idx >= 0 && idx < 3) { - Vector3i *v = reinterpret_cast<Vector3i *>(_data._mem); valid = true; (*v)[idx] = p_value; return; } } else if (p_index.get_type() == Variant::STRING) { - //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); Vector3i *v = reinterpret_cast<Vector3i *>(_data._mem); @@ -2299,35 +2309,38 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case PLANE: { - if (p_index.get_type() == Variant::STRING) { //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); Plane *v = reinterpret_cast<Plane *>(_data._mem); if (*str == "x") { - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } valid = true; v->normal.x = p_value; return; } else if (*str == "y") { - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } valid = true; v->normal.y = p_value; return; } else if (*str == "z") { - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } valid = true; v->normal.z = p_value; return; } else if (*str == "normal") { - if (p_value.type != Variant::VECTOR3) + if (p_value.type != Variant::VECTOR3) { return; + } valid = true; v->normal = p_value; @@ -2341,12 +2354,11 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case QUAT: { - - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } if (p_index.get_type() == Variant::STRING) { - const String *str = reinterpret_cast<const String *>(p_index._data._mem); Quat *v = reinterpret_cast<Quat *>(_data._mem); if (*str == "x") { @@ -2370,9 +2382,9 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case AABB: { - - if (p_value.type != Variant::VECTOR3) + if (p_value.type != Variant::VECTOR3) { return; + } if (p_index.get_type() == Variant::STRING) { //scalar name @@ -2395,16 +2407,16 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } } break; case BASIS: { - - if (p_value.type != Variant::VECTOR3) + if (p_value.type != Variant::VECTOR3) { return; + } if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int index = p_index; - if (index < 0) + if (index < 0) { index += 3; + } if (index >= 0 && index < 3) { Basis *v = _data._basis; @@ -2413,7 +2425,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) return; } } else if (p_index.get_type() == Variant::STRING) { - const String *str = reinterpret_cast<const String *>(p_index._data._mem); Basis *v = _data._basis; @@ -2434,41 +2445,42 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case TRANSFORM: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - - if (p_value.type != Variant::VECTOR3) + if (p_value.type != Variant::VECTOR3) { return; + } int index = p_index; - if (index < 0) + if (index < 0) { index += 4; + } if (index >= 0 && index < 4) { Transform *v = _data._transform; valid = true; - if (index == 3) + if (index == 3) { v->origin = p_value; - else + } else { v->basis.set_axis(index, p_value); + } return; } } else if (p_index.get_type() == Variant::STRING) { - Transform *v = _data._transform; const String *str = reinterpret_cast<const String *>(p_index._data._mem); if (*str == "basis") { - - if (p_value.type != Variant::BASIS) + if (p_value.type != Variant::BASIS) { return; + } valid = true; v->basis = p_value; return; } if (*str == "origin") { - if (p_value.type != Variant::VECTOR3) + if (p_value.type != Variant::VECTOR3) { return; + } valid = true; v->origin = p_value; return; @@ -2477,12 +2489,11 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } break; case COLOR: { - - if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) + if (p_value.type != Variant::INT && p_value.type != Variant::FLOAT) { return; + } if (p_index.get_type() == Variant::STRING) { - const String *str = reinterpret_cast<const String *>(p_index._data._mem); Color *v = reinterpret_cast<Color *>(_data._mem); if (*str == "r") { @@ -2531,10 +2542,10 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) return; } } else if (p_index.get_type() == Variant::INT) { - int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 4; + } if (idx >= 0 && idx < 4) { Color *v = reinterpret_cast<Color *>(_data._mem); (*v)[idx] = p_value; @@ -2550,14 +2561,12 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) case _RID: { } break; case OBJECT: { - Object *obj = _get_obj().obj; //only if debugging! if (obj) { #ifdef DEBUG_ENABLED if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) { - WARN_PRINT("Attempted use of previously freed pointer object."); valid = false; return; @@ -2574,7 +2583,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } } break; case DICTIONARY: { - Dictionary *dic = reinterpret_cast<Dictionary *>(_data._mem); dic->operator[](p_index) = p_value; valid = true; //always valid, i guess? should this really be ok? @@ -2596,7 +2604,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } Variant Variant::get(const Variant &p_index, bool *r_valid) const { - static bool _dummy = false; bool &valid = r_valid ? *r_valid : _dummy; @@ -2617,16 +2624,15 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { return Variant(); } break; case STRING: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { //string index int idx = p_index; const String *str = reinterpret_cast<const String *>(_data._mem); - if (idx < 0) + if (idx < 0) { idx += str->length(); + } if (idx >= 0 && idx < str->length()) { - valid = true; return str->substr(idx, 1); } @@ -2634,14 +2640,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case VECTOR2: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { // scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 2; + } if (idx >= 0 && idx < 2) { - const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem); valid = true; return (*v)[idx]; @@ -2662,14 +2667,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case VECTOR2I: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { // scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 2; + } if (idx >= 0 && idx < 2) { - const Vector2i *v = reinterpret_cast<const Vector2i *>(_data._mem); valid = true; return (*v)[idx]; @@ -2690,7 +2694,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case RECT2: { - if (p_index.get_type() == Variant::STRING) { //scalar name @@ -2709,7 +2712,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } } break; case RECT2I: { - if (p_index.get_type() == Variant::STRING) { //scalar name @@ -2728,20 +2730,18 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } } break; case VECTOR3: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { //scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 3; + } if (idx >= 0 && idx < 3) { - const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem); valid = true; return (*v)[idx]; } } else if (p_index.get_type() == Variant::STRING) { - //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem); @@ -2759,20 +2759,18 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case VECTOR3I: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { //scalar index int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 3; + } if (idx >= 0 && idx < 3) { - const Vector3i *v = reinterpret_cast<const Vector3i *>(_data._mem); valid = true; return (*v)[idx]; } } else if (p_index.get_type() == Variant::STRING) { - //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); const Vector3i *v = reinterpret_cast<const Vector3i *>(_data._mem); @@ -2790,13 +2788,12 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case TRANSFORM2D: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int index = p_index; - if (index < 0) + if (index < 0) { index += 3; + } if (index >= 0 && index < 3) { const Transform2D *v = _data._transform2d; @@ -2804,7 +2801,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { return v->elements[index]; } } else if (p_index.get_type() == Variant::STRING) { - //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); const Transform2D *v = _data._transform2d; @@ -2822,7 +2818,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case PLANE: { - if (p_index.get_type() == Variant::STRING) { //scalar name const String *str = reinterpret_cast<const String *>(p_index._data._mem); @@ -2847,9 +2842,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case QUAT: { - if (p_index.get_type() == Variant::STRING) { - const String *str = reinterpret_cast<const String *>(p_index._data._mem); const Quat *v = reinterpret_cast<const Quat *>(_data._mem); if (*str == "x") { @@ -2869,7 +2862,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case AABB: { - if (p_index.get_type() == Variant::STRING) { //scalar name @@ -2888,12 +2880,11 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } } break; case BASIS: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int index = p_index; - if (index < 0) + if (index < 0) { index += 3; + } if (index >= 0 && index < 3) { const Basis *v = _data._basis; @@ -2901,7 +2892,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { return v->get_axis(index); } } else if (p_index.get_type() == Variant::STRING) { - const String *str = reinterpret_cast<const String *>(p_index._data._mem); const Basis *v = _data._basis; @@ -2919,19 +2909,17 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case TRANSFORM: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int index = p_index; - if (index < 0) + if (index < 0) { index += 4; + } if (index >= 0 && index < 4) { const Transform *v = _data._transform; valid = true; return index == 3 ? v->origin : v->basis.get_axis(index); } } else if (p_index.get_type() == Variant::STRING) { - const Transform *v = _data._transform; const String *str = reinterpret_cast<const String *>(p_index._data._mem); @@ -2947,9 +2935,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case COLOR: { - if (p_index.get_type() == Variant::STRING) { - const String *str = reinterpret_cast<const String *>(p_index._data._mem); const Color *v = reinterpret_cast<const Color *>(_data._mem); if (*str == "r") { @@ -2987,10 +2973,10 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { return (int)Math::round(v->a * 255.0); } } else if (p_index.get_type() == Variant::INT) { - int idx = p_index; - if (idx < 0) + if (idx < 0) { idx += 4; + } if (idx >= 0 && idx < 4) { const Color *v = reinterpret_cast<const Color *>(_data._mem); valid = true; @@ -3008,7 +2994,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { case OBJECT: { Object *obj = _get_obj().obj; if (obj) { - #ifdef DEBUG_ENABLED if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && ObjectDB::get_instance(_get_obj().id) == nullptr) { @@ -3026,7 +3011,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } break; case DICTIONARY: { - const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); const Variant *res = dic->getptr(p_index); if (res) { @@ -3052,14 +3036,12 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } bool Variant::in(const Variant &p_index, bool *r_valid) const { - - if (r_valid) + if (r_valid) { *r_valid = true; + } switch (type) { - case STRING: { - if (p_index.get_type() == Variant::STRING) { //string index String idx = p_index; @@ -3072,7 +3054,6 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { case OBJECT: { Object *obj = _get_obj().obj; if (obj) { - bool valid = false; #ifdef DEBUG_ENABLED @@ -3093,26 +3074,25 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { return valid; } else { - if (r_valid) + if (r_valid) { *r_valid = false; + } } return false; } break; case DICTIONARY: { - const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); return dic->has(p_index); } break; case ARRAY: { - const Array *arr = reinterpret_cast<const Array *>(_data._mem); int l = arr->size(); if (l) { for (int i = 0; i < l; i++) { - - if (evaluate(OP_EQUAL, (*arr)[i], p_index)) + if (evaluate(OP_EQUAL, (*arr)[i], p_index)) { return true; + } } } @@ -3121,15 +3101,15 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; case PACKED_BYTE_ARRAY: { if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int index = p_index; const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array); int l = arr->size(); if (l) { const uint8_t *r = arr->ptr(); for (int i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3139,15 +3119,15 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; case PACKED_INT32_ARRAY: { if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int32_t index = p_index; const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array); int32_t l = arr->size(); if (l) { const int32_t *r = arr->ptr(); for (int32_t i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3156,15 +3136,15 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; case PACKED_INT64_ARRAY: { if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - int64_t index = p_index; const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array); int64_t l = arr->size(); if (l) { const int64_t *r = arr->ptr(); for (int64_t i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3172,17 +3152,16 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } } break; case PACKED_FLOAT32_ARRAY: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - real_t index = p_index; const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array); int l = arr->size(); if (l) { const float *r = arr->ptr(); for (int i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3191,17 +3170,16 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; case PACKED_FLOAT64_ARRAY: { - if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { - real_t index = p_index; const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array); int l = arr->size(); if (l) { const double *r = arr->ptr(); for (int i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3211,7 +3189,6 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; case PACKED_STRING_ARRAY: { if (p_index.get_type() == Variant::STRING) { - String index = p_index; const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array); @@ -3219,8 +3196,9 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { if (l) { const String *r = arr->ptr(); for (int i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3230,7 +3208,6 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; //25 case PACKED_VECTOR2_ARRAY: { if (p_index.get_type() == Variant::VECTOR2) { - Vector2 index = p_index; const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array); @@ -3238,8 +3215,9 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { if (l) { const Vector2 *r = arr->ptr(); for (int i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3249,7 +3227,6 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; case PACKED_VECTOR3_ARRAY: { if (p_index.get_type() == Variant::VECTOR3) { - Vector3 index = p_index; const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array); @@ -3257,8 +3234,9 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { if (l) { const Vector3 *r = arr->ptr(); for (int i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3267,9 +3245,7 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } break; case PACKED_COLOR_ARRAY: { - if (p_index.get_type() == Variant::COLOR) { - Color index = p_index; const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array); @@ -3277,8 +3253,9 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { if (l) { const Color *r = arr->ptr(); for (int i = 0; i < l; i++) { - if (r[i] == index) + if (r[i] == index) { return true; + } } } @@ -3289,63 +3266,55 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } } - if (r_valid) + if (r_valid) { *r_valid = false; + } return false; } void Variant::get_property_list(List<PropertyInfo> *p_list) const { - switch (type) { case VECTOR2: { - p_list->push_back(PropertyInfo(Variant::FLOAT, "x")); p_list->push_back(PropertyInfo(Variant::FLOAT, "y")); } break; case VECTOR2I: { - p_list->push_back(PropertyInfo(Variant::INT, "x")); p_list->push_back(PropertyInfo(Variant::INT, "y")); } break; case RECT2: { - p_list->push_back(PropertyInfo(Variant::VECTOR2, "position")); p_list->push_back(PropertyInfo(Variant::VECTOR2, "size")); p_list->push_back(PropertyInfo(Variant::VECTOR2, "end")); } break; case RECT2I: { - p_list->push_back(PropertyInfo(Variant::VECTOR2I, "position")); p_list->push_back(PropertyInfo(Variant::VECTOR2I, "size")); p_list->push_back(PropertyInfo(Variant::VECTOR2I, "end")); } break; case VECTOR3: { - p_list->push_back(PropertyInfo(Variant::FLOAT, "x")); p_list->push_back(PropertyInfo(Variant::FLOAT, "y")); p_list->push_back(PropertyInfo(Variant::FLOAT, "z")); } break; case VECTOR3I: { - p_list->push_back(PropertyInfo(Variant::INT, "x")); p_list->push_back(PropertyInfo(Variant::INT, "y")); p_list->push_back(PropertyInfo(Variant::INT, "z")); } break; case TRANSFORM2D: { - p_list->push_back(PropertyInfo(Variant::VECTOR2, "x")); p_list->push_back(PropertyInfo(Variant::VECTOR2, "y")); p_list->push_back(PropertyInfo(Variant::VECTOR2, "origin")); } break; case PLANE: { - p_list->push_back(PropertyInfo(Variant::VECTOR3, "normal")); p_list->push_back(PropertyInfo(Variant::FLOAT, "x")); p_list->push_back(PropertyInfo(Variant::FLOAT, "y")); @@ -3354,7 +3323,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } break; case QUAT: { - p_list->push_back(PropertyInfo(Variant::FLOAT, "x")); p_list->push_back(PropertyInfo(Variant::FLOAT, "y")); p_list->push_back(PropertyInfo(Variant::FLOAT, "z")); @@ -3367,14 +3335,12 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back(PropertyInfo(Variant::VECTOR3, "end")); } break; case BASIS: { - p_list->push_back(PropertyInfo(Variant::VECTOR3, "x")); p_list->push_back(PropertyInfo(Variant::VECTOR3, "y")); p_list->push_back(PropertyInfo(Variant::VECTOR3, "z")); } break; case TRANSFORM: { - p_list->push_back(PropertyInfo(Variant::BASIS, "basis")); p_list->push_back(PropertyInfo(Variant::VECTOR3, "origin")); @@ -3400,7 +3366,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { case _RID: { } break; case OBJECT: { - Object *obj = _get_obj().obj; if (obj) { #ifdef DEBUG_ENABLED @@ -3417,7 +3382,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } break; case DICTIONARY: { - const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); List<Variant> keys; dic->get_key_list(&keys); @@ -3437,7 +3401,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { case PACKED_VECTOR2_ARRAY: case PACKED_VECTOR3_ARRAY: case PACKED_COLOR_ARRAY: { - //nothing } break; default: { @@ -3446,7 +3409,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } bool Variant::iter_init(Variant &r_iter, bool &valid) const { - valid = true; switch (type) { case INT: { @@ -3458,17 +3420,25 @@ bool Variant::iter_init(Variant &r_iter, bool &valid) const { return _data._float > 0.0; } break; case VECTOR2: { - int64_t from = reinterpret_cast<const Vector2 *>(_data._mem)->x; - int64_t to = reinterpret_cast<const Vector2 *>(_data._mem)->y; + double from = reinterpret_cast<const Vector2 *>(_data._mem)->x; + double to = reinterpret_cast<const Vector2 *>(_data._mem)->y; + + r_iter = from; + + return from < to; + } break; + case VECTOR2I: { + int64_t from = reinterpret_cast<const Vector2i *>(_data._mem)->x; + int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y; r_iter = from; return from < to; } break; case VECTOR3: { - int64_t from = reinterpret_cast<const Vector3 *>(_data._mem)->x; - int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y; - int64_t step = reinterpret_cast<const Vector3 *>(_data._mem)->z; + double from = reinterpret_cast<const Vector3 *>(_data._mem)->x; + double to = reinterpret_cast<const Vector3 *>(_data._mem)->y; + double step = reinterpret_cast<const Vector3 *>(_data._mem)->z; r_iter = from; @@ -3476,13 +3446,24 @@ bool Variant::iter_init(Variant &r_iter, bool &valid) const { return false; } else if (from < to) { return step > 0; - } else { - return step < 0; } - //return true; + return step < 0; } break; - case OBJECT: { + case VECTOR3I: { + int64_t from = reinterpret_cast<const Vector3i *>(_data._mem)->x; + int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y; + int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z; + + r_iter = from; + if (from == to) { + return false; + } else if (from < to) { + return step > 0; + } + return step < 0; + } break; + case OBJECT: { if (!_get_obj().obj) { valid = false; return false; @@ -3514,18 +3495,18 @@ bool Variant::iter_init(Variant &r_iter, bool &valid) const { } break; case STRING: { - const String *str = reinterpret_cast<const String *>(_data._mem); - if (str->empty()) + if (str->empty()) { return false; + } r_iter = 0; return true; } break; case DICTIONARY: { - const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); - if (dic->empty()) + if (dic->empty()) { return false; + } const Variant *next = dic->next(nullptr); r_iter = *next; @@ -3533,81 +3514,87 @@ bool Variant::iter_init(Variant &r_iter, bool &valid) const { } break; case ARRAY: { - const Array *arr = reinterpret_cast<const Array *>(_data._mem); - if (arr->empty()) + if (arr->empty()) { return false; + } r_iter = 0; return true; } break; case PACKED_BYTE_ARRAY: { const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_INT32_ARRAY: { const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_INT64_ARRAY: { const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_FLOAT32_ARRAY: { const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_FLOAT64_ARRAY: { const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_STRING_ARRAY: { const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_VECTOR2_ARRAY: { - const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_VECTOR3_ARRAY: { - const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; } break; case PACKED_COLOR_ARRAY: { - const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array); - if (arr->size() == 0) + if (arr->size() == 0) { return false; + } r_iter = 0; return true; @@ -3619,56 +3606,91 @@ bool Variant::iter_init(Variant &r_iter, bool &valid) const { valid = false; return false; } -bool Variant::iter_next(Variant &r_iter, bool &valid) const { +bool Variant::iter_next(Variant &r_iter, bool &valid) const { valid = true; switch (type) { case INT: { int64_t idx = r_iter; idx++; - if (idx >= _data._int) + if (idx >= _data._int) { return false; + } r_iter = idx; return true; } break; case FLOAT: { int64_t idx = r_iter; idx++; - if (idx >= _data._float) + if (idx >= _data._float) { return false; + } r_iter = idx; return true; } break; case VECTOR2: { - int64_t to = reinterpret_cast<const Vector2 *>(_data._mem)->y; + double to = reinterpret_cast<const Vector2 *>(_data._mem)->y; + + double idx = r_iter; + idx++; + + if (idx >= to) { + return false; + } + + r_iter = idx; + return true; + } break; + case VECTOR2I: { + int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y; int64_t idx = r_iter; idx++; - if (idx >= to) + if (idx >= to) { return false; + } r_iter = idx; return true; } break; case VECTOR3: { - int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y; - int64_t step = reinterpret_cast<const Vector3 *>(_data._mem)->z; + double to = reinterpret_cast<const Vector3 *>(_data._mem)->y; + double step = reinterpret_cast<const Vector3 *>(_data._mem)->z; + + double idx = r_iter; + idx += step; + + if (step < 0 && idx <= to) { + return false; + } + + if (step > 0 && idx >= to) { + return false; + } + + r_iter = idx; + return true; + } break; + case VECTOR3I: { + int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y; + int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z; int64_t idx = r_iter; idx += step; - if (step < 0 && idx <= to) + if (step < 0 && idx <= to) { return false; + } - if (step > 0 && idx >= to) + if (step > 0 && idx >= to) { return false; + } r_iter = idx; return true; } break; case OBJECT: { - if (!_get_obj().obj) { valid = false; return false; @@ -3701,33 +3723,33 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { } break; case STRING: { - const String *str = reinterpret_cast<const String *>(_data._mem); int idx = r_iter; idx++; - if (idx >= str->length()) + if (idx >= str->length()) { return false; + } r_iter = idx; return true; } break; case DICTIONARY: { - const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); const Variant *next = dic->next(&r_iter); - if (!next) + if (!next) { return false; + } r_iter = *next; return true; } break; case ARRAY: { - const Array *arr = reinterpret_cast<const Array *>(_data._mem); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; } break; @@ -3735,8 +3757,9 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { const Vector<uint8_t> *arr = &PackedArrayRef<uint8_t>::get_array(_data.packed_array); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; @@ -3745,8 +3768,9 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { const Vector<int32_t> *arr = &PackedArrayRef<int32_t>::get_array(_data.packed_array); int32_t idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; @@ -3755,8 +3779,9 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { const Vector<int64_t> *arr = &PackedArrayRef<int64_t>::get_array(_data.packed_array); int64_t idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; @@ -3765,8 +3790,9 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { const Vector<float> *arr = &PackedArrayRef<float>::get_array(_data.packed_array); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; @@ -3775,8 +3801,9 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { const Vector<double> *arr = &PackedArrayRef<double>::get_array(_data.packed_array); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; @@ -3785,38 +3812,39 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { const Vector<String> *arr = &PackedArrayRef<String>::get_array(_data.packed_array); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; } break; case PACKED_VECTOR2_ARRAY: { - const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; } break; case PACKED_VECTOR3_ARRAY: { - const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; } break; case PACKED_COLOR_ARRAY: { - const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array); int idx = r_iter; idx++; - if (idx >= arr->size()) + if (idx >= arr->size()) { return false; + } r_iter = idx; return true; } break; @@ -3829,27 +3857,27 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const { } Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const { - r_valid = true; switch (type) { case INT: { - return r_iter; } break; case FLOAT: { - return r_iter; } break; case VECTOR2: { - + return r_iter; + } break; + case VECTOR2I: { return r_iter; } break; case VECTOR3: { - + return r_iter; + } break; + case VECTOR3I: { return r_iter; } break; case OBJECT: { - if (!_get_obj().obj) { r_valid = false; return Variant(); @@ -3877,17 +3905,14 @@ Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const { } break; case STRING: { - const String *str = reinterpret_cast<const String *>(_data._mem); return str->substr(r_iter, 1); } break; case DICTIONARY: { - return r_iter; //iterator is the same as the key } break; case ARRAY: { - const Array *arr = reinterpret_cast<const Array *>(_data._mem); int idx = r_iter; #ifdef DEBUG_ENABLED @@ -3965,7 +3990,6 @@ Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const { return arr->get(idx); } break; case PACKED_VECTOR2_ARRAY: { - const Vector<Vector2> *arr = &PackedArrayRef<Vector2>::get_array(_data.packed_array); int idx = r_iter; #ifdef DEBUG_ENABLED @@ -3977,7 +4001,6 @@ Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const { return arr->get(idx); } break; case PACKED_VECTOR3_ARRAY: { - const Vector<Vector3> *arr = &PackedArrayRef<Vector3>::get_array(_data.packed_array); int idx = r_iter; #ifdef DEBUG_ENABLED @@ -3989,7 +4012,6 @@ Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const { return arr->get(idx); } break; case PACKED_COLOR_ARRAY: { - const Vector<Color> *arr = &PackedArrayRef<Color>::get_array(_data.packed_array); int idx = r_iter; #ifdef DEBUG_ENABLED @@ -4142,7 +4164,6 @@ void Variant::blend(const Variant &a, const Variant &b, float c, Variant &r_dst) } void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst) { - if (a.type != b.type) { if (a.is_num() && b.is_num()) { //not as efficient but.. @@ -4157,7 +4178,6 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & } switch (a.type) { - case NIL: { r_dst = Variant(); } @@ -4195,22 +4215,21 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & int split = csize / 2; for (int i = 0; i < csize; i++) { - CharType chr = ' '; if (i < split) { - - if (i < sa.length()) + if (i < sa.length()) { chr = sa[i]; - else if (i < sb.length()) + } else if (i < sb.length()) { chr = sb[i]; + } } else { - - if (i < sb.length()) + if (i < sb.length()) { chr = sb[i]; - else if (i < sa.length()) + } else if (i < sa.length()) { chr = sa[i]; + } } dst[i] = chr; @@ -4220,7 +4239,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & } return; case VECTOR2: { - r_dst = reinterpret_cast<const Vector2 *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector2 *>(b._data._mem), c); + r_dst = reinterpret_cast<const Vector2 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector2 *>(b._data._mem), c); } return; case VECTOR2I: { @@ -4233,7 +4252,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & return; case RECT2: { - r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c)); + r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c)); } return; case RECT2I: { @@ -4254,7 +4273,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & return; case VECTOR3: { - r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector3 *>(b._data._mem), c); + r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector3 *>(b._data._mem), c); } return; case VECTOR3I: { @@ -4281,7 +4300,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & } return; case AABB: { - r_dst = ::AABB(a._data._aabb->position.linear_interpolate(b._data._aabb->position, c), a._data._aabb->size.linear_interpolate(b._data._aabb->size, c)); + r_dst = ::AABB(a._data._aabb->position.lerp(b._data._aabb->position, c), a._data._aabb->size.lerp(b._data._aabb->size, c)); } return; case BASIS: { @@ -4293,7 +4312,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & } return; case COLOR: { - r_dst = reinterpret_cast<const Color *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color *>(b._data._mem), c); + r_dst = reinterpret_cast<const Color *>(a._data._mem)->lerp(*reinterpret_cast<const Color *>(b._data._mem), c); } return; case STRING_NAME: { @@ -4328,10 +4347,8 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector<int32_t> *arr_b = &PackedArrayRef<int32_t>::get_array(b._data.packed_array); int32_t sz = arr_a->size(); if (sz == 0 || arr_b->size() != sz) { - r_dst = a; } else { - Vector<int32_t> v; v.resize(sz); { @@ -4354,10 +4371,8 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector<int64_t> *arr_b = &PackedArrayRef<int64_t>::get_array(b._data.packed_array); int64_t sz = arr_a->size(); if (sz == 0 || arr_b->size() != sz) { - r_dst = a; } else { - Vector<int64_t> v; v.resize(sz); { @@ -4380,10 +4395,8 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector<float> *arr_b = &PackedArrayRef<float>::get_array(b._data.packed_array); int sz = arr_a->size(); if (sz == 0 || arr_b->size() != sz) { - r_dst = a; } else { - Vector<float> v; v.resize(sz); { @@ -4406,10 +4419,8 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector<double> *arr_b = &PackedArrayRef<double>::get_array(b._data.packed_array); int sz = arr_a->size(); if (sz == 0 || arr_b->size() != sz) { - r_dst = a; } else { - Vector<double> v; v.resize(sz); { @@ -4436,10 +4447,8 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector<Vector2> *arr_b = &PackedArrayRef<Vector2>::get_array(b._data.packed_array); int sz = arr_a->size(); if (sz == 0 || arr_b->size() != sz) { - r_dst = a; } else { - Vector<Vector2> v; v.resize(sz); { @@ -4448,7 +4457,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector2 *br = arr_b->ptr(); for (int i = 0; i < sz; i++) { - vw[i] = ar[i].linear_interpolate(br[i], c); + vw[i] = ar[i].lerp(br[i], c); } } r_dst = v; @@ -4456,15 +4465,12 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & } return; case PACKED_VECTOR3_ARRAY: { - const Vector<Vector3> *arr_a = &PackedArrayRef<Vector3>::get_array(a._data.packed_array); const Vector<Vector3> *arr_b = &PackedArrayRef<Vector3>::get_array(b._data.packed_array); int sz = arr_a->size(); if (sz == 0 || arr_b->size() != sz) { - r_dst = a; } else { - Vector<Vector3> v; v.resize(sz); { @@ -4473,7 +4479,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector3 *br = arr_b->ptr(); for (int i = 0; i < sz; i++) { - vw[i] = ar[i].linear_interpolate(br[i], c); + vw[i] = ar[i].lerp(br[i], c); } } r_dst = v; @@ -4485,10 +4491,8 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Vector<Color> *arr_b = &PackedArrayRef<Color>::get_array(b._data.packed_array); int sz = arr_a->size(); if (sz == 0 || arr_b->size() != sz) { - r_dst = a; } else { - Vector<Color> v; v.resize(sz); { @@ -4497,7 +4501,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & const Color *br = arr_b->ptr(); for (int i = 0; i < sz; i++) { - vw[i] = ar[i].linear_interpolate(br[i], c); + vw[i] = ar[i].lerp(br[i], c); } } r_dst = v; @@ -4505,7 +4509,6 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & } return; default: { - r_dst = a; } } @@ -4541,7 +4544,6 @@ static const char *_op_names[Variant::OP_MAX] = { }; String Variant::get_operator_name(Operator p_op) { - ERR_FAIL_INDEX_V(p_op, OP_MAX, ""); return _op_names[p_op]; } |