diff options
Diffstat (limited to 'core/variant_op.cpp')
| -rw-r--r-- | core/variant_op.cpp | 550 |
1 files changed, 300 insertions, 250 deletions
diff --git a/core/variant_op.cpp b/core/variant_op.cpp index fd64b58bd..1e67d81ae 100644 --- a/core/variant_op.cpp +++ b/core/variant_op.cpp @@ -5,7 +5,7 @@ /* GODOT ENGINE */ /* http://www.godotengine.org */ /*************************************************************************/ -/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ @@ -47,12 +47,12 @@ bool Variant::booleanize(bool &r_valid) const { case STRING: return (*reinterpret_cast<const String*>(_data._mem))!=""; case VECTOR2: case RECT2: - case MATRIX32: + case TRANSFORM2D: case VECTOR3: case PLANE: - case _AABB: + case RECT3: case QUAT: - case MATRIX3: + case BASIS: case TRANSFORM: case COLOR: case IMAGE: r_valid=false; return false; @@ -62,13 +62,13 @@ bool Variant::booleanize(bool &r_valid) const { case INPUT_EVENT: case DICTIONARY: case ARRAY: - case RAW_ARRAY: - case INT_ARRAY: - case REAL_ARRAY: - case STRING_ARRAY: - case VECTOR2_ARRAY: - case VECTOR3_ARRAY: - case COLOR_ARRAY: + case POOL_BYTE_ARRAY: + case POOL_INT_ARRAY: + case POOL_REAL_ARRAY: + case POOL_STRING_ARRAY: + case POOL_VECTOR2_ARRAY: + case POOL_VECTOR3_ARRAY: + case POOL_COLOR_ARRAY: r_valid=false; return false; default: {} @@ -97,6 +97,12 @@ case m_name: {\ _RETURN( -p_a._data.m_type);\ }; +#define DEFAULT_OP_NUM_POS(m_name,m_type)\ +case m_name: {\ +\ + _RETURN( p_a._data.m_type);\ +}; + #define DEFAULT_OP_NUM_VEC(m_op,m_name,m_type)\ case m_name: {\ switch(p_b.type) {\ @@ -136,6 +142,10 @@ case m_name: {\ _RETURN( -*reinterpret_cast<const m_type*>(p_a._data._mem));\ } +#define DEFAULT_OP_LOCALMEM_POS(m_name,m_type)\ +case m_name: {\ + _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem));\ +} #define DEFAULT_OP_LOCALMEM_NUM(m_op,m_name,m_type)\ case m_name: {switch(p_b.type) {\ @@ -176,16 +186,16 @@ case m_name: { \ r_valid=false;\ return;\ }\ - const DVector<m_type> &array_a=*reinterpret_cast<const DVector<m_type> *>(p_a._data._mem);\ - const DVector<m_type> &array_b=*reinterpret_cast<const DVector<m_type> *>(p_b._data._mem);\ + const PoolVector<m_type> &array_a=*reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem);\ + const PoolVector<m_type> &array_b=*reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem);\ \ int a_len = array_a.size();\ if (a_len m_opa array_b.size()){\ _RETURN( m_ret_s);\ }else {\ \ - DVector<m_type>::Read ra = array_a.read();\ - DVector<m_type>::Read rb = array_b.read();\ + PoolVector<m_type>::Read ra = array_a.read();\ + PoolVector<m_type>::Read rb = array_b.read();\ \ for(int i=0;i<a_len;i++) {\ if (ra[i] m_opb rb[i])\ @@ -202,9 +212,9 @@ case m_name: { \ r_valid=false;\ _RETURN( NIL);\ }\ - const DVector<m_type> &array_a=*reinterpret_cast<const DVector<m_type> *>(p_a._data._mem);\ - const DVector<m_type> &array_b=*reinterpret_cast<const DVector<m_type> *>(p_b._data._mem);\ - DVector<m_type> sum = array_a;\ + const PoolVector<m_type> &array_a=*reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem);\ + const PoolVector<m_type> &array_b=*reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem);\ + PoolVector<m_type> sum = array_a;\ sum.append_array(array_b);\ _RETURN( sum );\ } @@ -252,12 +262,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(==,STRING,String); DEFAULT_OP_LOCALMEM(==,VECTOR2,Vector2); DEFAULT_OP_LOCALMEM(==,RECT2,Rect2); - DEFAULT_OP_PTRREF(==,MATRIX32,_matrix32); + DEFAULT_OP_PTRREF(==,TRANSFORM2D,_transform2d); DEFAULT_OP_LOCALMEM(==,VECTOR3,Vector3); DEFAULT_OP_LOCALMEM(==,PLANE,Plane); DEFAULT_OP_LOCALMEM(==,QUAT,Quat); - DEFAULT_OP_PTRREF(==,_AABB,_aabb); - DEFAULT_OP_PTRREF(==,MATRIX3,_matrix3); + DEFAULT_OP_PTRREF(==,RECT3,_rect3); + DEFAULT_OP_PTRREF(==,BASIS,_basis); DEFAULT_OP_PTRREF(==,TRANSFORM,_transform); DEFAULT_OP_LOCALMEM(==,COLOR,Color); @@ -306,13 +316,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& } break; - DEFAULT_OP_ARRAY_EQ(RAW_ARRAY,uint8_t); - DEFAULT_OP_ARRAY_EQ(INT_ARRAY,int); - DEFAULT_OP_ARRAY_EQ(REAL_ARRAY,real_t); - DEFAULT_OP_ARRAY_EQ(STRING_ARRAY,String); - DEFAULT_OP_ARRAY_EQ(VECTOR2_ARRAY,Vector3); - DEFAULT_OP_ARRAY_EQ(VECTOR3_ARRAY,Vector3); - DEFAULT_OP_ARRAY_EQ(COLOR_ARRAY,Color); + DEFAULT_OP_ARRAY_EQ(POOL_BYTE_ARRAY,uint8_t); + DEFAULT_OP_ARRAY_EQ(POOL_INT_ARRAY,int); + DEFAULT_OP_ARRAY_EQ(POOL_REAL_ARRAY,real_t); + DEFAULT_OP_ARRAY_EQ(POOL_STRING_ARRAY,String); + DEFAULT_OP_ARRAY_EQ(POOL_VECTOR2_ARRAY,Vector3); + DEFAULT_OP_ARRAY_EQ(POOL_VECTOR3_ARRAY,Vector3); + DEFAULT_OP_ARRAY_EQ(POOL_COLOR_ARRAY,Color); case VARIANT_MAX: { r_valid=false; @@ -344,12 +354,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(<,STRING,String); DEFAULT_OP_LOCALMEM(<,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(<,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_FAIL(QUAT); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -383,13 +393,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& _RETURN( false ); } break; - DEFAULT_OP_ARRAY_LT(RAW_ARRAY,uint8_t); - DEFAULT_OP_ARRAY_LT(INT_ARRAY,int); - DEFAULT_OP_ARRAY_LT(REAL_ARRAY,real_t); - DEFAULT_OP_ARRAY_LT(STRING_ARRAY,String); - DEFAULT_OP_ARRAY_LT(VECTOR2_ARRAY,Vector3); - DEFAULT_OP_ARRAY_LT(VECTOR3_ARRAY,Vector3); - DEFAULT_OP_ARRAY_LT(COLOR_ARRAY,Color); + DEFAULT_OP_ARRAY_LT(POOL_BYTE_ARRAY,uint8_t); + DEFAULT_OP_ARRAY_LT(POOL_INT_ARRAY,int); + DEFAULT_OP_ARRAY_LT(POOL_REAL_ARRAY,real_t); + DEFAULT_OP_ARRAY_LT(POOL_STRING_ARRAY,String); + DEFAULT_OP_ARRAY_LT(POOL_VECTOR2_ARRAY,Vector3); + DEFAULT_OP_ARRAY_LT(POOL_VECTOR3_ARRAY,Vector3); + DEFAULT_OP_ARRAY_LT(POOL_COLOR_ARRAY,Color); case VARIANT_MAX: { r_valid=false; return; @@ -410,12 +420,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(<=,STRING,String); DEFAULT_OP_LOCALMEM(<=,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(<=,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_FAIL(QUAT); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -430,13 +440,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -474,12 +484,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(+,STRING,String); DEFAULT_OP_LOCALMEM(+,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(+,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_LOCALMEM(+, QUAT, Quat); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -507,13 +517,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& sum[i+asize]=array_b[i]; _RETURN( sum ); } - DEFAULT_OP_ARRAY_ADD(RAW_ARRAY,uint8_t); - DEFAULT_OP_ARRAY_ADD(INT_ARRAY,int); - DEFAULT_OP_ARRAY_ADD(REAL_ARRAY,real_t); - DEFAULT_OP_ARRAY_ADD(STRING_ARRAY,String); - DEFAULT_OP_ARRAY_ADD(VECTOR2_ARRAY,Vector2); - DEFAULT_OP_ARRAY_ADD(VECTOR3_ARRAY,Vector3); - DEFAULT_OP_ARRAY_ADD(COLOR_ARRAY,Color); + DEFAULT_OP_ARRAY_ADD(POOL_BYTE_ARRAY,uint8_t); + DEFAULT_OP_ARRAY_ADD(POOL_INT_ARRAY,int); + DEFAULT_OP_ARRAY_ADD(POOL_REAL_ARRAY,real_t); + DEFAULT_OP_ARRAY_ADD(POOL_STRING_ARRAY,String); + DEFAULT_OP_ARRAY_ADD(POOL_VECTOR2_ARRAY,Vector2); + DEFAULT_OP_ARRAY_ADD(POOL_VECTOR3_ARRAY,Vector3); + DEFAULT_OP_ARRAY_ADD(POOL_COLOR_ARRAY,Color); case VARIANT_MAX: { r_valid=false; return; @@ -532,12 +542,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM(-,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(-,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_LOCALMEM(-, QUAT, Quat); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -548,13 +558,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -573,13 +583,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM_NUM(*,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - case MATRIX32: { + case TRANSFORM2D: { - if (p_b.type==MATRIX32) { - _RETURN( *p_a._data._matrix32 * *p_b._data._matrix32 ); + if (p_b.type==TRANSFORM2D) { + _RETURN( *p_a._data._transform2d * *p_b._data._transform2d ); }; if (p_b.type==VECTOR2) { - _RETURN( p_a._data._matrix32->xform( *(const Vector2*)p_b._data._mem) ); + _RETURN( p_a._data._transform2d->xform( *(const Vector2*)p_b._data._mem) ); }; r_valid=false; return; @@ -605,18 +615,18 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& r_valid=false; return; } break; - DEFAULT_OP_FAIL(_AABB); - case MATRIX3: { + DEFAULT_OP_FAIL(RECT3); + case BASIS: { switch(p_b.type) { case VECTOR3: { - _RETURN( p_a._data._matrix3->xform( *(const Vector3*)p_b._data._mem) ); + _RETURN( p_a._data._basis->xform( *(const Vector3*)p_b._data._mem) ); } ; - case MATRIX3: { + case BASIS: { - _RETURN( *p_a._data._matrix3 * *p_b._data._matrix3 ); + _RETURN( *p_a._data._basis * *p_b._data._basis ); }; default: {} @@ -650,13 +660,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -673,7 +683,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& case INT: { switch(p_b.type) { case BOOL: { - int b = p_b._data._bool; + int64_t b = p_b._data._bool; if (b==0) { r_valid=false; @@ -683,7 +693,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& } break; case INT: { - int b = p_b._data._int; + int64_t b = p_b._data._int; if (b==0) { r_valid=false; @@ -702,7 +712,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM_NUM(/,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM_NUM(/,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); case QUAT: { @@ -712,8 +722,8 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& } _RETURN( *reinterpret_cast<const Quat*>(p_a._data._mem) / p_b._data._real); } break; - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -724,13 +734,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -740,6 +750,48 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& } } break; + case OP_POSITIVE: { + // Simple case when user defines variable as +value. + switch(p_a.type) { + + DEFAULT_OP_FAIL(NIL); + DEFAULT_OP_FAIL(STRING); + DEFAULT_OP_FAIL(RECT2); + DEFAULT_OP_FAIL(TRANSFORM2D); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); + DEFAULT_OP_FAIL(TRANSFORM); + DEFAULT_OP_NUM_POS(BOOL,_bool); + DEFAULT_OP_NUM_POS(INT,_int); + DEFAULT_OP_NUM_POS(REAL,_real); + DEFAULT_OP_LOCALMEM_POS(VECTOR3,Vector3); + DEFAULT_OP_LOCALMEM_POS(PLANE,Plane); + DEFAULT_OP_LOCALMEM_POS(QUAT,Quat); + DEFAULT_OP_LOCALMEM_POS(VECTOR2,Vector2); + + DEFAULT_OP_FAIL(COLOR); + DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); + DEFAULT_OP_FAIL(_RID); + DEFAULT_OP_FAIL(OBJECT); + DEFAULT_OP_FAIL(INPUT_EVENT); + DEFAULT_OP_FAIL(DICTIONARY); + DEFAULT_OP_FAIL(ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); + case VARIANT_MAX: { + r_valid=false; + return; + + } break; + + } + } break; case OP_NEGATE: { switch(p_a.type) { @@ -750,12 +802,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM_NEG(VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM_NEG(VECTOR3,Vector3); DEFAULT_OP_LOCALMEM_NEG(PLANE,Plane); DEFAULT_OP_LOCALMEM_NEG(QUAT,Quat); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -766,21 +818,19 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; } break; - } - } break; case OP_MODULE: { if (p_a.type==INT && p_b.type==INT) { @@ -999,10 +1049,10 @@ Variant Variant::get_named(const StringName& p_index, bool *r_valid) const { } break; #define DEFAULT_OP_DVECTOR_SET(m_name, dv_type, skip_cond)\ - DEFAULT_OP_ARRAY_CMD(m_name, DVector<dv_type>, if(skip_cond) return;, arr->set(index, p_value);return) + DEFAULT_OP_ARRAY_CMD(m_name, PoolVector<dv_type>, if(skip_cond) return;, arr->set(index, p_value);return) #define DEFAULT_OP_DVECTOR_GET(m_name, dv_type)\ - DEFAULT_OP_ARRAY_CMD(m_name, const DVector<dv_type>, ;, return arr->get(index)) + DEFAULT_OP_ARRAY_CMD(m_name, const PoolVector<dv_type>, ;, return arr->get(index)) void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) { @@ -1107,7 +1157,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } } } break; - case MATRIX32: { + case TRANSFORM2D: { if (p_value.type!=Variant::VECTOR2) return; @@ -1119,7 +1169,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) if (index<0) index += 3; if (index>=0 && index<3) { - Matrix32 *v=_data._matrix32; + Transform2D *v=_data._transform2d; valid=true; v->elements[index]=p_value; @@ -1129,7 +1179,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - Matrix32 *v=_data._matrix32; + Transform2D *v=_data._transform2d; if (*str=="x") { valid=true; v->elements[0]=p_value; @@ -1255,7 +1305,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } } break; - case _AABB: { + case RECT3: { if (p_value.type!=Variant::VECTOR3) return; @@ -1265,7 +1315,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - AABB *v=_data._aabb; + Rect3 *v=_data._rect3; if (*str=="pos") { valid=true; v->pos=p_value; @@ -1281,7 +1331,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } } } break; //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: { + case BASIS: { if (p_value.type!=Variant::VECTOR3) return; @@ -1293,7 +1343,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) if (index<0) index += 3; if (index>=0 && index<3) { - Matrix3 *v=_data._matrix3; + Basis *v=_data._basis; valid=true; v->set_axis(index,p_value); @@ -1302,7 +1352,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } else if (p_index.get_type()==Variant::STRING) { const String *str=reinterpret_cast<const String*>(p_index._data._mem); - Matrix3 *v=_data._matrix3; + Basis *v=_data._basis; if (*str=="x") { valid=true; @@ -1348,7 +1398,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) if (*str=="basis") { - if (p_value.type!=Variant::MATRIX3) + if (p_value.type!=Variant::BASIS) return; valid=true; v->basis=p_value; @@ -1694,7 +1744,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } - if (ie.type==InputEvent::JOYSTICK_BUTTON) { + if (ie.type==InputEvent::JOYPAD_BUTTON) { if (str=="button_index") { if (p_value.type!=Variant::REAL && p_value.type!=Variant::INT) @@ -1719,7 +1769,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } - if (ie.type==InputEvent::JOYSTICK_MOTION) { + if (ie.type==InputEvent::JOYPAD_MOTION) { if (str=="axis") { if (p_value.type!=Variant::REAL && p_value.type!=Variant::INT) @@ -1837,13 +1887,13 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) return; } break; // 20 DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index]=p_value;return) - DEFAULT_OP_DVECTOR_SET(RAW_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) - DEFAULT_OP_DVECTOR_SET(INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT) - DEFAULT_OP_DVECTOR_SET(REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) - DEFAULT_OP_DVECTOR_SET(STRING_ARRAY, String, p_value.type != Variant::STRING) // 25 - DEFAULT_OP_DVECTOR_SET(VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) - DEFAULT_OP_DVECTOR_SET(VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3) - DEFAULT_OP_DVECTOR_SET(COLOR_ARRAY, Color, p_value.type != Variant::COLOR) + DEFAULT_OP_DVECTOR_SET(POOL_BYTE_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING) // 25 + DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) + DEFAULT_OP_DVECTOR_SET(POOL_VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3) + DEFAULT_OP_DVECTOR_SET(POOL_COLOR_ARRAY, Color, p_value.type != Variant::COLOR) default: return; } @@ -1957,7 +2007,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } break; - case MATRIX32: { + case TRANSFORM2D: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { @@ -1966,7 +2016,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { if (index<0) index += 3; if (index>=0 && index<3) { - const Matrix32 *v=_data._matrix32; + const Transform2D *v=_data._transform2d; valid=true; return v->elements[index]; @@ -1975,7 +2025,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - const Matrix32 *v=_data._matrix32; + const Transform2D *v=_data._transform2d; if (*str=="x") { valid=true; return v->elements[0]; @@ -2036,13 +2086,13 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } break; - case _AABB: { + case RECT3: { if (p_index.get_type()==Variant::STRING) { //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - const AABB *v=_data._aabb; + const Rect3 *v=_data._rect3; if (*str=="pos") { valid=true; return v->pos; @@ -2055,7 +2105,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } } break; //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: { + case BASIS: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { @@ -2063,7 +2113,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { if (index<0) index += 3; if (index>=0 && index<3) { - const Matrix3 *v=_data._matrix3; + const Basis *v=_data._basis; valid=true; return v->get_axis(index); @@ -2071,7 +2121,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } else if (p_index.get_type()==Variant::STRING) { const String *str=reinterpret_cast<const String*>(p_index._data._mem); - const Matrix3 *v=_data._matrix3; + const Basis *v=_data._basis; if (*str=="x") { valid=true; @@ -2317,7 +2367,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } - if (ie.type==InputEvent::JOYSTICK_BUTTON) { + if (ie.type==InputEvent::JOYPAD_BUTTON) { if (str=="button_index") { valid=true; @@ -2332,7 +2382,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } - if (ie.type==InputEvent::JOYSTICK_MOTION) { + if (ie.type==InputEvent::JOYPAD_MOTION) { if (str=="axis") { valid=true; @@ -2421,13 +2471,13 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } break; // 20 DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) - DEFAULT_OP_DVECTOR_GET(RAW_ARRAY, uint8_t) - DEFAULT_OP_DVECTOR_GET(INT_ARRAY, int) - DEFAULT_OP_DVECTOR_GET(REAL_ARRAY, real_t) - DEFAULT_OP_DVECTOR_GET(STRING_ARRAY, String) - DEFAULT_OP_DVECTOR_GET(VECTOR2_ARRAY, Vector2) - DEFAULT_OP_DVECTOR_GET(VECTOR3_ARRAY, Vector3) - DEFAULT_OP_DVECTOR_GET(COLOR_ARRAY, Color) + DEFAULT_OP_DVECTOR_GET(POOL_BYTE_ARRAY, uint8_t) + DEFAULT_OP_DVECTOR_GET(POOL_INT_ARRAY, int) + DEFAULT_OP_DVECTOR_GET(POOL_REAL_ARRAY, real_t) + DEFAULT_OP_DVECTOR_GET(POOL_STRING_ARRAY, String) + DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2) + DEFAULT_OP_DVECTOR_GET(POOL_VECTOR3_ARRAY, Vector3) + DEFAULT_OP_DVECTOR_GET(POOL_COLOR_ARRAY, Color) default: return Variant(); } @@ -2507,14 +2557,14 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { return false; } break; - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { int index = p_index; - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>* >(_data._mem); + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>* >(_data._mem); int l=arr->size(); if (l) { - DVector<uint8_t>::Read r = arr->read(); + PoolVector<uint8_t>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2526,14 +2576,14 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { int index = p_index; - const DVector<int> *arr=reinterpret_cast<const DVector<int>* >(_data._mem); + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>* >(_data._mem); int l=arr->size(); if (l) { - DVector<int>::Read r = arr->read(); + PoolVector<int>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2544,15 +2594,15 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { return false; } } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { real_t index = p_index; - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>* >(_data._mem); + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>* >(_data._mem); int l=arr->size(); if (l) { - DVector<real_t>::Read r = arr->read(); + PoolVector<real_t>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2564,15 +2614,15 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { if (p_index.get_type()==Variant::STRING) { String index = p_index; - const DVector<String> *arr=reinterpret_cast<const DVector<String>* >(_data._mem); + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>* >(_data._mem); int l=arr->size(); if (l) { - DVector<String>::Read r = arr->read(); + PoolVector<String>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2584,15 +2634,15 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; //25 - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { if (p_index.get_type()==Variant::VECTOR2) { Vector2 index = p_index; - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>* >(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>* >(_data._mem); int l=arr->size(); if (l) { - DVector<Vector2>::Read r = arr->read(); + PoolVector<Vector2>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2604,15 +2654,15 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { if (p_index.get_type()==Variant::VECTOR3) { Vector3 index = p_index; - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>* >(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>* >(_data._mem); int l=arr->size(); if (l) { - DVector<Vector3>::Read r = arr->read(); + PoolVector<Vector3>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2624,17 +2674,17 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { if (p_index.get_type()==Variant::COLOR) { Color index = p_index; - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>* >(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>* >(_data._mem); int l=arr->size(); if (l) { - DVector<Color>::Read r = arr->read(); + PoolVector<Color>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2679,7 +2729,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back( PropertyInfo(Variant::REAL,"z")); } break; - case MATRIX32: { + case TRANSFORM2D: { p_list->push_back( PropertyInfo(Variant::VECTOR2,"x")); p_list->push_back( PropertyInfo(Variant::VECTOR2,"y")); @@ -2703,12 +2753,12 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back( PropertyInfo(Variant::REAL,"w")); } break; - case _AABB: { + case RECT3: { p_list->push_back( PropertyInfo(Variant::VECTOR3,"pos")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"size")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"end")); } break; //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: { + case BASIS: { p_list->push_back( PropertyInfo(Variant::VECTOR3,"x")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"y")); @@ -2717,7 +2767,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } break; case TRANSFORM: { - p_list->push_back( PropertyInfo(Variant::MATRIX3,"basis")); + p_list->push_back( PropertyInfo(Variant::BASIS,"basis")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"origin")); } break; @@ -2813,7 +2863,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } - if (ie.type==InputEvent::JOYSTICK_BUTTON) { + if (ie.type==InputEvent::JOYPAD_BUTTON) { p_list->push_back( PropertyInfo(Variant::INT,"button_index") ); p_list->push_back( PropertyInfo(Variant::BOOL,"pressed") ); @@ -2821,7 +2871,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } - if (ie.type==InputEvent::JOYSTICK_MOTION) { + if (ie.type==InputEvent::JOYPAD_MOTION) { p_list->push_back( PropertyInfo(Variant::INT,"axis") ); p_list->push_back( PropertyInfo(Variant::REAL,"value") ); @@ -2864,12 +2914,12 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } } break; // 20 case ARRAY: - case RAW_ARRAY: - case INT_ARRAY: - case REAL_ARRAY: - case STRING_ARRAY: - case VECTOR3_ARRAY: - case COLOR_ARRAY: { + case POOL_BYTE_ARRAY: + case POOL_INT_ARRAY: + case POOL_REAL_ARRAY: + case POOL_STRING_ARRAY: + case POOL_VECTOR3_ARRAY: + case POOL_COLOR_ARRAY: { //nothing } break; @@ -2941,56 +2991,56 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { r_iter=0; return true; } break; - case RAW_ARRAY: { - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem); + case POOL_BYTE_ARRAY: { + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; return true; } break; - case INT_ARRAY: { - const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem); + case POOL_INT_ARRAY: { + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; return true; } break; - case REAL_ARRAY: { - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem); + case POOL_REAL_ARRAY: { + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; return true; } break; - case STRING_ARRAY: { - const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem); + case POOL_STRING_ARRAY: { + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; return true; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; return true; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; return true; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3072,8 +3122,8 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case RAW_ARRAY: { - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem); + case POOL_BYTE_ARRAY: { + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3082,8 +3132,8 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { return true; } break; - case INT_ARRAY: { - const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem); + case POOL_INT_ARRAY: { + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3092,8 +3142,8 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { return true; } break; - case REAL_ARRAY: { - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem); + case POOL_REAL_ARRAY: { + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3102,8 +3152,8 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { return true; } break; - case STRING_ARRAY: { - const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem); + case POOL_STRING_ARRAY: { + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3111,9 +3161,9 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3121,9 +3171,9 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3131,9 +3181,9 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3204,8 +3254,8 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case RAW_ARRAY: { - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem); + case POOL_BYTE_ARRAY: { + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3215,8 +3265,8 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case INT_ARRAY: { - const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem); + case POOL_INT_ARRAY: { + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3226,8 +3276,8 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case REAL_ARRAY: { - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem); + case POOL_REAL_ARRAY: { + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3237,8 +3287,8 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case STRING_ARRAY: { - const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem); + case POOL_STRING_ARRAY: { + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3248,9 +3298,9 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3260,9 +3310,9 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3272,9 +3322,9 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3308,8 +3358,8 @@ void Variant::blend(const Variant& a, const Variant& b, float c, Variant &r_dst) switch(a.type) { case NIL: { r_dst=Variant(); } return; case INT:{ - int va=a._data._int; - int vb=b._data._int; + int64_t va=a._data._int; + int64_t vb=b._data._int; r_dst=int(va + vb * c + 0.5); } return; case REAL:{ @@ -3324,10 +3374,10 @@ void Variant::blend(const Variant& a, const Variant& b, float c, Variant &r_dst) r_dst=Rect2(ra->pos + rb->pos * c, ra->size + rb->size * c); } return; case VECTOR3:{ r_dst=*reinterpret_cast<const Vector3*>(a._data._mem)+*reinterpret_cast<const Vector3*>(b._data._mem)*c; } return; - case _AABB:{ - const AABB *ra = reinterpret_cast<const AABB*>(a._data._mem); - const AABB *rb = reinterpret_cast<const AABB*>(b._data._mem); - r_dst=AABB(ra->pos + rb->pos * c, ra->size + rb->size * c); + case RECT3:{ + const Rect3 *ra = reinterpret_cast<const Rect3*>(a._data._mem); + const Rect3 *rb = reinterpret_cast<const Rect3*>(b._data._mem); + r_dst=Rect3(ra->pos + rb->pos * c, ra->size + rb->size * c); } return; case QUAT:{ Quat empty_rot; @@ -3373,8 +3423,8 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r case NIL:{ r_dst=Variant(); } return; case BOOL:{ r_dst=a; } return; case INT:{ - int va=a._data._int; - int vb=b._data._int; + int64_t va=a._data._int; + int64_t vb=b._data._int; r_dst=int((1.0-c) * va + vb * c); } return; case REAL:{ @@ -3426,11 +3476,11 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r case VECTOR2:{ r_dst=reinterpret_cast<const Vector2*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector2*>(b._data._mem),c); } return; case RECT2:{ r_dst = Rect2( reinterpret_cast<const Rect2*>(a._data._mem)->pos.linear_interpolate(reinterpret_cast<const Rect2*>(b._data._mem)->pos,c), reinterpret_cast<const Rect2*>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2*>(b._data._mem)->size,c) ); } return; case VECTOR3:{ r_dst=reinterpret_cast<const Vector3*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector3*>(b._data._mem),c); } return; - case MATRIX32:{ r_dst=a._data._matrix32->interpolate_with(*b._data._matrix32,c); } return; + case TRANSFORM2D:{ r_dst=a._data._transform2d->interpolate_with(*b._data._transform2d,c); } return; case PLANE:{ r_dst=a; } return; case QUAT:{ r_dst=reinterpret_cast<const Quat*>(a._data._mem)->slerp(*reinterpret_cast<const Quat*>(b._data._mem),c); } return; - case _AABB:{ r_dst=AABB( a._data._aabb->pos.linear_interpolate(b._data._aabb->pos,c), a._data._aabb->size.linear_interpolate(b._data._aabb->size,c) ); } return; - case MATRIX3:{ r_dst=Transform(*a._data._matrix3).interpolate_with(Transform(*b._data._matrix3),c).basis; } return; + case RECT3:{ r_dst=Rect3( a._data._rect3->pos.linear_interpolate(b._data._rect3->pos,c), a._data._rect3->size.linear_interpolate(b._data._rect3->size,c) ); } return; + case BASIS:{ r_dst=Transform(*a._data._basis).interpolate_with(Transform(*b._data._basis),c).basis; } return; case TRANSFORM:{ r_dst=a._data._transform->interpolate_with(*b._data._transform,c); } return; case COLOR:{ r_dst=reinterpret_cast<const Color*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color*>(b._data._mem),c); } return; case IMAGE:{ r_dst=a; } return; @@ -3440,25 +3490,25 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r case INPUT_EVENT:{ r_dst=a; } return; case DICTIONARY:{ } return; case ARRAY:{ r_dst=a; } return; - case RAW_ARRAY:{ r_dst=a; } return; - case INT_ARRAY:{ r_dst=a; } return; - case REAL_ARRAY:{ r_dst=a; } return; - case STRING_ARRAY:{ r_dst=a; } return; - case VECTOR2_ARRAY:{ - const DVector<Vector2> *arr_a=reinterpret_cast<const DVector<Vector2>* >(a._data._mem); - const DVector<Vector2> *arr_b=reinterpret_cast<const DVector<Vector2>* >(b._data._mem); + case POOL_BYTE_ARRAY:{ r_dst=a; } return; + case POOL_INT_ARRAY:{ r_dst=a; } return; + case POOL_REAL_ARRAY:{ r_dst=a; } return; + case POOL_STRING_ARRAY:{ r_dst=a; } return; + case POOL_VECTOR2_ARRAY:{ + const PoolVector<Vector2> *arr_a=reinterpret_cast<const PoolVector<Vector2>* >(a._data._mem); + const PoolVector<Vector2> *arr_b=reinterpret_cast<const PoolVector<Vector2>* >(b._data._mem); int sz = arr_a->size(); if (sz==0 || arr_b->size()!=sz) { r_dst=a; } else { - DVector<Vector2> v; + PoolVector<Vector2> v; v.resize(sz); { - DVector<Vector2>::Write vw=v.write(); - DVector<Vector2>::Read ar=arr_a->read(); - DVector<Vector2>::Read br=arr_b->read(); + PoolVector<Vector2>::Write vw=v.write(); + PoolVector<Vector2>::Read ar=arr_a->read(); + PoolVector<Vector2>::Read br=arr_b->read(); for(int i=0;i<sz;i++) { vw[i]=ar[i].linear_interpolate(br[i],c); @@ -3470,23 +3520,23 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r } return; - case VECTOR3_ARRAY:{ + case POOL_VECTOR3_ARRAY:{ - const DVector<Vector3> *arr_a=reinterpret_cast<const DVector<Vector3>* >(a._data._mem); - const DVector<Vector3> *arr_b=reinterpret_cast<const DVector<Vector3>* >(b._data._mem); + const PoolVector<Vector3> *arr_a=reinterpret_cast<const PoolVector<Vector3>* >(a._data._mem); + const PoolVector<Vector3> *arr_b=reinterpret_cast<const PoolVector<Vector3>* >(b._data._mem); int sz = arr_a->size(); if (sz==0 || arr_b->size()!=sz) { r_dst=a; } else { - DVector<Vector3> v; + PoolVector<Vector3> v; v.resize(sz); { - DVector<Vector3>::Write vw=v.write(); - DVector<Vector3>::Read ar=arr_a->read(); - DVector<Vector3>::Read br=arr_b->read(); + PoolVector<Vector3>::Write vw=v.write(); + PoolVector<Vector3>::Read ar=arr_a->read(); + PoolVector<Vector3>::Read br=arr_b->read(); for(int i=0;i<sz;i++) { vw[i]=ar[i].linear_interpolate(br[i],c); @@ -3497,7 +3547,7 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r } } return; - case COLOR_ARRAY:{ r_dst=a; } return; + case POOL_COLOR_ARRAY:{ r_dst=a; } return; default: { r_dst=a; |