Type renames:

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

7 files changed, 104 insertions, 104 deletions

diff --git a/drivers/gles2/shader_compiler_gles2.cpp b/drivers/gles2/shader_compiler_gles2.cpp
index 4ef96de9d..adb9fe0e8 100644
--- a/drivers/gles2/shader_compiler_gles2.cpp
+++ b/drivers/gles2/shader_compiler_gles2.cpp
@@ -299,8 +299,8 @@ String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_a
 				case SL::TYPE_VEC2: { Vector2 v = cnode->value; code="vec2("+_mknum(v.x)+", "+_mknum(v.y)+")"; } break;
 				case SL::TYPE_VEC3: { Vector3 v = cnode->value; code="vec3("+_mknum(v.x)+", "+_mknum(v.y)+", "+_mknum(v.z)+")"; } break;
 				case SL::TYPE_VEC4: { Plane v = cnode->value; code="vec4("+_mknum(v.normal.x)+", "+_mknum(v.normal.y)+", "+_mknum(v.normal.z)+", "+_mknum(v.d)+")"; } break;
-				case SL::TYPE_MAT2: { Matrix32 x = cnode->value; code="mat2( vec2("+_mknum(x[0][0])+", "+_mknum(x[0][1])+"), vec2("+_mknum(x[1][0])+", "+_mknum(x[1][1])+"))"; } break;
-				case SL::TYPE_MAT3: { Matrix3 x = cnode->value; code="mat3( vec3("+_mknum(x.get_axis(0).x)+", "+_mknum(x.get_axis(0).y)+", "+_mknum(x.get_axis(0).z)+"), vec3("+_mknum(x.get_axis(1).x)+", "+_mknum(x.get_axis(1).y)+", "+_mknum(x.get_axis(1).z)+"), vec3("+_mknum(x.get_axis(2).x)+", "+_mknum(x.get_axis(2).y)+", "+_mknum(x.get_axis(2).z)+"))"; } break;
+				case SL::TYPE_MAT2: { Transform2D x = cnode->value; code="mat2( vec2("+_mknum(x[0][0])+", "+_mknum(x[0][1])+"), vec2("+_mknum(x[1][0])+", "+_mknum(x[1][1])+"))"; } break;
+				case SL::TYPE_MAT3: { Basis x = cnode->value; code="mat3( vec3("+_mknum(x.get_axis(0).x)+", "+_mknum(x.get_axis(0).y)+", "+_mknum(x.get_axis(0).z)+"), vec3("+_mknum(x.get_axis(1).x)+", "+_mknum(x.get_axis(1).y)+", "+_mknum(x.get_axis(1).z)+"), vec3("+_mknum(x.get_axis(2).x)+", "+_mknum(x.get_axis(2).y)+", "+_mknum(x.get_axis(2).z)+"))"; } break;
 				case SL::TYPE_MAT4: { Transform x = cnode->value; code="mat4( vec4("+_mknum(x.basis.get_axis(0).x)+", "+_mknum(x.basis.get_axis(0).y)+", "+_mknum(x.basis.get_axis(0).z)+",0.0), vec4("+_mknum(x.basis.get_axis(1).x)+", "+_mknum(x.basis.get_axis(1).y)+", "+_mknum(x.basis.get_axis(1).z)+",0.0), vec4("+_mknum(x.basis.get_axis(2).x)+", "+_mknum(x.basis.get_axis(2).y)+", "+_mknum(x.basis.get_axis(2).z)+",0.0), vec4("+_mknum(x.origin.x)+", "+_mknum(x.origin.y)+", "+_mknum(x.origin.z)+",1.0))"; } break;
 				default: code="<error: "+Variant::get_type_name(cnode->value.get_type())+" ("+itos(cnode->datatype)+">";
 			}
diff --git a/drivers/gles3/rasterizer_canvas_gles3.cpp b/drivers/gles3/rasterizer_canvas_gles3.cpp
index 6bd440eec..3c3768be6 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.cpp
+++ b/drivers/gles3/rasterizer_canvas_gles3.cpp
@@ -1,7 +1,7 @@
 #include "rasterizer_canvas_gles3.h"
 #include "os/os.h"
 
-static _FORCE_INLINE_ void store_matrix32(const Matrix32& p_mtx, float* p_array) {
+static _FORCE_INLINE_ void store_transform2d(const Transform2D& p_mtx, float* p_array) {
 
 	p_array[ 0]=p_mtx.elements[0][0];
 	p_array[ 1]=p_mtx.elements[0][1];
@@ -69,8 +69,8 @@ void RasterizerCanvasGLES3::light_internal_update(RID p_rid, Light* p_light) {
 	LightInternal * li = light_internal_owner.getornull(p_rid);
 	ERR_FAIL_COND(!li);
 
-	store_matrix32(p_light->light_shader_xform,li->ubo_data.light_matrix);
-	store_matrix32(p_light->xform_cache.affine_inverse(),li->ubo_data.local_matrix);
+	store_transform2d(p_light->light_shader_xform,li->ubo_data.light_matrix);
+	store_transform2d(p_light->xform_cache.affine_inverse(),li->ubo_data.local_matrix);
 	store_camera(p_light->shadow_matrix_cache,li->ubo_data.shadow_matrix);
 
 	for(int i=0;i<4;i++) {
@@ -141,8 +141,8 @@ void RasterizerCanvasGLES3::canvas_begin(){
 	state.canvas_shader.set_custom_shader(0);
 	state.canvas_shader.bind();
 	state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,Color(1,1,1,1));
-	state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,Matrix32());
-	state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Matrix32());
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,Transform2D());
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Transform2D());
 
 
 
@@ -999,7 +999,7 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
 					ci->final_modulate.a * p_modulate.a );
 
 		state.final_transform = ci->final_transform;
-		state.extra_matrix=Matrix32();
+		state.extra_matrix=Transform2D();
 
 		state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
 		state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
@@ -1081,7 +1081,7 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
 
 						state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
 						state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
-						state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Matrix32());
+						state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Transform2D());
 
 					}
 
@@ -1212,7 +1212,7 @@ void RasterizerCanvasGLES3::canvas_debug_viewport_shadows(Light* p_lights_with_s
 }
 
 
-void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache) {
+void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, const Transform2D& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache) {
 
 	RasterizerStorageGLES3::CanvasLightShadow *cls = storage->canvas_light_shadow_owner.get(p_buffer);
 	ERR_FAIL_COND(!cls);
@@ -1269,7 +1269,7 @@ void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, cons
 			projection.set_frustum( xmin, xmax, ymin, ymax, nearp, farp );
 		}
 
-		Vector3 cam_target=Matrix3(Vector3(0,0,Math_PI*2*(i/4.0))).xform(Vector3(0,1,0));
+		Vector3 cam_target=Basis(Vector3(0,0,Math_PI*2*(i/4.0))).xform(Vector3(0,1,0));
 		projection = projection * CameraMatrix(Transform().looking_at(cam_target,Vector3(0,0,-1)).affine_inverse());
 
 		state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::PROJECTION_MATRIX,projection);
diff --git a/drivers/gles3/rasterizer_canvas_gles3.h b/drivers/gles3/rasterizer_canvas_gles3.h
index 670310068..6630ec38c 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.h
+++ b/drivers/gles3/rasterizer_canvas_gles3.h
@@ -42,8 +42,8 @@ public:
 		Transform vp;
 
 		Color canvas_item_modulate;
-		Matrix32 extra_matrix;
-		Matrix32 final_transform;
+		Transform2D extra_matrix;
+		Transform2D final_transform;
 
 	} state;
 
@@ -90,7 +90,7 @@ public:
 	virtual void canvas_render_items(Item *p_item_list,int p_z,const Color& p_modulate,Light *p_light);
 	virtual void canvas_debug_viewport_shadows(Light* p_lights_with_shadow);
 
-	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache);
+	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Transform2D& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache);
 
 
 	virtual void reset_canvas();
diff --git a/drivers/gles3/rasterizer_scene_gles3.cpp b/drivers/gles3/rasterizer_scene_gles3.cpp
index b5904e09d..5611b4b63 100644
--- a/drivers/gles3/rasterizer_scene_gles3.cpp
+++ b/drivers/gles3/rasterizer_scene_gles3.cpp
@@ -15,7 +15,7 @@ static const GLenum _cube_side_enum[6]={
 };
 
 
-static _FORCE_INLINE_ void store_matrix32(const Matrix32& p_mtx, float* p_array) {
+static _FORCE_INLINE_ void store_transform2d(const Transform2D& p_mtx, float* p_array) {
 
 	p_array[ 0]=p_mtx.elements[0][0];
 	p_array[ 1]=p_mtx.elements[0][1];
diff --git a/drivers/gles3/rasterizer_storage_gles3.cpp b/drivers/gles3/rasterizer_storage_gles3.cpp
index a3c5bf557..a4fea29b4 100644
--- a/drivers/gles3/rasterizer_storage_gles3.cpp
+++ b/drivers/gles3/rasterizer_storage_gles3.cpp
@@ -1601,7 +1601,7 @@ void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyIn
 			case ShaderLanguage::TYPE_UVEC3:
 			case ShaderLanguage::TYPE_UVEC4: {
 
-				pi.type=Variant::INT_ARRAY;
+				pi.type=Variant::POOL_INT_ARRAY;
 			} break;
 			case ShaderLanguage::TYPE_FLOAT: {
 				pi.type=Variant::REAL;
@@ -1620,8 +1620,8 @@ void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyIn
 					pi.type=Variant::PLANE;
 				}
 			} break;
-			case ShaderLanguage::TYPE_MAT2: pi.type=Variant::MATRIX32; break;
-			case ShaderLanguage::TYPE_MAT3: pi.type=Variant::MATRIX3; break;
+			case ShaderLanguage::TYPE_MAT2: pi.type=Variant::TRANSFORM2D; break;
+			case ShaderLanguage::TYPE_MAT3: pi.type=Variant::BASIS; break;
 			case ShaderLanguage::TYPE_MAT4: pi.type=Variant::TRANSFORM; break;
 			case ShaderLanguage::TYPE_SAMPLER2D:
 			case ShaderLanguage::TYPE_ISAMPLER2D:
@@ -2009,7 +2009,7 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			}
 		} break;
 		case ShaderLanguage::TYPE_MAT2: {
-			Matrix32 v = value;
+			Transform2D v = value;
 			GLfloat *gui = (GLfloat*)data;
 
 			gui[ 0]=v.elements[0][0];
@@ -2020,7 +2020,7 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 		case ShaderLanguage::TYPE_MAT3: {
 
 
-			Matrix3 v = value;
+			Basis v = value;
 			GLfloat *gui = (GLfloat*)data;
 
 			gui[ 0]=v.elements[0][0];
@@ -2463,7 +2463,7 @@ RID RasterizerStorageGLES3::mesh_create(){
 }
 
 
-void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const PoolVector<uint8_t>& p_array,int p_vertex_count,const PoolVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes,const Vector<AABB>& p_bone_aabbs){
+void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const PoolVector<uint8_t>& p_array,int p_vertex_count,const PoolVector<uint8_t>& p_index_array,int p_index_count,const Rect3& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes,const Vector<Rect3>& p_bone_aabbs){
 
 	PoolVector<uint8_t> array = p_array;
 
@@ -3009,11 +3009,11 @@ VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_
 	return mesh->surfaces[p_surface]->primitive;
 }
 
-AABB RasterizerStorageGLES3::mesh_surface_get_aabb(RID p_mesh, int p_surface) const {
+Rect3 RasterizerStorageGLES3::mesh_surface_get_aabb(RID p_mesh, int p_surface) const {
 
 	const Mesh *mesh = mesh_owner.getornull(p_mesh);
-	ERR_FAIL_COND_V(!mesh,AABB());
-	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),AABB());
+	ERR_FAIL_COND_V(!mesh,Rect3());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Rect3());
 
 	return mesh->surfaces[p_surface]->aabb;
 
@@ -3051,11 +3051,11 @@ Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shap
 	return bsarr;
 
 }
-Vector<AABB> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const{
+Vector<Rect3> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const{
 
 	const Mesh *mesh = mesh_owner.getornull(p_mesh);
-	ERR_FAIL_COND_V(!mesh,Vector<AABB >());
-	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<AABB >());
+	ERR_FAIL_COND_V(!mesh,Vector<Rect3 >());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<Rect3 >());
 
 	return mesh->surfaces[p_surface]->skeleton_bone_aabb;
 
@@ -3103,47 +3103,47 @@ int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const{
 
 }
 
-void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb){
+void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const Rect3& p_aabb){
 
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
 	mesh->custom_aabb=p_aabb;
 }
-AABB RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{
+Rect3 RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{
 
 	const Mesh *mesh = mesh_owner.getornull(p_mesh);
-	ERR_FAIL_COND_V(!mesh,AABB());
+	ERR_FAIL_COND_V(!mesh,Rect3());
 
 	return mesh->custom_aabb;
 
 }
 
-AABB RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
+Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
 
 	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,AABB());
+	ERR_FAIL_COND_V(!mesh,Rect3());
 
-	if (mesh->custom_aabb!=AABB())
+	if (mesh->custom_aabb!=Rect3())
 		return mesh->custom_aabb;
 
 	Skeleton *sk=NULL;
 	if (p_skeleton.is_valid())
 		sk=skeleton_owner.get(p_skeleton);
 
-	AABB aabb;
+	Rect3 aabb;
 
 	if (sk && sk->size!=0) {
 
 
 		for (int i=0;i<mesh->surfaces.size();i++) {
 
-			AABB laabb;
+			Rect3 laabb;
 			if (mesh->surfaces[i]->format&VS::ARRAY_FORMAT_BONES && mesh->surfaces[i]->skeleton_bone_aabb.size()) {
 
 
 				int bs = mesh->surfaces[i]->skeleton_bone_aabb.size();
-				const AABB *skbones = mesh->surfaces[i]->skeleton_bone_aabb.ptr();
+				const Rect3 *skbones = mesh->surfaces[i]->skeleton_bone_aabb.ptr();
 				const bool *skused = mesh->surfaces[i]->skeleton_bone_used.ptr();
 
 				int sbs = sk->size;
@@ -3170,7 +3170,7 @@ AABB RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
 						mtx.basis.elements[1][1]=dataptr[ 5];
 						mtx.origin[1]=dataptr[ 7];
 
-						AABB baabb = mtx.xform( skbones[j] );
+						Rect3 baabb = mtx.xform( skbones[j] );
 						if (first) {
 							laabb=baabb;
 							first=false;
@@ -3200,7 +3200,7 @@ AABB RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
 						mtx.basis.elements[2][2]=dataptr[10];
 						mtx.origin.z=dataptr[11];
 
-						AABB baabb = mtx.xform ( skbones[j] );
+						Rect3 baabb = mtx.xform ( skbones[j] );
 						if (first) {
 							laabb=baabb;
 							first=false;
@@ -3630,7 +3630,7 @@ void RasterizerStorageGLES3::multimesh_instance_set_transform(RID p_multimesh,in
 	}
 }
 
-void RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Matrix32& p_transform){
+void RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Transform2D& p_transform){
 
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
@@ -3726,17 +3726,17 @@ Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multime
 
 	return xform;
 }
-Matrix32 RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const{
+Transform2D RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const{
 
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,Matrix32());
-	ERR_FAIL_INDEX_V(p_index,multimesh->size,Matrix32());
-	ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D,Matrix32());
+	ERR_FAIL_COND_V(!multimesh,Transform2D());
+	ERR_FAIL_INDEX_V(p_index,multimesh->size,Transform2D());
+	ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D,Transform2D());
 
 	int stride = multimesh->color_floats+multimesh->xform_floats;
 	float *dataptr=&multimesh->data[stride*p_index];
 
-	Matrix32 xform;
+	Transform2D xform;
 
 	xform.elements[0][0]=dataptr[ 0];
 	xform.elements[1][0]=dataptr[ 1];
@@ -3795,10 +3795,10 @@ int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) con
 	return multimesh->visible_instances;
 }
 
-AABB RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const{
+Rect3 RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const{
 
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,AABB());
+	ERR_FAIL_COND_V(!multimesh,Rect3());
 
 	const_cast<RasterizerStorageGLES3*>(this)->update_dirty_multimeshes(); //update pending AABBs
 
@@ -3825,7 +3825,7 @@ void RasterizerStorageGLES3::update_dirty_multimeshes() {
 
 		if (multimesh->size && multimesh->dirty_aabb) {
 
-			AABB mesh_aabb;
+			Rect3 mesh_aabb;
 
 			if (multimesh->mesh.is_valid()) {
 				mesh_aabb=mesh_get_aabb(multimesh->mesh,RID());
@@ -3837,7 +3837,7 @@ void RasterizerStorageGLES3::update_dirty_multimeshes() {
 			int count = multimesh->data.size();
 			float *data=multimesh->data.ptr();
 
-			AABB aabb;
+			Rect3 aabb;
 
 			if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
 
@@ -3852,7 +3852,7 @@ void RasterizerStorageGLES3::update_dirty_multimeshes() {
 					xform.basis[1][1]=dataptr[ 5];
 					xform.origin[1]=dataptr[ 7];
 
-					AABB laabb = xform.xform(mesh_aabb);
+					Rect3 laabb = xform.xform(mesh_aabb);
 					if (i==0)
 						aabb=laabb;
 					else
@@ -3878,7 +3878,7 @@ void RasterizerStorageGLES3::update_dirty_multimeshes() {
 					xform.basis.elements[2][2]=dataptr[10];
 					xform.origin.z=dataptr[11];
 
-					AABB laabb = xform.xform(mesh_aabb);
+					Rect3 laabb = xform.xform(mesh_aabb);
 					if (i==0)
 						aabb=laabb;
 					else
@@ -4028,10 +4028,10 @@ void RasterizerStorageGLES3::immediate_clear(RID p_immediate) {
 
 }
 
-AABB RasterizerStorageGLES3::immediate_get_aabb(RID p_immediate) const {
+Rect3 RasterizerStorageGLES3::immediate_get_aabb(RID p_immediate) const {
 
 	Immediate *im = immediate_owner.get(p_immediate);
-	ERR_FAIL_COND_V(!im,AABB());
+	ERR_FAIL_COND_V(!im,Rect3());
 	return im->aabb;
 }
 
@@ -4185,7 +4185,7 @@ Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton,int
 
 	return mtx;
 }
-void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Matrix32& p_transform){
+void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Transform2D& p_transform){
 
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
@@ -4208,16 +4208,16 @@ void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p
 	}
 
 }
-Matrix32 RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const{
+Transform2D RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const{
 
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 
-	ERR_FAIL_COND_V(!skeleton,Matrix32());
-	ERR_FAIL_INDEX_V(p_bone,skeleton->size,Matrix32());
-	ERR_FAIL_COND_V(!skeleton->use_2d,Matrix32());
+	ERR_FAIL_COND_V(!skeleton,Transform2D());
+	ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform2D());
+	ERR_FAIL_COND_V(!skeleton->use_2d,Transform2D());
 
-	Matrix32 mtx;
+	Transform2D mtx;
 
 	float * bones = skeleton->bones.ptr();
 	mtx.elements[0][0]=bones[p_bone*12+ 0];
@@ -4474,10 +4474,10 @@ uint64_t RasterizerStorageGLES3::light_get_version(RID p_light) const {
 }
 
 
-AABB RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
+Rect3 RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
 
 	const Light * light = light_owner.getornull(p_light);
-	ERR_FAIL_COND_V(!light,AABB());
+	ERR_FAIL_COND_V(!light,Rect3());
 
 	switch( light->type ) {
 
@@ -4485,22 +4485,22 @@ AABB RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
 
 			float len=light->param[VS::LIGHT_PARAM_RANGE];
 			float size=Math::tan(Math::deg2rad(light->param[VS::LIGHT_PARAM_SPOT_ANGLE]))*len;
-			return AABB( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) );
+			return Rect3( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) );
 		} break;
 		case VS::LIGHT_OMNI: {
 
 			float r = light->param[VS::LIGHT_PARAM_RANGE];
-			return AABB( -Vector3(r,r,r), Vector3(r,r,r)*2 );
+			return Rect3( -Vector3(r,r,r), Vector3(r,r,r)*2 );
 		} break;
 		case VS::LIGHT_DIRECTIONAL: {
 
-			return AABB();
+			return Rect3();
 		} break;
 		default: {}
 	}
 
-	ERR_FAIL_V( AABB() );
-	return AABB();
+	ERR_FAIL_V( Rect3() );
+	return Rect3();
 }
 
 /* PROBE API */
@@ -4635,11 +4635,11 @@ void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_
 
 }
 
-AABB RasterizerStorageGLES3::reflection_probe_get_aabb(RID p_probe) const {
+Rect3 RasterizerStorageGLES3::reflection_probe_get_aabb(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
-	ERR_FAIL_COND_V(!reflection_probe,AABB());
+	ERR_FAIL_COND_V(!reflection_probe,Rect3());
 
-	AABB aabb;
+	Rect3 aabb;
 	aabb.pos=-reflection_probe->extents;
 	aabb.size=reflection_probe->extents*2.0;
 
@@ -4744,7 +4744,7 @@ RID RasterizerStorageGLES3::gi_probe_create() {
 
 	GIProbe *gip = memnew( GIProbe );
 
-	gip->bounds=AABB(Vector3(),Vector3(1,1,1));
+	gip->bounds=Rect3(Vector3(),Vector3(1,1,1));
 	gip->dynamic_range=1.0;
 	gip->energy=1.0;
 	gip->interior=false;
@@ -4755,7 +4755,7 @@ RID RasterizerStorageGLES3::gi_probe_create() {
 	return gi_probe_owner.make_rid(gip);
 }
 
-void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const AABB& p_bounds){
+void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const Rect3& p_bounds){
 
 	GIProbe *gip = gi_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!gip);
@@ -4764,10 +4764,10 @@ void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const AABB& p_bound
 	gip->version++;
 	gip->instance_change_notify();
 }
-AABB RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const{
+Rect3 RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const{
 
 	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
-	ERR_FAIL_COND_V(!gip,AABB());
+	ERR_FAIL_COND_V(!gip,Rect3());
 
 	return gip->bounds;
 }
@@ -5074,7 +5074,7 @@ void RasterizerStorageGLES3::particles_set_randomness_ratio(RID p_particles,floa
 	particles->randomness=p_ratio;
 
 }
-void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles,const AABB& p_aabb) {
+void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles,const Rect3& p_aabb) {
 
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
@@ -5166,10 +5166,10 @@ void RasterizerStorageGLES3::particles_set_draw_pass_mesh(RID p_particles,int p_
 
 }
 
-AABB RasterizerStorageGLES3::particles_get_current_aabb(RID p_particles) {
+Rect3 RasterizerStorageGLES3::particles_get_current_aabb(RID p_particles) {
 
 	const Particles *particles = particles_owner.getornull(p_particles);
-	ERR_FAIL_COND_V(!particles,AABB());
+	ERR_FAIL_COND_V(!particles,Rect3());
 
 	return particles->computed_aabb;
 }
diff --git a/drivers/gles3/rasterizer_storage_gles3.h b/drivers/gles3/rasterizer_storage_gles3.h
index 32581e860..66593b202 100644
--- a/drivers/gles3/rasterizer_storage_gles3.h
+++ b/drivers/gles3/rasterizer_storage_gles3.h
@@ -526,7 +526,7 @@ public:
 		GLuint vertex_id;
 		GLuint index_id;
 
-		Vector<AABB> skeleton_bone_aabb;
+		Vector<Rect3> skeleton_bone_aabb;
 		Vector<bool> skeleton_bone_used;
 
 		//bool packed;
@@ -538,7 +538,7 @@ public:
 
 		Vector<MorphTarget> morph_targets;
 
-		AABB aabb;
+		Rect3 aabb;
 
 		int array_len;
 		int index_array_len;
@@ -585,7 +585,7 @@ public:
 		Vector<Surface*> surfaces;
 		int morph_target_count;
 		VS::MorphTargetMode morph_target_mode;
-		AABB custom_aabb;
+		Rect3 custom_aabb;
 		mutable uint64_t last_pass;
 		Mesh() {
 			morph_target_mode=VS::MORPH_MODE_NORMALIZED;
@@ -599,7 +599,7 @@ public:
 
 	virtual RID mesh_create();
 
-	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const PoolVector<uint8_t>& p_array,int p_vertex_count,const PoolVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes=Vector<PoolVector<uint8_t> >(),const Vector<AABB>& p_bone_aabbs=Vector<AABB>());
+	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const PoolVector<uint8_t>& p_array,int p_vertex_count,const PoolVector<uint8_t>& p_index_array,int p_index_count,const Rect3& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes=Vector<PoolVector<uint8_t> >(),const Vector<Rect3>& p_bone_aabbs=Vector<Rect3>());
 
 	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount);
 	virtual int mesh_get_morph_target_count(RID p_mesh) const;
@@ -621,17 +621,17 @@ public:
 	virtual uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const;
 	virtual VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const;
 
-	virtual AABB mesh_surface_get_aabb(RID p_mesh, int p_surface) const;
+	virtual Rect3 mesh_surface_get_aabb(RID p_mesh, int p_surface) const;
 	virtual Vector<PoolVector<uint8_t> > mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const;
-	virtual Vector<AABB> mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const;
+	virtual Vector<Rect3> mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const;
 
 	virtual void mesh_remove_surface(RID p_mesh, int p_surface);
 	virtual int mesh_get_surface_count(RID p_mesh) const;
 
-	virtual void mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb);
-	virtual AABB mesh_get_custom_aabb(RID p_mesh) const;
+	virtual void mesh_set_custom_aabb(RID p_mesh,const Rect3& p_aabb);
+	virtual Rect3 mesh_get_custom_aabb(RID p_mesh) const;
 
-	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton) const;
+	virtual Rect3 mesh_get_aabb(RID p_mesh, RID p_skeleton) const;
 	virtual void mesh_clear(RID p_mesh);
 
 	void mesh_render_blend_shapes(Surface *s, float *p_weights);
@@ -644,7 +644,7 @@ public:
 		VS::MultimeshTransformFormat transform_format;
 		VS::MultimeshColorFormat color_format;
 		Vector<float> data;
-		AABB aabb;
+		Rect3 aabb;
 		SelfList<MultiMesh> update_list;
 		GLuint buffer;
 		int visible_instances;
@@ -681,19 +681,19 @@ public:
 
 	virtual void multimesh_set_mesh(RID p_multimesh,RID p_mesh);
 	virtual void multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform);
-	virtual void multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Matrix32& p_transform);
+	virtual void multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Transform2D& p_transform);
 	virtual void multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color);
 
 	virtual RID multimesh_get_mesh(RID p_multimesh) const;
 
 	virtual Transform multimesh_instance_get_transform(RID p_multimesh,int p_index) const;
-	virtual Matrix32 multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const;
+	virtual Transform2D multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const;
 	virtual Color multimesh_instance_get_color(RID p_multimesh,int p_index) const;
 
 	virtual void multimesh_set_visible_instances(RID p_multimesh,int p_visible);
 	virtual int multimesh_get_visible_instances(RID p_multimesh) const;
 
-	virtual AABB multimesh_get_aabb(RID p_multimesh) const;
+	virtual Rect3 multimesh_get_aabb(RID p_multimesh) const;
 
 	/* IMMEDIATE API */
 
@@ -714,7 +714,7 @@ public:
 		List<Chunk> chunks;
 		bool building;
 		int mask;
-		AABB aabb;
+		Rect3 aabb;
 
 		Immediate() { type=GEOMETRY_IMMEDIATE; building=false;}
 
@@ -741,7 +741,7 @@ public:
 	virtual void immediate_clear(RID p_immediate);
 	virtual void immediate_set_material(RID p_immediate,RID p_material);
 	virtual RID immediate_get_material(RID p_immediate) const;
-	virtual AABB immediate_get_aabb(RID p_immediate) const;
+	virtual Rect3 immediate_get_aabb(RID p_immediate) const;
 
 	/* SKELETON API */
 
@@ -771,8 +771,8 @@ public:
 	virtual int skeleton_get_bone_count(RID p_skeleton) const;
 	virtual void skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform);
 	virtual Transform skeleton_bone_get_transform(RID p_skeleton,int p_bone) const;
-	virtual void skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Matrix32& p_transform);
-	virtual Matrix32 skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const;
+	virtual void skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Transform2D& p_transform);
+	virtual Transform2D skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const;
 
 	/* Light API */
 
@@ -823,7 +823,7 @@ public:
 	virtual float light_get_param(RID p_light,VS::LightParam p_param);
 	virtual Color light_get_color(RID p_light);
 
-	virtual AABB light_get_aabb(RID p_light) const;
+	virtual Rect3 light_get_aabb(RID p_light) const;
 	virtual uint64_t light_get_version(RID p_light) const;
 
 	/* PROBE API */
@@ -862,7 +862,7 @@ public:
 	virtual void reflection_probe_set_enable_shadows(RID p_probe, bool p_enable);
 	virtual void reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers);
 
-	virtual AABB reflection_probe_get_aabb(RID p_probe) const;
+	virtual Rect3 reflection_probe_get_aabb(RID p_probe) const;
 	virtual VS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const;
 	virtual uint32_t reflection_probe_get_cull_mask(RID p_probe) const;
 
@@ -902,7 +902,7 @@ public:
 	struct GIProbe : public Instantiable {
 
 
-		AABB bounds;
+		Rect3 bounds;
 		Transform to_cell;
 		float cell_size;
 
@@ -922,8 +922,8 @@ public:
 
 	virtual RID gi_probe_create();
 
-	virtual void gi_probe_set_bounds(RID p_probe,const AABB& p_bounds);
-	virtual AABB gi_probe_get_bounds(RID p_probe) const;
+	virtual void gi_probe_set_bounds(RID p_probe,const Rect3& p_bounds);
+	virtual Rect3 gi_probe_get_bounds(RID p_probe) const;
 
 	virtual void gi_probe_set_cell_size(RID p_probe, float p_size);
 	virtual float gi_probe_get_cell_size(RID p_probe) const;
@@ -977,7 +977,7 @@ public:
 		float pre_process_time;
 		float explosiveness;
 		float randomness;
-		AABB custom_aabb;
+		Rect3 custom_aabb;
 		Vector3 gravity;
 		bool use_local_coords;
 		RID process_material;
@@ -996,7 +996,7 @@ public:
 
 		Vector<DrawPass> draw_passes;
 
-		AABB computed_aabb;
+		Rect3 computed_aabb;
 
 		GLuint particle_buffers[2];
 
@@ -1053,7 +1053,7 @@ public:
 	virtual void particles_set_pre_process_time(RID p_particles,float p_time);
 	virtual void particles_set_explosiveness_ratio(RID p_particles,float p_ratio);
 	virtual void particles_set_randomness_ratio(RID p_particles,float p_ratio);
-	virtual void particles_set_custom_aabb(RID p_particles,const AABB& p_aabb);
+	virtual void particles_set_custom_aabb(RID p_particles,const Rect3& p_aabb);
 	virtual void particles_set_gravity(RID p_particles,const Vector3& p_gravity);
 	virtual void particles_set_use_local_coordinates(RID p_particles,bool p_enable);
 	virtual void particles_set_process_material(RID p_particles,RID p_material);
@@ -1070,7 +1070,7 @@ public:
 	virtual void particles_set_draw_pass_material(RID p_particles,int p_pass, RID p_material);
 	virtual void particles_set_draw_pass_mesh(RID p_particles,int p_pass, RID p_mesh);
 
-	virtual AABB particles_get_current_aabb(RID p_particles);
+	virtual Rect3 particles_get_current_aabb(RID p_particles);
 
 	/* INSTANCE */
 
diff --git a/drivers/gles3/shader_gles3.h b/drivers/gles3/shader_gles3.h
index 8b402716a..ee8db2ac8 100644
--- a/drivers/gles3/shader_gles3.h
+++ b/drivers/gles3/shader_gles3.h
@@ -236,9 +236,9 @@ private:
 			glUniform4f( p_uniform, val.x,val.y,val.z,val.w );
 		} break;
 
-		case Variant::MATRIX32: {
+		case Variant::TRANSFORM2D: {
 
-			Matrix32 tr=p_value;
+			Transform2D tr=p_value;
 			GLfloat matrix[16]={ /* build a 16x16 matrix */
 				tr.elements[0][0],
 				tr.elements[0][1],
@@ -261,7 +261,7 @@ private:
 			glUniformMatrix4fv(p_uniform,1,false,matrix);
 
 		} break;
-		case Variant::MATRIX3:
+		case Variant::BASIS:
 		case Variant::TRANSFORM: {
 
 			Transform tr=p_value;