Type renames:

	Matrix32 -> Transform2D
	Matrix3 -> Basis
	AABB -> Rect3
	RawArray -> PoolByteArray
	IntArray -> PoolIntArray
	FloatArray -> PoolFloatArray
	Vector2Array -> PoolVector2Array
	Vector3Array -> PoolVector3Array
	ColorArray -> PoolColorArray

1 files changed, 189 insertions, 189 deletions

diff --git a/core/variant_op.cpp b/core/variant_op.cpp
index 00baffdd3b..1e67d81ae2 100644
--- a/core/variant_op.cpp
+++ b/core/variant_op.cpp
@@ -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: {}
@@ -262,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);
@@ -316,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;
@@ -354,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);
@@ -393,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;
@@ -420,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);
@@ -440,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;
@@ -484,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);
@@ -517,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;
@@ -542,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);
@@ -558,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;
@@ -583,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;
@@ -615,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: {}
@@ -660,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;
@@ -712,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: {
@@ -722,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);
@@ -734,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;
@@ -757,9 +757,9 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant&
 					DEFAULT_OP_FAIL(NIL);
 					DEFAULT_OP_FAIL(STRING);
 					DEFAULT_OP_FAIL(RECT2);
-					DEFAULT_OP_FAIL(MATRIX32);
-					DEFAULT_OP_FAIL(_AABB);
-					DEFAULT_OP_FAIL(MATRIX3);
+					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);
@@ -777,13 +777,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;
@@ -802,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);
@@ -818,13 +818,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;
@@ -1157,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;
@@ -1169,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;
@@ -1179,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;
@@ -1305,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;
@@ -1315,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;
@@ -1331,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;
@@ -1343,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);
@@ -1352,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;
@@ -1398,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;
@@ -1887,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;
 	}
 
@@ -2007,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) {
 
@@ -2016,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];
@@ -2025,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];
@@ -2086,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;
@@ -2105,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) {
 
@@ -2113,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);
@@ -2121,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;
@@ -2471,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();
 	}
 
@@ -2557,7 +2557,7 @@ 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;
@@ -2576,7 +2576,7 @@ 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;
@@ -2594,7 +2594,7 @@ 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) {
 
@@ -2614,7 +2614,7 @@ 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;
@@ -2634,7 +2634,7 @@ 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;
@@ -2654,7 +2654,7 @@ 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;
@@ -2674,7 +2674,7 @@ 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) {
 
@@ -2729,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"));
@@ -2753,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"));
@@ -2767,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;
@@ -2914,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;
@@ -2991,7 +2991,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const {
 			r_iter=0;
 			return true;
 		} break;
-		case RAW_ARRAY: {
+		case POOL_BYTE_ARRAY: {
 			const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem);
 			if (arr->size()==0)
 				return false;
@@ -2999,7 +2999,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const {
 			return true;
 
 		} break;
-		case INT_ARRAY: {
+		case POOL_INT_ARRAY: {
 			const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem);
 			if (arr->size()==0)
 				return false;
@@ -3007,7 +3007,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const {
 			return true;
 
 		} break;
-		case REAL_ARRAY: {
+		case POOL_REAL_ARRAY: {
 			const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem);
 			if (arr->size()==0)
 				return false;
@@ -3015,14 +3015,14 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const {
 			return true;
 
 		} break;
-		case STRING_ARRAY: {
+		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 PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem);
 			if (arr->size()==0)
@@ -3030,7 +3030,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const {
 			r_iter=0;
 			return true;
 		} break;
-		case VECTOR3_ARRAY: {
+		case POOL_VECTOR3_ARRAY: {
 
 			const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem);
 			if (arr->size()==0)
@@ -3038,7 +3038,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const {
 			r_iter=0;
 			return true;
 		} break;
-		case COLOR_ARRAY: {
+		case POOL_COLOR_ARRAY: {
 
 			const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem);
 			if (arr->size()==0)
@@ -3122,7 +3122,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const {
 			r_iter=idx;
 			return true;
 		} break;
-		case RAW_ARRAY: {
+		case POOL_BYTE_ARRAY: {
 			const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem);
 			int idx=r_iter;
 			idx++;
@@ -3132,7 +3132,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const {
 			return true;
 
 		} break;
-		case INT_ARRAY: {
+		case POOL_INT_ARRAY: {
 			const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem);
 			int idx=r_iter;
 			idx++;
@@ -3142,7 +3142,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const {
 			return true;
 
 		} break;
-		case REAL_ARRAY: {
+		case POOL_REAL_ARRAY: {
 			const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem);
 			int idx=r_iter;
 			idx++;
@@ -3152,7 +3152,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const {
 			return true;
 
 		} break;
-		case STRING_ARRAY: {
+		case POOL_STRING_ARRAY: {
 			const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem);
 			int idx=r_iter;
 			idx++;
@@ -3161,7 +3161,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const {
 			r_iter=idx;
 			return true;
 		} break;
-		case VECTOR2_ARRAY: {
+		case POOL_VECTOR2_ARRAY: {
 
 			const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem);
 			int idx=r_iter;
@@ -3171,7 +3171,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const {
 			r_iter=idx;
 			return true;
 		} break;
-		case VECTOR3_ARRAY: {
+		case POOL_VECTOR3_ARRAY: {
 
 			const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem);
 			int idx=r_iter;
@@ -3181,7 +3181,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const {
 			r_iter=idx;
 			return true;
 		} break;
-		case COLOR_ARRAY: {
+		case POOL_COLOR_ARRAY: {
 
 			const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem);
 			int idx=r_iter;
@@ -3254,7 +3254,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const {
 #endif
 			return arr->get(idx);
 		} break;
-		case RAW_ARRAY: {
+		case POOL_BYTE_ARRAY: {
 			const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem);
 			int idx=r_iter;
 #ifdef DEBUG_ENABLED
@@ -3265,7 +3265,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const {
 #endif
 			return arr->get(idx);
 		} break;
-		case INT_ARRAY: {
+		case POOL_INT_ARRAY: {
 			const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem);
 			int idx=r_iter;
 #ifdef DEBUG_ENABLED
@@ -3276,7 +3276,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const {
 #endif
 			return arr->get(idx);
 		} break;
-		case REAL_ARRAY: {
+		case POOL_REAL_ARRAY: {
 			const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem);
 			int idx=r_iter;
 #ifdef DEBUG_ENABLED
@@ -3287,7 +3287,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const {
 #endif
 			return arr->get(idx);
 		} break;
-		case STRING_ARRAY: {
+		case POOL_STRING_ARRAY: {
 			const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem);
 			int idx=r_iter;
 #ifdef DEBUG_ENABLED
@@ -3298,7 +3298,7 @@ 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 PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem);
 			int idx=r_iter;
@@ -3310,7 +3310,7 @@ 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 PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem);
 			int idx=r_iter;
@@ -3322,7 +3322,7 @@ 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 PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem);
 			int idx=r_iter;
@@ -3374,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;
@@ -3476,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;
@@ -3490,11 +3490,11 @@ 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:{
+		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();
@@ -3520,7 +3520,7 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r
 
 
 		} return;
-		case VECTOR3_ARRAY:{
+		case POOL_VECTOR3_ARRAY:{
 
 
 			const PoolVector<Vector3> *arr_a=reinterpret_cast<const PoolVector<Vector3>* >(a._data._mem);
@@ -3547,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;