A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code

1 files changed, 632 insertions, 814 deletions

diff --git a/editor/import/editor_import_collada.cpp b/editor/import/editor_import_collada.cpp
index 7098e8812..b4ce666e0 100644
--- a/editor/import/editor_import_collada.cpp
+++ b/editor/import/editor_import_collada.cpp
@@ -28,22 +28,20 @@
 /*************************************************************************/
 #include "editor_import_collada.h"
 
-
-#include "scene/3d/spatial.h"
-#include "scene/3d/skeleton.h"
-#include "scene/3d/path.h"
+#include "editor/collada/collada.h"
+#include "editor/editor_node.h"
+#include "os/os.h"
 #include "scene/3d/camera.h"
 #include "scene/3d/light.h"
-#include "scene/animation/animation_player.h"
 #include "scene/3d/mesh_instance.h"
+#include "scene/3d/path.h"
+#include "scene/3d/skeleton.h"
+#include "scene/3d/spatial.h"
+#include "scene/animation/animation_player.h"
 #include "scene/resources/animation.h"
 #include "scene/resources/packed_scene.h"
-#include "os/os.h"
-#include "editor/collada/collada.h"
-#include "editor/editor_node.h"
 #include <iostream>
 
-
 struct ColladaImport {
 
 	Collada collada;
@@ -57,7 +55,10 @@ struct ColladaImport {
 		int bone;
 		List<int> anim_tracks;
 
-		NodeMap() { node=NULL; bone=-1; }
+		NodeMap() {
+			node = NULL;
+			bone = -1;
+		}
 	};
 
 	bool found_ambient;
@@ -68,30 +69,28 @@ struct ColladaImport {
 	bool use_mesh_builtin_materials;
 	float bake_fps;
 
-
-
-	Map<String,NodeMap> node_map; //map from collada node to engine node
-	Map<String,String> node_name_map; //map from collada node to engine node
+	Map<String, NodeMap> node_map; //map from collada node to engine node
+	Map<String, String> node_name_map; //map from collada node to engine node
 	Map<String, Ref<Mesh> > mesh_cache;
 	Map<String, Ref<Curve3D> > curve_cache;
 	Map<String, Ref<Material> > material_cache;
-	Map<Collada::Node*,Skeleton*> skeleton_map;
+	Map<Collada::Node *, Skeleton *> skeleton_map;
 
-	Map< Skeleton*, Map< String, int> > skeleton_bone_map;
+	Map<Skeleton *, Map<String, int> > skeleton_bone_map;
 
 	Set<String> valid_animated_nodes;
 	Vector<int> valid_animated_properties;
-	Map<String,bool> bones_with_animation;
+	Map<String, bool> bones_with_animation;
 
-	Error _populate_skeleton(Skeleton *p_skeleton,Collada::Node *p_node, int &r_bone, int p_parent);
+	Error _populate_skeleton(Skeleton *p_skeleton, Collada::Node *p_node, int &r_bone, int p_parent);
 	Error _create_scene_skeletons(Collada::Node *p_node);
 	Error _create_scene(Collada::Node *p_node, Spatial *p_parent);
 	Error _create_resources(Collada::Node *p_node);
-	Error _create_material(const String& p_material);
-	Error _create_mesh_surfaces(bool p_optimize, Ref<Mesh>& p_mesh, const Map<String,Collada::NodeGeometry::Material>& p_material_map, const Collada::MeshData &meshdata, const Transform& p_local_xform, const Vector<int> &bone_remap, const Collada::SkinControllerData *p_skin_data, const Collada::MorphControllerData *p_morph_data, Vector<Ref<Mesh> > p_morph_meshes=Vector<Ref<Mesh> >(), bool p_for_morph=false, bool p_use_mesh_material=false);
-	Error load(const String& p_path, int p_flags, bool p_force_make_tangents=false);
+	Error _create_material(const String &p_material);
+	Error _create_mesh_surfaces(bool p_optimize, Ref<Mesh> &p_mesh, const Map<String, Collada::NodeGeometry::Material> &p_material_map, const Collada::MeshData &meshdata, const Transform &p_local_xform, const Vector<int> &bone_remap, const Collada::SkinControllerData *p_skin_data, const Collada::MorphControllerData *p_morph_data, Vector<Ref<Mesh> > p_morph_meshes = Vector<Ref<Mesh> >(), bool p_for_morph = false, bool p_use_mesh_material = false);
+	Error load(const String &p_path, int p_flags, bool p_force_make_tangents = false);
 	void _fix_param_animation_tracks();
-	void create_animation(int p_clip,bool p_make_tracks_in_all_bones, bool p_import_value_tracks);
+	void create_animation(int p_clip, bool p_make_tracks_in_all_bones, bool p_import_value_tracks);
 	void create_animations(bool p_make_tracks_in_all_bones, bool p_import_value_tracks);
 
 	Set<String> tracks_in_clips;
@@ -101,51 +100,47 @@ struct ColladaImport {
 
 	ColladaImport() {
 
-		found_ambient=false;
-		found_directional=false;
-		force_make_tangents=false;
-		apply_mesh_xform_to_vertices=true;
-		bake_fps=15;
-
+		found_ambient = false;
+		found_directional = false;
+		force_make_tangents = false;
+		apply_mesh_xform_to_vertices = true;
+		bake_fps = 15;
 	}
 };
 
+Error ColladaImport::_populate_skeleton(Skeleton *p_skeleton, Collada::Node *p_node, int &r_bone, int p_parent) {
 
-Error ColladaImport::_populate_skeleton(Skeleton *p_skeleton,Collada::Node *p_node, int &r_bone, int p_parent) {
-
-
-	if (p_node->type!=Collada::Node::TYPE_JOINT)
+	if (p_node->type != Collada::Node::TYPE_JOINT)
 		return OK;
 
-	Collada::NodeJoint *joint = static_cast<Collada::NodeJoint*>(p_node);
+	Collada::NodeJoint *joint = static_cast<Collada::NodeJoint *>(p_node);
 
-	print_line("populating joint "+joint->name);
+	print_line("populating joint " + joint->name);
 	p_skeleton->add_bone(p_node->name);
-	if (p_parent>=0)
-		p_skeleton->set_bone_parent(r_bone,p_parent);
+	if (p_parent >= 0)
+		p_skeleton->set_bone_parent(r_bone, p_parent);
 
 	NodeMap nm;
-	nm.node=p_skeleton;
+	nm.node = p_skeleton;
 	nm.bone = r_bone;
-	node_map[p_node->id]=nm;
-	node_name_map[p_node->name]=p_node->id;
+	node_map[p_node->id] = nm;
+	node_name_map[p_node->name] = p_node->id;
 
-	skeleton_bone_map[p_skeleton][joint->sid]=r_bone;
+	skeleton_bone_map[p_skeleton][joint->sid] = r_bone;
 
 	if (collada.state.bone_rest_map.has(joint->sid)) {
 
-		p_skeleton->set_bone_rest(r_bone,collada.fix_transform(collada.state.bone_rest_map[joint->sid]));
+		p_skeleton->set_bone_rest(r_bone, collada.fix_transform(collada.state.bone_rest_map[joint->sid]));
 		//should map this bone to something for animation?
 	} else {
-		print_line("no rest: "+joint->sid);
+		print_line("no rest: " + joint->sid);
 		WARN_PRINT("Joint has no rest..");
 	}
 
-
 	int id = r_bone++;
-	for(int i=0;i<p_node->children.size();i++) {
+	for (int i = 0; i < p_node->children.size(); i++) {
 
-		Error err = _populate_skeleton(p_skeleton,p_node->children[i],r_bone,id);
+		Error err = _populate_skeleton(p_skeleton, p_node->children[i], r_bone, id);
 		if (err)
 			return err;
 	}
@@ -153,70 +148,61 @@ Error ColladaImport::_populate_skeleton(Skeleton *p_skeleton,Collada::Node *p_no
 	return OK;
 }
 
-
 void ColladaImport::_pre_process_lights(Collada::Node *p_node) {
 
+	if (p_node->type == Collada::Node::TYPE_LIGHT) {
 
-	if (p_node->type==Collada::Node::TYPE_LIGHT) {
-
-
-		Collada::NodeLight *light=static_cast<Collada::NodeLight*>(p_node);
+		Collada::NodeLight *light = static_cast<Collada::NodeLight *>(p_node);
 		if (collada.state.light_data_map.has(light->light)) {
 
 			Collada::LightData &ld = collada.state.light_data_map[light->light];
-			if (ld.mode==Collada::LightData::MODE_AMBIENT) {
-				found_ambient=true;
-				ambient=ld.color;
+			if (ld.mode == Collada::LightData::MODE_AMBIENT) {
+				found_ambient = true;
+				ambient = ld.color;
 			}
-			if (ld.mode==Collada::LightData::MODE_DIRECTIONAL) {
-				found_directional=true;
+			if (ld.mode == Collada::LightData::MODE_DIRECTIONAL) {
+				found_directional = true;
 			}
 		}
-
 	}
 
-
-	for(int i=0;i<p_node->children.size();i++)
+	for (int i = 0; i < p_node->children.size(); i++)
 		_pre_process_lights(p_node->children[i]);
 }
 
 Error ColladaImport::_create_scene_skeletons(Collada::Node *p_node) {
 
+	if (p_node->type == Collada::Node::TYPE_SKELETON) {
 
-	if (p_node->type==Collada::Node::TYPE_SKELETON) {
-
-		Skeleton *sk = memnew( Skeleton );
+		Skeleton *sk = memnew(Skeleton);
 		int bone = 0;
 
-		for(int i=0;i<p_node->children.size();i++) {
+		for (int i = 0; i < p_node->children.size(); i++) {
 
-			_populate_skeleton(sk,p_node->children[i],bone,-1);
+			_populate_skeleton(sk, p_node->children[i], bone, -1);
 		}
 		sk->localize_rests(); //after creating skeleton, rests must be localized...!
-		skeleton_map[p_node]=sk;
+		skeleton_map[p_node] = sk;
 	}
 
-
-	for(int i=0;i<p_node->children.size();i++) {
+	for (int i = 0; i < p_node->children.size(); i++) {
 
 		Error err = _create_scene_skeletons(p_node->children[i]);
 		if (err)
 			return err;
 	}
 	return OK;
-
 }
 
-
 Error ColladaImport::_create_scene(Collada::Node *p_node, Spatial *p_parent) {
 
-	Spatial * node=NULL;
+	Spatial *node = NULL;
 
-	switch(p_node->type) {
+	switch (p_node->type) {
 
 		case Collada::Node::TYPE_NODE: {
 
-			node = memnew( Spatial );
+			node = memnew(Spatial);
 		} break;
 		case Collada::Node::TYPE_JOINT: {
 
@@ -225,29 +211,29 @@ Error ColladaImport::_create_scene(Collada::Node *p_node, Spatial *p_parent) {
 		case Collada::Node::TYPE_LIGHT: {
 
 			//node = memnew( Light)
-			Collada::NodeLight *light = static_cast<Collada::NodeLight*>(p_node);
+			Collada::NodeLight *light = static_cast<Collada::NodeLight *>(p_node);
 			if (collada.state.light_data_map.has(light->light)) {
 
 				Collada::LightData &ld = collada.state.light_data_map[light->light];
 
-				if (ld.mode==Collada::LightData::MODE_AMBIENT) {
+				if (ld.mode == Collada::LightData::MODE_AMBIENT) {
 
 					if (found_directional)
 						return OK; //do nothing not needed
 
-					if (!bool(GLOBAL_DEF("collada/use_ambient",false)))
+					if (!bool(GLOBAL_DEF("collada/use_ambient", false)))
 						return OK;
 					//well, it's an ambient light..
-					Light *l = memnew( DirectionalLight );
+					Light *l = memnew(DirectionalLight);
 					//l->set_color(Light::COLOR_AMBIENT,ld.color);
 					//l->set_color(Light::COLOR_DIFFUSE,Color(0,0,0));
 					//l->set_color(Light::COLOR_SPECULAR,Color(0,0,0));
 					node = l;
 
-				} else if (ld.mode==Collada::LightData::MODE_DIRECTIONAL) {
+				} else if (ld.mode == Collada::LightData::MODE_DIRECTIONAL) {
 
 					//well, it's an ambient light..
-					Light *l = memnew( DirectionalLight );
+					Light *l = memnew(DirectionalLight);
 					/*
 					if (found_ambient) //use it here
 						l->set_color(Light::COLOR_AMBIENT,ambient);
@@ -260,10 +246,10 @@ Error ColladaImport::_create_scene(Collada::Node *p_node, Spatial *p_parent) {
 
 					Light *l;
 
-					if (ld.mode==Collada::LightData::MODE_OMNI)
-						l=memnew( OmniLight );
+					if (ld.mode == Collada::LightData::MODE_OMNI)
+						l = memnew(OmniLight);
 					else {
-						l=memnew( SpotLight );
+						l = memnew(SpotLight);
 						//l->set_parameter(Light::PARAM_SPOT_ANGLE,ld.spot_angle);
 						//l->set_parameter(Light::PARAM_SPOT_ATTENUATION,ld.spot_exp);
 					}
@@ -272,37 +258,36 @@ Error ColladaImport::_create_scene(Collada::Node *p_node, Spatial *p_parent) {
 					//l->set_color(Light::COLOR_DIFFUSE,ld.color);
 					//l->set_color(Light::COLOR_SPECULAR,Color(1,1,1));
 					//l->approximate_opengl_attenuation(ld.constant_att,ld.linear_att,ld.quad_att);
-					node=l;
+					node = l;
 				}
 
 			} else {
 
-				node = memnew( Spatial );
+				node = memnew(Spatial);
 			}
 		} break;
 		case Collada::Node::TYPE_CAMERA: {
 
-			Collada::NodeCamera *cam = static_cast<Collada::NodeCamera*>(p_node);
-			Camera *camera = memnew( Camera );
+			Collada::NodeCamera *cam = static_cast<Collada::NodeCamera *>(p_node);
+			Camera *camera = memnew(Camera);
 
 			if (collada.state.camera_data_map.has(cam->camera)) {
 
 				const Collada::CameraData &cd = collada.state.camera_data_map[cam->camera];
 
-				switch(cd.mode) {
+				switch (cd.mode) {
 
 					case Collada::CameraData::MODE_ORTHOGONAL: {
 
 						if (cd.orthogonal.y_mag) {
 
 							camera->set_keep_aspect_mode(Camera::KEEP_HEIGHT);
-							camera->set_orthogonal(cd.orthogonal.y_mag*2.0 ,cd.z_near,cd.z_far);
+							camera->set_orthogonal(cd.orthogonal.y_mag * 2.0, cd.z_near, cd.z_far);
 
 						} else if (!cd.orthogonal.y_mag && cd.orthogonal.x_mag) {
 
-
 							camera->set_keep_aspect_mode(Camera::KEEP_WIDTH);
-							camera->set_orthogonal(cd.orthogonal.x_mag*2.0,cd.z_near,cd.z_far);
+							camera->set_orthogonal(cd.orthogonal.x_mag * 2.0, cd.z_near, cd.z_far);
 						}
 
 					} break;
@@ -310,97 +295,94 @@ Error ColladaImport::_create_scene(Collada::Node *p_node, Spatial *p_parent) {
 
 						if (cd.perspective.y_fov) {
 
-							camera->set_perspective(cd.perspective.y_fov,cd.z_near,cd.z_far);
+							camera->set_perspective(cd.perspective.y_fov, cd.z_near, cd.z_far);
 
 						} else if (!cd.perspective.y_fov && cd.perspective.x_fov) {
 
-							camera->set_perspective(cd.perspective.x_fov / cd.aspect,cd.z_near,cd.z_far);
+							camera->set_perspective(cd.perspective.x_fov / cd.aspect, cd.z_near, cd.z_far);
 						}
 
 					} break;
 				}
-
 			}
 
-			node=camera;
+			node = camera;
 
 		} break;
 		case Collada::Node::TYPE_GEOMETRY: {
 
-			Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry*>(p_node);
+			Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry *>(p_node);
 
 			if (collada.state.curve_data_map.has(ng->source)) {
 
-				node = memnew( Path );
+				node = memnew(Path);
 			} else {
 				//mesh since nothing else
-				node = memnew( MeshInstance );
-				node->cast_to<MeshInstance>()->set_flag(GeometryInstance::FLAG_USE_BAKED_LIGHT,true);
+				node = memnew(MeshInstance);
+				node->cast_to<MeshInstance>()->set_flag(GeometryInstance::FLAG_USE_BAKED_LIGHT, true);
 			}
 		} break;
 		case Collada::Node::TYPE_SKELETON: {
 
-			ERR_FAIL_COND_V(!skeleton_map.has(p_node),ERR_CANT_CREATE);
+			ERR_FAIL_COND_V(!skeleton_map.has(p_node), ERR_CANT_CREATE);
 			Skeleton *sk = skeleton_map[p_node];
-			node=sk;
+			node = sk;
 		} break;
-
 	}
 
-	if (p_node->name!="")
+	if (p_node->name != "")
 		node->set_name(p_node->name);
 	NodeMap nm;
-	nm.node=node;
-	node_map[p_node->id]=nm;
-	node_name_map[p_node->name]=p_node->id;
+	nm.node = node;
+	node_map[p_node->id] = nm;
+	node_name_map[p_node->name] = p_node->id;
 	Transform xf = p_node->default_transform;
 
-	xf = collada.fix_transform( xf ) * p_node->post_transform;
+	xf = collada.fix_transform(xf) * p_node->post_transform;
 	node->set_transform(xf);
 	p_parent->add_child(node);
 	node->set_owner(scene);
 
-	if (p_node->empty_draw_type!="") {
+	if (p_node->empty_draw_type != "") {
 		node->set_meta("empty_draw_type", Variant(p_node->empty_draw_type));
 	}
-	
-	for(int i=0;i<p_node->children.size();i++) {
 
-		Error err = _create_scene(p_node->children[i],node);
+	for (int i = 0; i < p_node->children.size(); i++) {
+
+		Error err = _create_scene(p_node->children[i], node);
 		if (err)
 			return err;
 	}
 	return OK;
 }
 
+Error ColladaImport::_create_material(const String &p_target) {
 
-Error ColladaImport::_create_material(const String& p_target) {
+	ERR_FAIL_COND_V(material_cache.has(p_target), ERR_ALREADY_EXISTS);
+	ERR_FAIL_COND_V(!collada.state.material_map.has(p_target), ERR_INVALID_PARAMETER);
+	Collada::Material &src_mat = collada.state.material_map[p_target];
+	ERR_FAIL_COND_V(!collada.state.effect_map.has(src_mat.instance_effect), ERR_INVALID_PARAMETER);
+	Collada::Effect &effect = collada.state.effect_map[src_mat.instance_effect];
 
-	ERR_FAIL_COND_V(material_cache.has(p_target),ERR_ALREADY_EXISTS);
-	ERR_FAIL_COND_V(!collada.state.material_map.has(p_target),ERR_INVALID_PARAMETER);
-	Collada::Material &src_mat=collada.state.material_map[p_target];
-	ERR_FAIL_COND_V(!collada.state.effect_map.has(src_mat.instance_effect),ERR_INVALID_PARAMETER);
-	Collada::Effect &effect=collada.state.effect_map[src_mat.instance_effect];
+	Ref<FixedSpatialMaterial> material = memnew(FixedSpatialMaterial);
 
-	Ref<FixedSpatialMaterial> material= memnew( FixedSpatialMaterial );
-
-	if (src_mat.name!="")
+	if (src_mat.name != "")
 		material->set_name(src_mat.name);
-	else if (effect.name!="")
+	else if (effect.name != "")
 		material->set_name(effect.name);
 
 	// DIFFUSE
 
-	if (effect.diffuse.texture!="") {
+	if (effect.diffuse.texture != "") {
 
-		String texfile = effect.get_texture_path(effect.diffuse.texture,collada);
-		if (texfile!="") {
+		String texfile = effect.get_texture_path(effect.diffuse.texture, collada);
+		if (texfile != "") {
 
-			Ref<Texture> texture = ResourceLoader::load(texfile,"Texture");
+			Ref<Texture> texture = ResourceLoader::load(texfile, "Texture");
 			if (texture.is_valid()) {
 
-				material->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO,texture);
-				material->set_albedo(Color(1,1,1,1));
+				material->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, texture);
+				material->set_albedo(Color(1, 1, 1, 1));
 				//material->set_parameter(FixedSpatialMaterial::PARAM_DIFFUSE,Color(1,1,1,1));
 			} else {
 				missing_textures.push_back(texfile.get_file());
@@ -412,154 +394,140 @@ Error ColladaImport::_create_material(const String& p_target) {
 
 	// SPECULAR
 
-	if (effect.specular.texture!="") {
+	if (effect.specular.texture != "") {
 
-		String texfile = effect.get_texture_path(effect.specular.texture,collada);
-		if (texfile!="") {
+		String texfile = effect.get_texture_path(effect.specular.texture, collada);
+		if (texfile != "") {
 
-			Ref<Texture> texture = ResourceLoader::load(texfile,"Texture");
+			Ref<Texture> texture = ResourceLoader::load(texfile, "Texture");
 			if (texture.is_valid()) {
-				material->set_texture(FixedSpatialMaterial::TEXTURE_SPECULAR,texture);
-				material->set_specular(Color(1,1,1,1));
+				material->set_texture(FixedSpatialMaterial::TEXTURE_SPECULAR, texture);
+				material->set_specular(Color(1, 1, 1, 1));
 
 				//material->set_texture(FixedSpatialMaterial::PARAM_SPECULAR,texture);
 				//material->set_parameter(FixedSpatialMaterial::PARAM_SPECULAR,Color(1,1,1,1));
 			} else {
 				missing_textures.push_back(texfile.get_file());
 			}
-
 		}
 	} else {
 		material->set_metalness(effect.specular.color.get_v());
 	}
 
-
 	// EMISSION
 
-	if (effect.emission.texture!="") {
+	if (effect.emission.texture != "") {
 
-		String texfile = effect.get_texture_path(effect.emission.texture,collada);
-		if (texfile!="") {
+		String texfile = effect.get_texture_path(effect.emission.texture, collada);
+		if (texfile != "") {
 
-			Ref<Texture> texture = ResourceLoader::load(texfile,"Texture");
+			Ref<Texture> texture = ResourceLoader::load(texfile, "Texture");
 			if (texture.is_valid()) {
 
-				material->set_feature(FixedSpatialMaterial::FEATURE_EMISSION,true);
-				material->set_texture(FixedSpatialMaterial::TEXTURE_EMISSION,texture);
-				material->set_emission(Color(1,1,1,1));
+				material->set_feature(FixedSpatialMaterial::FEATURE_EMISSION, true);
+				material->set_texture(FixedSpatialMaterial::TEXTURE_EMISSION, texture);
+				material->set_emission(Color(1, 1, 1, 1));
 
 				//material->set_parameter(FixedSpatialMaterial::PARAM_EMISSION,Color(1,1,1,1));
-			}else {
+			} else {
 				missing_textures.push_back(texfile.get_file());
 			}
-
 		}
 	} else {
-		if (effect.emission.color!=Color()) {
-			material->set_feature(FixedSpatialMaterial::FEATURE_EMISSION,true);
+		if (effect.emission.color != Color()) {
+			material->set_feature(FixedSpatialMaterial::FEATURE_EMISSION, true);
 			material->set_emission(effect.emission.color);
 		}
 	}
 
 	// NORMAL
 
-	if (effect.bump.texture!="") {
+	if (effect.bump.texture != "") {
 
-		String texfile = effect.get_texture_path(effect.bump.texture,collada);
-		if (texfile!="") {
+		String texfile = effect.get_texture_path(effect.bump.texture, collada);
+		if (texfile != "") {
 
-			Ref<Texture> texture = ResourceLoader::load(texfile,"Texture");
+			Ref<Texture> texture = ResourceLoader::load(texfile, "Texture");
 			if (texture.is_valid()) {
-				material->set_feature(FixedSpatialMaterial::FEATURE_NORMAL_MAPPING,true);
-				material->set_texture(FixedSpatialMaterial::TEXTURE_NORMAL,texture);
+				material->set_feature(FixedSpatialMaterial::FEATURE_NORMAL_MAPPING, true);
+				material->set_texture(FixedSpatialMaterial::TEXTURE_NORMAL, texture);
 				//material->set_emission(Color(1,1,1,1));
 
 				//material->set_texture(FixedSpatialMaterial::PARAM_NORMAL,texture);
-			}else {
+			} else {
 				//missing_textures.push_back(texfile.get_file());
 			}
-
 		}
 	}
 
-
-	float roughness = Math::sqrt(1.0-((Math::log(effect.shininess)/Math::log(2.0))/8.0)); //not very right..
+	float roughness = Math::sqrt(1.0 - ((Math::log(effect.shininess) / Math::log(2.0)) / 8.0)); //not very right..
 	material->set_roughness(roughness);
 
 	if (effect.double_sided) {
 		material->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED);
 	}
-	material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED,effect.unshaded);
-
+	material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, effect.unshaded);
 
-
-	material_cache[p_target]=material;
+	material_cache[p_target] = material;
 	return OK;
 }
 
-
-static void _generate_normals(const PoolVector<int>& p_indices,const PoolVector<Vector3>& p_vertices,PoolVector<Vector3>&r_normals) {
-
+static void _generate_normals(const PoolVector<int> &p_indices, const PoolVector<Vector3> &p_vertices, PoolVector<Vector3> &r_normals) {
 
 	r_normals.resize(p_vertices.size());
 	PoolVector<Vector3>::Write narrayw = r_normals.write();
 
-	int iacount=p_indices.size()/3;
+	int iacount = p_indices.size() / 3;
 	PoolVector<int>::Read index_arrayr = p_indices.read();
 	PoolVector<Vector3>::Read vertex_arrayr = p_vertices.read();
 
-	for(int idx=0;idx<iacount;idx++) {
+	for (int idx = 0; idx < iacount; idx++) {
 
-		Vector3 v[3]={
-			vertex_arrayr[index_arrayr[idx*3+0]],
-			vertex_arrayr[index_arrayr[idx*3+1]],
-			vertex_arrayr[index_arrayr[idx*3+2]]
+		Vector3 v[3] = {
+			vertex_arrayr[index_arrayr[idx * 3 + 0]],
+			vertex_arrayr[index_arrayr[idx * 3 + 1]],
+			vertex_arrayr[index_arrayr[idx * 3 + 2]]
 		};
 
-		Vector3 normal = Plane(v[0],v[1],v[2]).normal;
+		Vector3 normal = Plane(v[0], v[1], v[2]).normal;
 
-		narrayw[index_arrayr[idx*3+0]]+=normal;
-		narrayw[index_arrayr[idx*3+1]]+=normal;
-		narrayw[index_arrayr[idx*3+2]]+=normal;
+		narrayw[index_arrayr[idx * 3 + 0]] += normal;
+		narrayw[index_arrayr[idx * 3 + 1]] += normal;
+		narrayw[index_arrayr[idx * 3 + 2]] += normal;
 	}
 
-	int vlen=p_vertices.size();
+	int vlen = p_vertices.size();
 
-	for(int idx=0;idx<vlen;idx++) {
+	for (int idx = 0; idx < vlen; idx++) {
 		narrayw[idx].normalize();
 	}
-
 }
 
+static void _generate_tangents_and_binormals(const PoolVector<int> &p_indices, const PoolVector<Vector3> &p_vertices, const PoolVector<Vector3> &p_uvs, const PoolVector<Vector3> &p_normals, PoolVector<real_t> &r_tangents) {
 
-static void _generate_tangents_and_binormals(const PoolVector<int>& p_indices,const PoolVector<Vector3>& p_vertices,const PoolVector<Vector3>& p_uvs,const PoolVector<Vector3>& p_normals,PoolVector<real_t>&r_tangents) {
-
-	int vlen=p_vertices.size();
+	int vlen = p_vertices.size();
 
 	Vector<Vector3> tangents;
 	tangents.resize(vlen);
 	Vector<Vector3> binormals;
 	binormals.resize(vlen);
 
-
-	int iacount=p_indices.size()/3;
+	int iacount = p_indices.size() / 3;
 
 	PoolVector<int>::Read index_arrayr = p_indices.read();
 	PoolVector<Vector3>::Read vertex_arrayr = p_vertices.read();
 	PoolVector<Vector3>::Read narrayr = p_normals.read();
 	PoolVector<Vector3>::Read uvarrayr = p_uvs.read();
 
+	for (int idx = 0; idx < iacount; idx++) {
 
-	for(int idx=0;idx<iacount;idx++) {
+		Vector3 v1 = vertex_arrayr[index_arrayr[idx * 3 + 0]];
+		Vector3 v2 = vertex_arrayr[index_arrayr[idx * 3 + 1]];
+		Vector3 v3 = vertex_arrayr[index_arrayr[idx * 3 + 2]];
 
-
-		Vector3 v1 = vertex_arrayr[ index_arrayr[idx*3+0] ];
-		Vector3 v2 = vertex_arrayr[ index_arrayr[idx*3+1] ];
-		Vector3 v3 = vertex_arrayr[ index_arrayr[idx*3+2] ];
-
-		Vector3 w1 = uvarrayr[ index_arrayr[idx*3+0] ];
-		Vector3 w2 = uvarrayr[ index_arrayr[idx*3+1] ];
-		Vector3 w3 = uvarrayr[ index_arrayr[idx*3+2] ];
+		Vector3 w1 = uvarrayr[index_arrayr[idx * 3 + 0]];
+		Vector3 w2 = uvarrayr[index_arrayr[idx * 3 + 1]];
+		Vector3 w3 = uvarrayr[index_arrayr[idx * 3 + 2]];
 
 		real_t x1 = v2.x - v1.x;
 		real_t x2 = v3.x - v1.x;
@@ -573,169 +541,165 @@ static void _generate_tangents_and_binormals(const PoolVector<int>& p_indices,co
 		real_t t1 = w2.y - w1.y;
 		real_t t2 = w3.y - w1.y;
 
-		real_t r  = (s1 * t2 - s2 * t1);
+		real_t r = (s1 * t2 - s2 * t1);
 
 		Vector3 tangent;
 		Vector3 binormal;
 
-		if (r==0) {
+		if (r == 0) {
 
-			binormal=Vector3();
-			tangent=Vector3();
+			binormal = Vector3();
+			tangent = Vector3();
 		} else {
 			tangent = Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r,
-			(t2 * z1 - t1 * z2) * r).normalized();
+					(t2 * z1 - t1 * z2) * r)
+							  .normalized();
 			binormal = Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r,
-			(s1 * z2 - s2 * z1) * r).normalized();
+					(s1 * z2 - s2 * z1) * r)
+							   .normalized();
 		}
 
-		tangents[ index_arrayr[idx*3+0] ]+=tangent;
-		binormals[ index_arrayr[idx*3+0] ]+=binormal;
-		tangents[ index_arrayr[idx*3+1] ]+=tangent;
-		binormals[ index_arrayr[idx*3+1] ]+=binormal;
-		tangents[ index_arrayr[idx*3+2] ]+=tangent;
-		binormals[ index_arrayr[idx*3+2] ]+=binormal;
+		tangents[index_arrayr[idx * 3 + 0]] += tangent;
+		binormals[index_arrayr[idx * 3 + 0]] += binormal;
+		tangents[index_arrayr[idx * 3 + 1]] += tangent;
+		binormals[index_arrayr[idx * 3 + 1]] += binormal;
+		tangents[index_arrayr[idx * 3 + 2]] += tangent;
+		binormals[index_arrayr[idx * 3 + 2]] += binormal;
 
 		//print_line(itos(idx)+" tangent: "+tangent);
 		//print_line(itos(idx)+" binormal: "+binormal);
 	}
 
-	r_tangents.resize(vlen*4);
+	r_tangents.resize(vlen * 4);
 	PoolVector<real_t>::Write tarrayw = r_tangents.write();
 
-	for(int idx=0;idx<vlen;idx++) {
+	for (int idx = 0; idx < vlen; idx++) {
 		Vector3 tangent = tangents[idx];
 		Vector3 bingen = narrayr[idx].cross(tangent);
 		float dir;
-		if (bingen.dot(binormals[idx]) < 0 )
-			dir=-1.0;
+		if (bingen.dot(binormals[idx]) < 0)
+			dir = -1.0;
 		else
-			dir=+1.0;
+			dir = +1.0;
 
-		tarrayw[idx*4+0]=tangent.x;
-		tarrayw[idx*4+1]=tangent.y;
-		tarrayw[idx*4+2]=tangent.z;
-		tarrayw[idx*4+3]=dir;
+		tarrayw[idx * 4 + 0] = tangent.x;
+		tarrayw[idx * 4 + 1] = tangent.y;
+		tarrayw[idx * 4 + 2] = tangent.z;
+		tarrayw[idx * 4 + 3] = dir;
 	}
 }
 
-Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,const Map<String,Collada::NodeGeometry::Material>& p_material_map,const Collada::MeshData &meshdata,const Transform& p_local_xform,const Vector<int> &bone_remap, const Collada::SkinControllerData *skin_controller, const Collada::MorphControllerData *p_morph_data,Vector<Ref<Mesh> > p_morph_meshes,bool p_for_morph,bool p_use_mesh_material) {
-
+Error ColladaImport::_create_mesh_surfaces(bool p_optimize, Ref<Mesh> &p_mesh, const Map<String, Collada::NodeGeometry::Material> &p_material_map, const Collada::MeshData &meshdata, const Transform &p_local_xform, const Vector<int> &bone_remap, const Collada::SkinControllerData *skin_controller, const Collada::MorphControllerData *p_morph_data, Vector<Ref<Mesh> > p_morph_meshes, bool p_for_morph, bool p_use_mesh_material) {
 
-	bool local_xform_mirror=p_local_xform.basis.determinant() < 0;
+	bool local_xform_mirror = p_local_xform.basis.determinant() < 0;
 
 	if (p_morph_data) {
 
 		//add morphie target
-		ERR_FAIL_COND_V( !p_morph_data->targets.has("MORPH_TARGET"), ERR_INVALID_DATA );
+		ERR_FAIL_COND_V(!p_morph_data->targets.has("MORPH_TARGET"), ERR_INVALID_DATA);
 		String mt = p_morph_data->targets["MORPH_TARGET"];
-		ERR_FAIL_COND_V( !p_morph_data->sources.has(mt), ERR_INVALID_DATA);
+		ERR_FAIL_COND_V(!p_morph_data->sources.has(mt), ERR_INVALID_DATA);
 		int morph_targets = p_morph_data->sources[mt].sarray.size();
-		for(int i=0;i<morph_targets;i++) {
+		for (int i = 0; i < morph_targets; i++) {
 
 			String target = p_morph_data->sources[mt].sarray[i];
-			ERR_FAIL_COND_V( !collada.state.mesh_data_map.has(target), ERR_INVALID_DATA );
+			ERR_FAIL_COND_V(!collada.state.mesh_data_map.has(target), ERR_INVALID_DATA);
 			String name = collada.state.mesh_data_map[target].name;
 
 			p_mesh->add_blend_shape(name);
 		}
-		if (p_morph_data->mode=="RELATIVE")
+		if (p_morph_data->mode == "RELATIVE")
 			p_mesh->set_blend_shape_mode(Mesh::BLEND_SHAPE_MODE_RELATIVE);
-		else if (p_morph_data->mode=="NORMALIZED")
+		else if (p_morph_data->mode == "NORMALIZED")
 			p_mesh->set_blend_shape_mode(Mesh::BLEND_SHAPE_MODE_NORMALIZED);
 	}
 
+	int surface = 0;
+	for (int p_i = 0; p_i < meshdata.primitives.size(); p_i++) {
 
-	int surface=0;
-	for(int p_i = 0; p_i < meshdata.primitives.size(); p_i ++ ) {
-
-
-
-		const Collada::MeshData::Primitives& p = meshdata.primitives[p_i];
+		const Collada::MeshData::Primitives &p = meshdata.primitives[p_i];
 
 		/* VERTEX SOURCE */
-		ERR_FAIL_COND_V(!p.sources.has("VERTEX"),ERR_INVALID_DATA);
+		ERR_FAIL_COND_V(!p.sources.has("VERTEX"), ERR_INVALID_DATA);
 
 		String vertex_src_id = p.sources["VERTEX"].source;
-		int vertex_ofs=p.sources["VERTEX"].offset;
+		int vertex_ofs = p.sources["VERTEX"].offset;
 
-		ERR_FAIL_COND_V(!meshdata.vertices.has(vertex_src_id),ERR_INVALID_DATA);
+		ERR_FAIL_COND_V(!meshdata.vertices.has(vertex_src_id), ERR_INVALID_DATA);
 
-		ERR_FAIL_COND_V(!meshdata.vertices[vertex_src_id].sources.has("POSITION"),ERR_INVALID_DATA);
+		ERR_FAIL_COND_V(!meshdata.vertices[vertex_src_id].sources.has("POSITION"), ERR_INVALID_DATA);
 		String position_src_id = meshdata.vertices[vertex_src_id].sources["POSITION"];
 
-		ERR_FAIL_COND_V(!meshdata.sources.has(position_src_id),ERR_INVALID_DATA);
+		ERR_FAIL_COND_V(!meshdata.sources.has(position_src_id), ERR_INVALID_DATA);
 
-		const Collada::MeshData::Source *vertex_src=&meshdata.sources[position_src_id];
+		const Collada::MeshData::Source *vertex_src = &meshdata.sources[position_src_id];
 
 		/* NORMAL SOURCE */
 
-		const Collada::MeshData::Source *normal_src=NULL;
-		int normal_ofs=0;
+		const Collada::MeshData::Source *normal_src = NULL;
+		int normal_ofs = 0;
 
 		if (p.sources.has("NORMAL")) {
 
 			String normal_source_id = p.sources["NORMAL"].source;
 			normal_ofs = p.sources["NORMAL"].offset;
-			ERR_FAIL_COND_V( !meshdata.sources.has(normal_source_id),ERR_INVALID_DATA);
-			normal_src=&meshdata.sources[normal_source_id];
+			ERR_FAIL_COND_V(!meshdata.sources.has(normal_source_id), ERR_INVALID_DATA);
+			normal_src = &meshdata.sources[normal_source_id];
 		}
 
-		const Collada::MeshData::Source *binormal_src=NULL;
-		int binormal_ofs=0;
+		const Collada::MeshData::Source *binormal_src = NULL;
+		int binormal_ofs = 0;
 
 		if (p.sources.has("TEXBINORMAL")) {
 
 			String binormal_source_id = p.sources["TEXBINORMAL"].source;
 			binormal_ofs = p.sources["TEXBINORMAL"].offset;
-			ERR_FAIL_COND_V( !meshdata.sources.has(binormal_source_id),ERR_INVALID_DATA);
-			binormal_src=&meshdata.sources[binormal_source_id];
+			ERR_FAIL_COND_V(!meshdata.sources.has(binormal_source_id), ERR_INVALID_DATA);
+			binormal_src = &meshdata.sources[binormal_source_id];
 		}
 
-		const Collada::MeshData::Source *tangent_src=NULL;
-		int tangent_ofs=0;
+		const Collada::MeshData::Source *tangent_src = NULL;
+		int tangent_ofs = 0;
 
 		if (p.sources.has("TEXTANGENT")) {
 
 			String tangent_source_id = p.sources["TEXTANGENT"].source;
 			tangent_ofs = p.sources["TEXTANGENT"].offset;
-			ERR_FAIL_COND_V( !meshdata.sources.has(tangent_source_id),ERR_INVALID_DATA);
-			tangent_src=&meshdata.sources[tangent_source_id];
+			ERR_FAIL_COND_V(!meshdata.sources.has(tangent_source_id), ERR_INVALID_DATA);
+			tangent_src = &meshdata.sources[tangent_source_id];
 		}
 
-
-		const Collada::MeshData::Source *uv_src=NULL;
-		int uv_ofs=0;
+		const Collada::MeshData::Source *uv_src = NULL;
+		int uv_ofs = 0;
 
 		if (p.sources.has("TEXCOORD0")) {
 
 			String uv_source_id = p.sources["TEXCOORD0"].source;
 			uv_ofs = p.sources["TEXCOORD0"].offset;
-			ERR_FAIL_COND_V( !meshdata.sources.has(uv_source_id),ERR_INVALID_DATA);
-			uv_src=&meshdata.sources[uv_source_id];
+			ERR_FAIL_COND_V(!meshdata.sources.has(uv_source_id), ERR_INVALID_DATA);
+			uv_src = &meshdata.sources[uv_source_id];
 		}
 
-		const Collada::MeshData::Source *uv2_src=NULL;
-		int uv2_ofs=0;
+		const Collada::MeshData::Source *uv2_src = NULL;
+		int uv2_ofs = 0;
 
 		if (p.sources.has("TEXCOORD1")) {
 
 			String uv2_source_id = p.sources["TEXCOORD1"].source;
 			uv2_ofs = p.sources["TEXCOORD1"].offset;
-			ERR_FAIL_COND_V( !meshdata.sources.has(uv2_source_id),ERR_INVALID_DATA);
-			uv2_src=&meshdata.sources[uv2_source_id];
+			ERR_FAIL_COND_V(!meshdata.sources.has(uv2_source_id), ERR_INVALID_DATA);
+			uv2_src = &meshdata.sources[uv2_source_id];
 		}
 
-
-		const Collada::MeshData::Source *color_src=NULL;
-		int color_ofs=0;
+		const Collada::MeshData::Source *color_src = NULL;
+		int color_ofs = 0;
 
 		if (p.sources.has("COLOR")) {
 
 			String color_source_id = p.sources["COLOR"].source;
 			color_ofs = p.sources["COLOR"].offset;
-			ERR_FAIL_COND_V( !meshdata.sources.has(color_source_id), ERR_INVALID_DATA );
-			color_src=&meshdata.sources[color_source_id];
+			ERR_FAIL_COND_V(!meshdata.sources.has(color_source_id), ERR_INVALID_DATA);
+			color_src = &meshdata.sources[color_source_id];
 		}
 
 		//find largest source..
@@ -744,14 +708,14 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 		/* ADD WEIGHTS IF EXIST */
 		/************************/
 
-		Map<int,Vector<Collada::Vertex::Weight> > pre_weights;
+		Map<int, Vector<Collada::Vertex::Weight> > pre_weights;
 
-		bool has_weights=false;
+		bool has_weights = false;
 
 		if (skin_controller) {
 
-			const Collada::SkinControllerData::Source *weight_src=NULL;
-			int weight_ofs=0;
+			const Collada::SkinControllerData::Source *weight_src = NULL;
+			int weight_ofs = 0;
 
 			if (skin_controller->weights.sources.has("WEIGHT")) {
 
@@ -760,11 +724,10 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 				if (skin_controller->sources.has(weight_id)) {
 
 					weight_src = &skin_controller->sources[weight_id];
-
 				}
 			}
 
-			int joint_ofs=0;
+			int joint_ofs = 0;
 
 			if (skin_controller->weights.sources.has("JOINT")) {
 
@@ -773,67 +736,62 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 
 			//should be OK, given this was pre-checked.
 
-			int index_ofs=0;
+			int index_ofs = 0;
 			int wstride = skin_controller->weights.sources.size();
-			for(int w_i=0;w_i<skin_controller->weights.sets.size();w_i++) {
+			for (int w_i = 0; w_i < skin_controller->weights.sets.size(); w_i++) {
 
 				int amount = skin_controller->weights.sets[w_i];
 
 				Vector<Collada::Vertex::Weight> weights;
 
-				for (int a_i=0;a_i<amount;a_i++) {
+				for (int a_i = 0; a_i < amount; a_i++) {
 
 					Collada::Vertex::Weight w;
 
-					int read_from = index_ofs+a_i*wstride;
-					ERR_FAIL_INDEX_V(read_from+wstride-1,skin_controller->weights.indices.size(),ERR_INVALID_DATA);
-					int weight_index = skin_controller->weights.indices[read_from+weight_ofs];
-					ERR_FAIL_INDEX_V(weight_index,weight_src->array.size(),ERR_INVALID_DATA);
+					int read_from = index_ofs + a_i * wstride;
+					ERR_FAIL_INDEX_V(read_from + wstride - 1, skin_controller->weights.indices.size(), ERR_INVALID_DATA);
+					int weight_index = skin_controller->weights.indices[read_from + weight_ofs];
+					ERR_FAIL_INDEX_V(weight_index, weight_src->array.size(), ERR_INVALID_DATA);
 
 					w.weight = weight_src->array[weight_index];
 
-					int bone_index = skin_controller->weights.indices[read_from+joint_ofs];
-					if (bone_index==-1)
+					int bone_index = skin_controller->weights.indices[read_from + joint_ofs];
+					if (bone_index == -1)
 						continue; //ignore this weight (refers to bind shape)
-					ERR_FAIL_INDEX_V(bone_index,bone_remap.size(),ERR_INVALID_DATA);
-
-					w.bone_idx=bone_remap[bone_index];
+					ERR_FAIL_INDEX_V(bone_index, bone_remap.size(), ERR_INVALID_DATA);
 
+					w.bone_idx = bone_remap[bone_index];
 
 					weights.push_back(w);
 				}
 
 				/* FIX WEIGHTS */
 
-
-
 				weights.sort();
 
-				if (weights.size()>4) {
+				if (weights.size() > 4) {
 					//cap to 4 and make weights add up 1
 					weights.resize(4);
-
 				}
 
 				//make sure weights allways add up to 1
-				float total=0;
-				for(int i=0;i<weights.size();i++)
-					total+=weights[i].weight;
+				float total = 0;
+				for (int i = 0; i < weights.size(); i++)
+					total += weights[i].weight;
 				if (total)
-					for(int i=0;i<weights.size();i++)
-						weights[i].weight/=total;
+					for (int i = 0; i < weights.size(); i++)
+						weights[i].weight /= total;
 
-				if (weights.size()==0 || total==0) { //if nothing, add a weight to bone 0
+				if (weights.size() == 0 || total == 0) { //if nothing, add a weight to bone 0
 					//no weights assigned
 					Collada::Vertex::Weight w;
-					w.bone_idx=0;
-					w.weight=1.0;
+					w.bone_idx = 0;
+					w.weight = 1.0;
 					weights.clear();
 					weights.push_back(w);
-
 				}
 
-				pre_weights[w_i]=weights;
+				pre_weights[w_i] = weights;
 
 				/*
 				for(Set<int>::Element *E=vertex_map[w_i].front();E;E=E->next()) {
@@ -845,16 +803,11 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 
 				}*/
 
-
-
-
-				index_ofs+=wstride*amount;
-
+				index_ofs += wstride * amount;
 			}
 
 			//vertices need to be localized
-			has_weights=true;
-
+			has_weights = true;
 		}
 
 		Set<Collada::Vertex> vertex_set; //vertex set will be the vertices
@@ -870,131 +823,121 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 		// This is, however, more incompatible with standard video cards, so arrays must be converted.
 		// Must convert to GL/DX format.
 
-		int _prim_ofs=0;
-		int vertidx=0;
-		for(int p_i=0;p_i<p.count;p_i++) {
-
+		int _prim_ofs = 0;
+		int vertidx = 0;
+		for (int p_i = 0; p_i < p.count; p_i++) {
 
 			int amount;
 			if (p.polygons.size()) {
 
-				ERR_FAIL_INDEX_V(p_i,p.polygons.size(),ERR_INVALID_DATA);
-				amount=p.polygons[p_i];
+				ERR_FAIL_INDEX_V(p_i, p.polygons.size(), ERR_INVALID_DATA);
+				amount = p.polygons[p_i];
 			} else {
-				amount=3; //triangles;
+				amount = 3; //triangles;
 			}
 
 			//COLLADA_PRINT("amount: "+itos(amount));
 
-			int prev2[2]={0,0};
+			int prev2[2] = { 0, 0 };
 
-			for(int j=0;j<amount;j++) {
+			for (int j = 0; j < amount; j++) {
 
-				int src=_prim_ofs;
+				int src = _prim_ofs;
 				//_prim_ofs+=p.sources.size()
 
-				ERR_FAIL_INDEX_V(src,p.indices.size(),ERR_INVALID_DATA);
+				ERR_FAIL_INDEX_V(src, p.indices.size(), ERR_INVALID_DATA);
 
 				Collada::Vertex vertex;
 				if (!p_optimize)
-					vertex.uid=vertidx++;
-
+					vertex.uid = vertidx++;
 
-
-				int vertex_index=p.indices[src+vertex_ofs]; //used for index field (later used by controllers)
-				int vertex_pos = (vertex_src->stride?vertex_src->stride:3) * vertex_index;
-				ERR_FAIL_INDEX_V(vertex_pos,vertex_src->array.size(),ERR_INVALID_DATA);
-				vertex.vertex=Vector3(vertex_src->array[vertex_pos+0],vertex_src->array[vertex_pos+1],vertex_src->array[vertex_pos+2]);
+				int vertex_index = p.indices[src + vertex_ofs]; //used for index field (later used by controllers)
+				int vertex_pos = (vertex_src->stride ? vertex_src->stride : 3) * vertex_index;
+				ERR_FAIL_INDEX_V(vertex_pos, vertex_src->array.size(), ERR_INVALID_DATA);
+				vertex.vertex = Vector3(vertex_src->array[vertex_pos + 0], vertex_src->array[vertex_pos + 1], vertex_src->array[vertex_pos + 2]);
 
 				if (pre_weights.has(vertex_index)) {
-					vertex.weights=pre_weights[vertex_index];
+					vertex.weights = pre_weights[vertex_index];
 				}
 
 				if (normal_src) {
 
-
-
-					int normal_pos = (normal_src->stride?normal_src->stride:3) * p.indices[src+normal_ofs];
-					ERR_FAIL_INDEX_V(normal_pos,normal_src->array.size(),ERR_INVALID_DATA);
-					vertex.normal=Vector3(normal_src->array[normal_pos+0],normal_src->array[normal_pos+1],normal_src->array[normal_pos+2]);
-					vertex.normal=vertex.normal.snapped(0.001);
-
+					int normal_pos = (normal_src->stride ? normal_src->stride : 3) * p.indices[src + normal_ofs];
+					ERR_FAIL_INDEX_V(normal_pos, normal_src->array.size(), ERR_INVALID_DATA);
+					vertex.normal = Vector3(normal_src->array[normal_pos + 0], normal_src->array[normal_pos + 1], normal_src->array[normal_pos + 2]);
+					vertex.normal = vertex.normal.snapped(0.001);
 
 					if (tangent_src && binormal_src) {
 
-						int binormal_pos = (binormal_src->stride?binormal_src->stride:3) * p.indices[src+binormal_ofs];
-						ERR_FAIL_INDEX_V(binormal_pos,binormal_src->array.size(),ERR_INVALID_DATA);
-						Vector3 binormal =Vector3(binormal_src->array[binormal_pos+0],binormal_src->array[binormal_pos+1],binormal_src->array[binormal_pos+2]);
+						int binormal_pos = (binormal_src->stride ? binormal_src->stride : 3) * p.indices[src + binormal_ofs];
+						ERR_FAIL_INDEX_V(binormal_pos, binormal_src->array.size(), ERR_INVALID_DATA);
+						Vector3 binormal = Vector3(binormal_src->array[binormal_pos + 0], binormal_src->array[binormal_pos + 1], binormal_src->array[binormal_pos + 2]);
 
-						int tangent_pos = (tangent_src->stride?tangent_src->stride:3) * p.indices[src+tangent_ofs];
-						ERR_FAIL_INDEX_V(tangent_pos,tangent_src->array.size(),ERR_INVALID_DATA);
-						Vector3 tangent =Vector3(tangent_src->array[tangent_pos+0],tangent_src->array[tangent_pos+1],tangent_src->array[tangent_pos+2]);
+						int tangent_pos = (tangent_src->stride ? tangent_src->stride : 3) * p.indices[src + tangent_ofs];
+						ERR_FAIL_INDEX_V(tangent_pos, tangent_src->array.size(), ERR_INVALID_DATA);
+						Vector3 tangent = Vector3(tangent_src->array[tangent_pos + 0], tangent_src->array[tangent_pos + 1], tangent_src->array[tangent_pos + 2]);
 
-						vertex.tangent.normal=tangent;
-						vertex.tangent.d= vertex.normal.cross(tangent).dot(binormal) > 0 ? 1 : -1;
+						vertex.tangent.normal = tangent;
+						vertex.tangent.d = vertex.normal.cross(tangent).dot(binormal) > 0 ? 1 : -1;
 					}
-
 				}
 
-
 				if (uv_src) {
 
-					int uv_pos = (uv_src->stride?uv_src->stride:2) * p.indices[src+uv_ofs];
-					ERR_FAIL_INDEX_V(uv_pos,uv_src->array.size(),ERR_INVALID_DATA);
-					vertex.uv=Vector3(uv_src->array[uv_pos+0],1.0-uv_src->array[uv_pos+1],0);
+					int uv_pos = (uv_src->stride ? uv_src->stride : 2) * p.indices[src + uv_ofs];
+					ERR_FAIL_INDEX_V(uv_pos, uv_src->array.size(), ERR_INVALID_DATA);
+					vertex.uv = Vector3(uv_src->array[uv_pos + 0], 1.0 - uv_src->array[uv_pos + 1], 0);
 				}
 
 				if (uv2_src) {
 
-					int uv2_pos = (uv2_src->stride?uv2_src->stride:2) * p.indices[src+uv2_ofs];
-					ERR_FAIL_INDEX_V(uv2_pos,uv2_src->array.size(),ERR_INVALID_DATA);
-					vertex.uv2=Vector3(uv2_src->array[uv2_pos+0],1.0-uv2_src->array[uv2_pos+1],0);
+					int uv2_pos = (uv2_src->stride ? uv2_src->stride : 2) * p.indices[src + uv2_ofs];
+					ERR_FAIL_INDEX_V(uv2_pos, uv2_src->array.size(), ERR_INVALID_DATA);
+					vertex.uv2 = Vector3(uv2_src->array[uv2_pos + 0], 1.0 - uv2_src->array[uv2_pos + 1], 0);
 				}
 
 				if (color_src) {
 
-					int color_pos = (color_src->stride?color_src->stride:3) * p.indices[src+color_ofs]; // colors are RGB in collada..
-					ERR_FAIL_INDEX_V(color_pos,color_src->array.size(),ERR_INVALID_DATA);
-					vertex.color=Color(color_src->array[color_pos+0],color_src->array[color_pos+1],color_src->array[color_pos+2],(color_src->stride>3)?color_src->array[color_pos+3]:1.0);
-
+					int color_pos = (color_src->stride ? color_src->stride : 3) * p.indices[src + color_ofs]; // colors are RGB in collada..
+					ERR_FAIL_INDEX_V(color_pos, color_src->array.size(), ERR_INVALID_DATA);
+					vertex.color = Color(color_src->array[color_pos + 0], color_src->array[color_pos + 1], color_src->array[color_pos + 2], (color_src->stride > 3) ? color_src->array[color_pos + 3] : 1.0);
 				}
 
 #ifndef NO_UP_AXIS_SWAP
-				if (collada.state.up_axis==Vector3::AXIS_Z) {
+				if (collada.state.up_axis == Vector3::AXIS_Z) {
 
-					SWAP( vertex.vertex.z, vertex.vertex.y );
+					SWAP(vertex.vertex.z, vertex.vertex.y);
 					vertex.vertex.z = -vertex.vertex.z;
-					SWAP( vertex.normal.z, vertex.normal.y );
+					SWAP(vertex.normal.z, vertex.normal.y);
 					vertex.normal.z = -vertex.normal.z;
-					SWAP( vertex.tangent.normal.z, vertex.tangent.normal.y );
+					SWAP(vertex.tangent.normal.z, vertex.tangent.normal.y);
 					vertex.tangent.normal.z = -vertex.tangent.normal.z;
-
 				}
 
 #endif
 
 				vertex.fix_unit_scale(collada);
-				int index=0;
+				int index = 0;
 				//COLLADA_PRINT("vertex: "+vertex.vertex);
 
 				if (vertex_set.has(vertex)) {
 
-					index=vertex_set.find(vertex)->get().idx;
+					index = vertex_set.find(vertex)->get().idx;
 				} else {
 
-					index=vertex_set.size();
-					vertex.idx=index;
+					index = vertex_set.size();
+					vertex.idx = index;
 					vertex_set.insert(vertex);
 				}
 
-			/*	if (!vertex_map.has(vertex_index))
+				/*	if (!vertex_map.has(vertex_index))
 					vertex_map[vertex_index]=Set<int>();
 				vertex_map[vertex_index].insert(index); //should be outside..*/
 				//build triangles if needed
-				if (j==0)
-					prev2[0]=index;
+				if (j == 0)
+					prev2[0] = index;
 
-				if (j>=2) {
+				if (j >= 2) {
 					//insert indices in reverse order (collada uses CCW as frontface)
 					if (local_xform_mirror) {
 
@@ -1009,32 +952,28 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 					}
 				}
 
-				prev2[1]=index;
-				_prim_ofs+=p.vertex_size;
+				prev2[1] = index;
+				_prim_ofs += p.vertex_size;
 			}
-
 		}
 
-
-
 		Vector<Collada::Vertex> vertex_array; //there we go, vertex array
 
 		vertex_array.resize(vertex_set.size());
-		for(Set<Collada::Vertex>::Element *F=vertex_set.front();F;F=F->next()) {
+		for (Set<Collada::Vertex>::Element *F = vertex_set.front(); F; F = F->next()) {
 
-			vertex_array[F->get().idx]=F->get();
+			vertex_array[F->get().idx] = F->get();
 		}
 
-
 		if (has_weights) {
 
 			//if skeleton, localize
 			Transform local_xform = p_local_xform;
-			for(int i=0;i<vertex_array.size();i++) {
+			for (int i = 0; i < vertex_array.size(); i++) {
 
-				vertex_array[i].vertex=local_xform.xform(vertex_array[i].vertex);
-				vertex_array[i].normal=local_xform.basis.xform(vertex_array[i].normal).normalized();
-				vertex_array[i].tangent.normal=local_xform.basis.xform(vertex_array[i].tangent.normal).normalized();
+				vertex_array[i].vertex = local_xform.xform(vertex_array[i].vertex);
+				vertex_array[i].normal = local_xform.basis.xform(vertex_array[i].normal).normalized();
+				vertex_array[i].tangent.normal = local_xform.basis.xform(vertex_array[i].tangent.normal).normalized();
 				if (local_xform_mirror) {
 					//i shouldn't do this? wtf?
 					//vertex_array[i].normal*=-1.0;
@@ -1043,51 +982,46 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 			}
 		}
 
-
 		PoolVector<int> index_array;
 		index_array.resize(indices_list.size());
 		PoolVector<int>::Write index_arrayw = index_array.write();
 
-		int iidx=0;
-		for(List<int>::Element *F=indices_list.front();F;F=F->next()) {
+		int iidx = 0;
+		for (List<int>::Element *F = indices_list.front(); F; F = F->next()) {
 
-			index_arrayw[iidx++]=F->get();
+			index_arrayw[iidx++] = F->get();
 		}
 
-		index_arrayw=PoolVector<int>::Write();
-
+		index_arrayw = PoolVector<int>::Write();
 
 		/*****************/
 		/* MAKE SURFACES  */
 		/*****************/
 
-
 		{
 
 			Ref<FixedSpatialMaterial> material;
 
 			//find material
-			Mesh::PrimitiveType primitive=Mesh::PRIMITIVE_TRIANGLES;
+			Mesh::PrimitiveType primitive = Mesh::PRIMITIVE_TRIANGLES;
 
 			{
 
 				if (p_material_map.has(p.material)) {
-					String target=p_material_map[p.material].target;
+					String target = p_material_map[p.material].target;
 
 					if (!material_cache.has(target)) {
 						Error err = _create_material(target);
 						if (!err)
-							material=material_cache[target];
+							material = material_cache[target];
 					} else
-						material=material_cache[target];
+						material = material_cache[target];
 
-				} else if (p.material!=""){
-					print_line("Warning, unreferenced material in geometry instance: "+p.material);
+				} else if (p.material != "") {
+					print_line("Warning, unreferenced material in geometry instance: " + p.material);
 				}
 			}
 
-
-
 			PoolVector<Vector3> final_vertex_array;
 			PoolVector<Vector3> final_normal_array;
 			PoolVector<float> final_tangent_array;
@@ -1097,34 +1031,30 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 			PoolVector<int> final_bone_array;
 			PoolVector<float> final_weight_array;
 
-			uint32_t final_format=0;
+			uint32_t final_format = 0;
 
 			//create format
-			final_format=Mesh::ARRAY_FORMAT_VERTEX|Mesh::ARRAY_FORMAT_INDEX;
+			final_format = Mesh::ARRAY_FORMAT_VERTEX | Mesh::ARRAY_FORMAT_INDEX;
 
 			if (normal_src) {
-				final_format|=Mesh::ARRAY_FORMAT_NORMAL;
+				final_format |= Mesh::ARRAY_FORMAT_NORMAL;
 				if (uv_src && binormal_src && tangent_src) {
-					final_format|=Mesh::ARRAY_FORMAT_TANGENT;
+					final_format |= Mesh::ARRAY_FORMAT_TANGENT;
 				}
-
 			}
 
-
-
 			if (color_src)
-				final_format|=Mesh::ARRAY_FORMAT_COLOR;
+				final_format |= Mesh::ARRAY_FORMAT_COLOR;
 			if (uv_src)
-				final_format|=Mesh::ARRAY_FORMAT_TEX_UV;
+				final_format |= Mesh::ARRAY_FORMAT_TEX_UV;
 			if (uv2_src)
-				final_format|=Mesh::ARRAY_FORMAT_TEX_UV2;
+				final_format |= Mesh::ARRAY_FORMAT_TEX_UV2;
 
 			if (has_weights) {
-				final_format|=Mesh::ARRAY_FORMAT_WEIGHTS;
-				final_format|=Mesh::ARRAY_FORMAT_BONES;
+				final_format |= Mesh::ARRAY_FORMAT_WEIGHTS;
+				final_format |= Mesh::ARRAY_FORMAT_BONES;
 			}
 
-
 			//set arrays
 
 			int vlen = vertex_array.size();
@@ -1135,27 +1065,24 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 
 				PoolVector<Vector3>::Write varrayw = varray.write();
 
-				for(int k=0;k<vlen;k++)
-					varrayw[k]=vertex_array[k].vertex;
+				for (int k = 0; k < vlen; k++)
+					varrayw[k] = vertex_array[k].vertex;
 
 				varrayw = PoolVector<Vector3>::Write();
-				final_vertex_array=varray;
-
+				final_vertex_array = varray;
 			}
 
-
 			if (uv_src) { //compute uv first, may be needed for computing tangent/bionrmal
 				PoolVector<Vector3> uvarray;
 				uvarray.resize(vertex_array.size());
 				PoolVector<Vector3>::Write uvarrayw = uvarray.write();
 
-				for(int k=0;k<vlen;k++) {
-					uvarrayw[k]=vertex_array[k].uv;
+				for (int k = 0; k < vlen; k++) {
+					uvarrayw[k] = vertex_array[k].uv;
 				}
 
 				uvarrayw = PoolVector<Vector3>::Write();
-				final_uv_array=uvarray;
-
+				final_uv_array = uvarray;
 			}
 
 			if (uv2_src) { //compute uv first, may be needed for computing tangent/bionrmal
@@ -1163,13 +1090,12 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 				uv2array.resize(vertex_array.size());
 				PoolVector<Vector3>::Write uv2arrayw = uv2array.write();
 
-				for(int k=0;k<vlen;k++) {
-					uv2arrayw[k]=vertex_array[k].uv2;
+				for (int k = 0; k < vlen; k++) {
+					uv2arrayw[k] = vertex_array[k].uv2;
 				}
 
 				uv2arrayw = PoolVector<Vector3>::Write();
-				final_uv2_array=uv2array;
-
+				final_uv2_array = uv2array;
 			}
 
 			if (normal_src) {
@@ -1177,12 +1103,12 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 				narray.resize(vertex_array.size());
 				PoolVector<Vector3>::Write narrayw = narray.write();
 
-				for(int k=0;k<vlen;k++) {
-					narrayw[k]=vertex_array[k].normal;
+				for (int k = 0; k < vlen; k++) {
+					narrayw[k] = vertex_array[k].normal;
 				}
 
 				narrayw = PoolVector<Vector3>::Write();
-				final_normal_array=narray;
+				final_normal_array = narray;
 
 				/*
 				PoolVector<Vector3> altnaray;
@@ -1192,91 +1118,82 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 					print_line(rtos(altnaray[i].dot(final_normal_array[i])));
 				*/
 
-			} else if (primitive==Mesh::PRIMITIVE_TRIANGLES)  {
+			} else if (primitive == Mesh::PRIMITIVE_TRIANGLES) {
 				//generate normals (even if unused later)
 
-				_generate_normals(index_array,final_vertex_array,final_normal_array);
+				_generate_normals(index_array, final_vertex_array, final_normal_array);
 				if (OS::get_singleton()->is_stdout_verbose())
 					print_line("Collada: Triangle mesh lacks normals, so normals were generated.");
-				final_format|=Mesh::ARRAY_FORMAT_NORMAL;
-
+				final_format |= Mesh::ARRAY_FORMAT_NORMAL;
 			}
 
 			if (final_normal_array.size() && uv_src && binormal_src && tangent_src && !force_make_tangents) {
 
 				PoolVector<real_t> tarray;
-				tarray.resize(vertex_array.size()*4);
+				tarray.resize(vertex_array.size() * 4);
 				PoolVector<real_t>::Write tarrayw = tarray.write();
 
-
-				for(int k=0;k<vlen;k++) {
-					tarrayw[k*4+0]=vertex_array[k].tangent.normal.x;
-					tarrayw[k*4+1]=vertex_array[k].tangent.normal.y;
-					tarrayw[k*4+2]=vertex_array[k].tangent.normal.z;
-					tarrayw[k*4+3]=vertex_array[k].tangent.d;
-
+				for (int k = 0; k < vlen; k++) {
+					tarrayw[k * 4 + 0] = vertex_array[k].tangent.normal.x;
+					tarrayw[k * 4 + 1] = vertex_array[k].tangent.normal.y;
+					tarrayw[k * 4 + 2] = vertex_array[k].tangent.normal.z;
+					tarrayw[k * 4 + 3] = vertex_array[k].tangent.d;
 				}
 
 				tarrayw = PoolVector<real_t>::Write();
 
-				final_tangent_array=tarray;
-			} else if (final_normal_array.size() && primitive==Mesh::PRIMITIVE_TRIANGLES && final_uv_array.size() && (force_make_tangents || (material.is_valid()))){
+				final_tangent_array = tarray;
+			} else if (final_normal_array.size() && primitive == Mesh::PRIMITIVE_TRIANGLES && final_uv_array.size() && (force_make_tangents || (material.is_valid()))) {
 				//if this uses triangles, there are uvs and the material is using a normalmap, generate tangents and binormals, because they WILL be needed
 				//generate binormals/tangents
-				_generate_tangents_and_binormals(index_array,final_vertex_array,final_uv_array,final_normal_array,final_tangent_array);
-				final_format|=Mesh::ARRAY_FORMAT_TANGENT;
+				_generate_tangents_and_binormals(index_array, final_vertex_array, final_uv_array, final_normal_array, final_tangent_array);
+				final_format |= Mesh::ARRAY_FORMAT_TANGENT;
 				if (OS::get_singleton()->is_stdout_verbose())
 					print_line("Collada: Triangle mesh lacks tangents (And normalmap was used), so tangents were generated.");
-
 			}
 
-
 			if (color_src) {
 				PoolVector<Color> colorarray;
 				colorarray.resize(vertex_array.size());
 				PoolVector<Color>::Write colorarrayw = colorarray.write();
 
-				for(int k=0;k<vlen;k++) {
-					colorarrayw[k]=vertex_array[k].color;
+				for (int k = 0; k < vlen; k++) {
+					colorarrayw[k] = vertex_array[k].color;
 				}
 
 				colorarrayw = PoolVector<Color>::Write();
 
-				final_color_array=colorarray;
+				final_color_array = colorarray;
 			}
 
 			if (has_weights) {
 				PoolVector<float> weightarray;
 				PoolVector<int> bonearray;
 
-				weightarray.resize(vertex_array.size()*4);
+				weightarray.resize(vertex_array.size() * 4);
 				PoolVector<float>::Write weightarrayw = weightarray.write();
-				bonearray.resize(vertex_array.size()*4);
+				bonearray.resize(vertex_array.size() * 4);
 				PoolVector<int>::Write bonearrayw = bonearray.write();
 
-				for(int k=0;k<vlen;k++) {
-					float sum=0;
+				for (int k = 0; k < vlen; k++) {
+					float sum = 0;
 
-					for(int l=0;l<VS::ARRAY_WEIGHTS_SIZE;l++) {
-						if (l<vertex_array[k].weights.size()) {
-							weightarrayw[k*VS::ARRAY_WEIGHTS_SIZE+l]=vertex_array[k].weights[l].weight;
-							sum+=weightarrayw[k*VS::ARRAY_WEIGHTS_SIZE+l];
-							bonearrayw[k*VS::ARRAY_WEIGHTS_SIZE+l]=int(vertex_array[k].weights[l].bone_idx);
+					for (int l = 0; l < VS::ARRAY_WEIGHTS_SIZE; l++) {
+						if (l < vertex_array[k].weights.size()) {
+							weightarrayw[k * VS::ARRAY_WEIGHTS_SIZE + l] = vertex_array[k].weights[l].weight;
+							sum += weightarrayw[k * VS::ARRAY_WEIGHTS_SIZE + l];
+							bonearrayw[k * VS::ARRAY_WEIGHTS_SIZE + l] = int(vertex_array[k].weights[l].bone_idx);
 							//COLLADA_PRINT(itos(k)+": "+rtos(bonearrayw[k*VS::ARRAY_WEIGHTS_SIZE+l])+":"+rtos(weightarray[k*VS::ARRAY_WEIGHTS_SIZE+l]));
 						} else {
 
-							weightarrayw[k*VS::ARRAY_WEIGHTS_SIZE+l]=0;
-							bonearrayw[k*VS::ARRAY_WEIGHTS_SIZE+l]=0;
-
+							weightarrayw[k * VS::ARRAY_WEIGHTS_SIZE + l] = 0;
+							bonearrayw[k * VS::ARRAY_WEIGHTS_SIZE + l] = 0;
 						}
-
-
 					}
 					/*
 					if (sum<0.8)
 						COLLADA_PRINT("ERROR SUMMING INDEX "+itos(k)+" had weights: "+itos(vertex_array[k].weights.size()));
 					*/
-
 				}
 
 				weightarrayw = PoolVector<float>::Write();
@@ -1286,8 +1203,6 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 				final_bone_array = bonearray;
 			}
 
-
-
 			////////////////////////////
 			// FINALLY CREATE SUFRACE //
 			////////////////////////////
@@ -1295,30 +1210,29 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 			Array d;
 			d.resize(VS::ARRAY_MAX);
 
-			d[Mesh::ARRAY_INDEX]=index_array;
-			d[Mesh::ARRAY_VERTEX]=final_vertex_array;
+			d[Mesh::ARRAY_INDEX] = index_array;
+			d[Mesh::ARRAY_VERTEX] = final_vertex_array;
 
 			if (final_normal_array.size())
-				d[Mesh::ARRAY_NORMAL]=final_normal_array;
+				d[Mesh::ARRAY_NORMAL] = final_normal_array;
 			if (final_tangent_array.size())
-				d[Mesh::ARRAY_TANGENT]=final_tangent_array;
+				d[Mesh::ARRAY_TANGENT] = final_tangent_array;
 			if (final_uv_array.size())
-				d[Mesh::ARRAY_TEX_UV]=final_uv_array;
+				d[Mesh::ARRAY_TEX_UV] = final_uv_array;
 			if (final_uv2_array.size())
-				d[Mesh::ARRAY_TEX_UV2]=final_uv2_array;
+				d[Mesh::ARRAY_TEX_UV2] = final_uv2_array;
 			if (final_color_array.size())
-				d[Mesh::ARRAY_COLOR]=final_color_array;
+				d[Mesh::ARRAY_COLOR] = final_color_array;
 			if (final_weight_array.size())
-				d[Mesh::ARRAY_WEIGHTS]=final_weight_array;
+				d[Mesh::ARRAY_WEIGHTS] = final_weight_array;
 			if (final_bone_array.size())
-				d[Mesh::ARRAY_BONES]=final_bone_array;
-
+				d[Mesh::ARRAY_BONES] = final_bone_array;
 
 			Array mr;
 
-			////////////////////////////
-			// THEN THE MORPH TARGETS //
-			////////////////////////////
+////////////////////////////
+// THEN THE MORPH TARGETS //
+////////////////////////////
 #if 0
 			if (p_morph_data) {
 
@@ -1426,14 +1340,14 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 							int pos = m_i*stride;
 							Vector3 vtx( m->array[pos+0], m->array[pos+1], m->array[pos+2] );
 
-	#ifndef NO_UP_AXIS_SWAP
+#ifndef NO_UP_AXIS_SWAP
 							if (collada.state.up_axis==Vector3::AXIS_Z) {
 
 								SWAP( vtx.z, vtx.y );
 								vtx.z = -vtx.z;
 
 							}
-	#endif
+#endif
 
 							Collada::Vertex vertex;
 							vertex.vertex=vtx;
@@ -1483,24 +1397,23 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 			}
 
 #endif
-			for(int mi=0;mi<p_morph_meshes.size();mi++) {
+			for (int mi = 0; mi < p_morph_meshes.size(); mi++) {
 
 				//print_line("want surface "+itos(mi)+" has "+itos(p_morph_meshes[mi]->get_surface_count()));
 				Array a = p_morph_meshes[mi]->surface_get_arrays(surface);
 				//add valid weight and bone arrays if they exist, TODO check if they are unique to shape (generally not)
 
 				if (final_weight_array.size())
-					a[Mesh::ARRAY_WEIGHTS]=final_weight_array;
+					a[Mesh::ARRAY_WEIGHTS] = final_weight_array;
 				if (final_bone_array.size())
-					a[Mesh::ARRAY_BONES]=final_bone_array;
+					a[Mesh::ARRAY_BONES] = final_bone_array;
 
-				a[Mesh::ARRAY_INDEX]=Variant();
+				a[Mesh::ARRAY_INDEX] = Variant();
 				//a.resize(Mesh::ARRAY_MAX); //no need for index
 				mr.push_back(a);
 			}
 
-
-			p_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES,d,mr,p_for_morph?0:Mesh::ARRAY_COMPRESS_DEFAULT);
+			p_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, d, mr, p_for_morph ? 0 : Mesh::ARRAY_COMPRESS_DEFAULT);
 
 			if (material.is_valid()) {
 				if (p_use_mesh_material) {
@@ -1517,21 +1430,15 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize,Ref<Mesh>& p_mesh,con
 		surface++;
 	}
 
-
 	return OK;
-
 }
 
-
 Error ColladaImport::_create_resources(Collada::Node *p_node) {
 
+	if (p_node->type == Collada::Node::TYPE_GEOMETRY && node_map.has(p_node->id)) {
 
-	if (p_node->type==Collada::Node::TYPE_GEOMETRY && node_map.has(p_node->id)) {
-
-
-		Spatial * node=node_map[p_node->id].node;
-		Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry*>(p_node);
-
+		Spatial *node = node_map[p_node->id].node;
+		Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry *>(p_node);
 
 		if (node->cast_to<Path>()) {
 
@@ -1544,96 +1451,86 @@ Error ColladaImport::_create_resources(Collada::Node *p_node) {
 				path->set_curve(curve_cache[ng->source]);
 			} else {
 
-				Ref<Curve3D> c = memnew( Curve3D );
+				Ref<Curve3D> c = memnew(Curve3D);
 
 				const Collada::CurveData &cd = collada.state.curve_data_map[ng->source];
 
-				ERR_FAIL_COND_V( !cd.control_vertices.has("POSITION") , ERR_INVALID_DATA);
-				ERR_FAIL_COND_V( !cd.control_vertices.has("IN_TANGENT") , ERR_INVALID_DATA);
-				ERR_FAIL_COND_V( !cd.control_vertices.has("OUT_TANGENT") , ERR_INVALID_DATA);
-				ERR_FAIL_COND_V( !cd.control_vertices.has("INTERPOLATION") , ERR_INVALID_DATA);
-
+				ERR_FAIL_COND_V(!cd.control_vertices.has("POSITION"), ERR_INVALID_DATA);
+				ERR_FAIL_COND_V(!cd.control_vertices.has("IN_TANGENT"), ERR_INVALID_DATA);
+				ERR_FAIL_COND_V(!cd.control_vertices.has("OUT_TANGENT"), ERR_INVALID_DATA);
+				ERR_FAIL_COND_V(!cd.control_vertices.has("INTERPOLATION"), ERR_INVALID_DATA);
 
-				ERR_FAIL_COND_V( !cd.sources.has(cd.control_vertices["POSITION"] ) , ERR_INVALID_DATA);
-				const Collada::CurveData::Source &vertices = cd.sources[ cd.control_vertices["POSITION"] ];
-				ERR_FAIL_COND_V( vertices.stride!=3, ERR_INVALID_DATA );
+				ERR_FAIL_COND_V(!cd.sources.has(cd.control_vertices["POSITION"]), ERR_INVALID_DATA);
+				const Collada::CurveData::Source &vertices = cd.sources[cd.control_vertices["POSITION"]];
+				ERR_FAIL_COND_V(vertices.stride != 3, ERR_INVALID_DATA);
 
-				ERR_FAIL_COND_V( !cd.sources.has(cd.control_vertices["IN_TANGENT"] ) , ERR_INVALID_DATA);
-				const Collada::CurveData::Source &in_tangents = cd.sources[ cd.control_vertices["IN_TANGENT"] ];
-				ERR_FAIL_COND_V( in_tangents.stride!=3 , ERR_INVALID_DATA);
+				ERR_FAIL_COND_V(!cd.sources.has(cd.control_vertices["IN_TANGENT"]), ERR_INVALID_DATA);
+				const Collada::CurveData::Source &in_tangents = cd.sources[cd.control_vertices["IN_TANGENT"]];
+				ERR_FAIL_COND_V(in_tangents.stride != 3, ERR_INVALID_DATA);
 
-				ERR_FAIL_COND_V( !cd.sources.has(cd.control_vertices["OUT_TANGENT"] ), ERR_INVALID_DATA );
-				const Collada::CurveData::Source &out_tangents = cd.sources[ cd.control_vertices["OUT_TANGENT"] ];
-				ERR_FAIL_COND_V( out_tangents.stride!=3, ERR_INVALID_DATA );
+				ERR_FAIL_COND_V(!cd.sources.has(cd.control_vertices["OUT_TANGENT"]), ERR_INVALID_DATA);
+				const Collada::CurveData::Source &out_tangents = cd.sources[cd.control_vertices["OUT_TANGENT"]];
+				ERR_FAIL_COND_V(out_tangents.stride != 3, ERR_INVALID_DATA);
 
-				ERR_FAIL_COND_V( !cd.sources.has(cd.control_vertices["INTERPOLATION"] ), ERR_INVALID_DATA );
-				const Collada::CurveData::Source &interps = cd.sources[ cd.control_vertices["INTERPOLATION"] ];
-				ERR_FAIL_COND_V( interps.stride!=1, ERR_INVALID_DATA );
+				ERR_FAIL_COND_V(!cd.sources.has(cd.control_vertices["INTERPOLATION"]), ERR_INVALID_DATA);
+				const Collada::CurveData::Source &interps = cd.sources[cd.control_vertices["INTERPOLATION"]];
+				ERR_FAIL_COND_V(interps.stride != 1, ERR_INVALID_DATA);
 
-				const Collada::CurveData::Source *tilts=NULL;
+				const Collada::CurveData::Source *tilts = NULL;
 				if (cd.control_vertices.has("TILT") && cd.sources.has(cd.control_vertices["TILT"]))
-					tilts=&cd.sources[ cd.control_vertices["TILT"] ];
-
+					tilts = &cd.sources[cd.control_vertices["TILT"]];
 
 				if (tilts) {
 					print_line("FOUND TILTS!!!");
 				}
-				int pc = vertices.array.size()/3;
-				for(int i=0;i<pc;i++) {
+				int pc = vertices.array.size() / 3;
+				for (int i = 0; i < pc; i++) {
 
-					Vector3 pos( vertices.array[i*3+0], vertices.array[i*3+1], vertices.array[i*3+2] );
-					Vector3 in( in_tangents.array[i*3+0], in_tangents.array[i*3+1], in_tangents.array[i*3+2] );
-					Vector3 out( out_tangents.array[i*3+0], out_tangents.array[i*3+1], out_tangents.array[i*3+2] );
+					Vector3 pos(vertices.array[i * 3 + 0], vertices.array[i * 3 + 1], vertices.array[i * 3 + 2]);
+					Vector3 in(in_tangents.array[i * 3 + 0], in_tangents.array[i * 3 + 1], in_tangents.array[i * 3 + 2]);
+					Vector3 out(out_tangents.array[i * 3 + 0], out_tangents.array[i * 3 + 1], out_tangents.array[i * 3 + 2]);
 
 #ifndef NO_UP_AXIS_SWAP
-					if (collada.state.up_axis==Vector3::AXIS_Z) {
+					if (collada.state.up_axis == Vector3::AXIS_Z) {
 
-						SWAP(pos.y,pos.z);
-						pos.z=-pos.z;
-						SWAP(in.y,in.z);
-						in.z=-in.z;
-						SWAP(out.y,out.z);
-						out.z=-out.z;
+						SWAP(pos.y, pos.z);
+						pos.z = -pos.z;
+						SWAP(in.y, in.z);
+						in.z = -in.z;
+						SWAP(out.y, out.z);
+						out.z = -out.z;
 					}
 #endif
-					pos*=collada.state.unit_scale;
-					in*=collada.state.unit_scale;
-					out*=collada.state.unit_scale;
+					pos *= collada.state.unit_scale;
+					in *= collada.state.unit_scale;
+					out *= collada.state.unit_scale;
 
-					c->add_point(pos,in-pos,out-pos);
+					c->add_point(pos, in - pos, out - pos);
 					if (tilts)
-						c->set_point_tilt(i,tilts->array[i]);
-
+						c->set_point_tilt(i, tilts->array[i]);
 				}
 
-				curve_cache[ng->source]=c;
+				curve_cache[ng->source] = c;
 				path->set_curve(c);
-
 			}
-
-
 		}
 
-
 		if (node->cast_to<MeshInstance>()) {
 
-
-			Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry*>(p_node);
+			Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry *>(p_node);
 
 			MeshInstance *mi = node->cast_to<MeshInstance>();
 
+			ERR_FAIL_COND_V(!mi, ERR_BUG);
 
-			ERR_FAIL_COND_V(!mi,ERR_BUG);
-
-
-			Collada::SkinControllerData *skin=NULL;
-			Collada::MorphControllerData *morph=NULL;
+			Collada::SkinControllerData *skin = NULL;
+			Collada::MorphControllerData *morph = NULL;
 			String meshid;
 			Transform apply_xform;
 			Vector<int> bone_remap;
 			Vector<Ref<Mesh> > morphs;
 
-			print_line("mesh: "+String(mi->get_name()));
+			print_line("mesh: " + String(mi->get_name()));
 
 			if (ng->controller) {
 
@@ -1643,95 +1540,93 @@ Error ColladaImport::_create_resources(Collada::Node *p_node) {
 
 				if (collada.state.skin_controller_data_map.has(ngsource)) {
 
-
-					ERR_FAIL_COND_V(!collada.state.skin_controller_data_map.has(ngsource),ERR_INVALID_DATA);
-					skin=&collada.state.skin_controller_data_map[ngsource];
+					ERR_FAIL_COND_V(!collada.state.skin_controller_data_map.has(ngsource), ERR_INVALID_DATA);
+					skin = &collada.state.skin_controller_data_map[ngsource];
 
 					Vector<String> skeletons = ng->skeletons;
 
-					ERR_FAIL_COND_V( skeletons.empty(), ERR_INVALID_DATA );
+					ERR_FAIL_COND_V(skeletons.empty(), ERR_INVALID_DATA);
 
 					String skname = skeletons[0];
 					if (!node_map.has(skname)) {
-						print_line("no node for skeleton "+skname);
+						print_line("no node for skeleton " + skname);
 					}
-					ERR_FAIL_COND_V( !node_map.has(skname), ERR_INVALID_DATA );
+					ERR_FAIL_COND_V(!node_map.has(skname), ERR_INVALID_DATA);
 					NodeMap nmsk = node_map[skname];
 					Skeleton *sk = nmsk.node->cast_to<Skeleton>();
-					ERR_FAIL_COND_V( !sk, ERR_INVALID_DATA );
-					ERR_FAIL_COND_V( !skeleton_bone_map.has(sk), ERR_INVALID_DATA );
-					Map<String, int> &bone_remap_map=skeleton_bone_map[sk];
+					ERR_FAIL_COND_V(!sk, ERR_INVALID_DATA);
+					ERR_FAIL_COND_V(!skeleton_bone_map.has(sk), ERR_INVALID_DATA);
+					Map<String, int> &bone_remap_map = skeleton_bone_map[sk];
 
-
-					meshid=skin->base;
+					meshid = skin->base;
 
 					if (collada.state.morph_controller_data_map.has(meshid)) {
 						//it's a morph!!
 						morph = &collada.state.morph_controller_data_map[meshid];
-						ngsource=meshid;
-						meshid=morph->mesh;
+						ngsource = meshid;
+						meshid = morph->mesh;
 					} else {
-						ngsource="";
+						ngsource = "";
 					}
 
 					if (apply_mesh_xform_to_vertices) {
-						apply_xform=collada.fix_transform(p_node->default_transform);
+						apply_xform = collada.fix_transform(p_node->default_transform);
 						node->set_transform(Transform());
 					} else {
-						apply_xform=Transform();
+						apply_xform = Transform();
 					}
 
-					Collada::SkinControllerData::Source *joint_src=NULL;
+					Collada::SkinControllerData::Source *joint_src = NULL;
 
-					ERR_FAIL_COND_V(!skin->weights.sources.has("JOINT"),ERR_INVALID_DATA);
+					ERR_FAIL_COND_V(!skin->weights.sources.has("JOINT"), ERR_INVALID_DATA);
 
 					String joint_id = skin->weights.sources["JOINT"].source;
-					ERR_FAIL_COND_V(!skin->sources.has(joint_id),ERR_INVALID_DATA);
+					ERR_FAIL_COND_V(!skin->sources.has(joint_id), ERR_INVALID_DATA);
 
 					joint_src = &skin->sources[joint_id];
 
 					bone_remap.resize(joint_src->sarray.size());
 
-					for(int i=0;i<bone_remap.size();i++) {
+					for (int i = 0; i < bone_remap.size(); i++) {
 
 						String str = joint_src->sarray[i];
 						if (!bone_remap_map.has(str)) {
-							print_line("bone not found for remap: "+str);
-							print_line("in skeleton: "+skname);
+							print_line("bone not found for remap: " + str);
+							print_line("in skeleton: " + skname);
 						}
-						ERR_FAIL_COND_V( !bone_remap_map.has(str), ERR_INVALID_DATA );
-						bone_remap[i]=bone_remap_map[str];
+						ERR_FAIL_COND_V(!bone_remap_map.has(str), ERR_INVALID_DATA);
+						bone_remap[i] = bone_remap_map[str];
 					}
 				}
 
 				if (collada.state.morph_controller_data_map.has(ngsource)) {
-					print_line("is morph "+ngsource);
+					print_line("is morph " + ngsource);
 					//it's a morph!!
 					morph = &collada.state.morph_controller_data_map[ngsource];
-					meshid=morph->mesh;
-					printf("KKmorph: %p\n",morph);
-					print_line("morph mshid: "+meshid);
+					meshid = morph->mesh;
+					printf("KKmorph: %p\n", morph);
+					print_line("morph mshid: " + meshid);
 
 					Vector<String> targets;
 
 					morph->targets.has("MORPH_TARGET");
 					String target = morph->targets["MORPH_TARGET"];
-					bool valid=false;
+					bool valid = false;
 					if (morph->sources.has(target)) {
-						valid=true;
+						valid = true;
 						Vector<String> names = morph->sources[target].sarray;
-						for(int i=0;i<names.size();i++) {
+						for (int i = 0; i < names.size(); i++) {
 
-							String meshid=names[i];
+							String meshid = names[i];
 							if (collada.state.mesh_data_map.has(meshid)) {
-								Ref<Mesh> mesh=Ref<Mesh>(memnew( Mesh ));
+								Ref<Mesh> mesh = Ref<Mesh>(memnew(Mesh));
 								const Collada::MeshData &meshdata = collada.state.mesh_data_map[meshid];
-								Error err = _create_mesh_surfaces(false,mesh,ng->material_map,meshdata,apply_xform,bone_remap,skin,NULL,Vector<Ref<Mesh> >(),true);
-								ERR_FAIL_COND_V(err,err);
+								Error err = _create_mesh_surfaces(false, mesh, ng->material_map, meshdata, apply_xform, bone_remap, skin, NULL, Vector<Ref<Mesh> >(), true);
+								ERR_FAIL_COND_V(err, err);
 
 								morphs.push_back(mesh);
 							} else {
-								valid=false;
+								valid = false;
 							}
 						}
 					}
@@ -1739,38 +1634,36 @@ Error ColladaImport::_create_resources(Collada::Node *p_node) {
 					if (!valid)
 						morphs.clear();
 
-					ngsource="";
+					ngsource = "";
 				}
 
-				if (ngsource!=""){
-					ERR_EXPLAIN("Controller Instance Source '"+ngsource+"' is neither skin or morph!");
-					ERR_FAIL_V( ERR_INVALID_DATA );
+				if (ngsource != "") {
+					ERR_EXPLAIN("Controller Instance Source '" + ngsource + "' is neither skin or morph!");
+					ERR_FAIL_V(ERR_INVALID_DATA);
 				}
 
-
-
 			} else {
-				meshid=ng->source;
+				meshid = ng->source;
 			}
 
 			Ref<Mesh> mesh;
 			if (mesh_cache.has(meshid)) {
-				mesh=mesh_cache[meshid];
+				mesh = mesh_cache[meshid];
 			} else {
 				if (collada.state.mesh_data_map.has(meshid)) {
 					//bleh, must ignore invalid
 
-					ERR_FAIL_COND_V(!collada.state.mesh_data_map.has(meshid),ERR_INVALID_DATA);
-					mesh=Ref<Mesh>(memnew( Mesh ));
+					ERR_FAIL_COND_V(!collada.state.mesh_data_map.has(meshid), ERR_INVALID_DATA);
+					mesh = Ref<Mesh>(memnew(Mesh));
 					const Collada::MeshData &meshdata = collada.state.mesh_data_map[meshid];
-					mesh->set_name( meshdata.name );
-					Error err = _create_mesh_surfaces(morphs.size()==0,mesh,ng->material_map,meshdata,apply_xform,bone_remap,skin,morph,morphs,false,use_mesh_builtin_materials);
-					ERR_FAIL_COND_V(err,err);
+					mesh->set_name(meshdata.name);
+					Error err = _create_mesh_surfaces(morphs.size() == 0, mesh, ng->material_map, meshdata, apply_xform, bone_remap, skin, morph, morphs, false, use_mesh_builtin_materials);
+					ERR_FAIL_COND_V(err, err);
 
-					mesh_cache[meshid]=mesh;
+					mesh_cache[meshid] = mesh;
 				} else {
 
-					print_line("Warning, will not import geometry: "+meshid);
+					print_line("Warning, will not import geometry: " + meshid);
 				}
 			}
 
@@ -1780,33 +1673,32 @@ Error ColladaImport::_create_resources(Collada::Node *p_node) {
 				if (!use_mesh_builtin_materials) {
 					const Collada::MeshData &meshdata = collada.state.mesh_data_map[meshid];
 
-					for(int i=0;i<meshdata.primitives.size();i++) {
+					for (int i = 0; i < meshdata.primitives.size(); i++) {
 
-						String matname=meshdata.primitives[i].material;
+						String matname = meshdata.primitives[i].material;
 
 						if (ng->material_map.has(matname)) {
-							String target=ng->material_map[matname].target;
+							String target = ng->material_map[matname].target;
 
 							Ref<Material> material;
 							if (!material_cache.has(target)) {
 								Error err = _create_material(target);
 								if (!err)
-									material=material_cache[target];
+									material = material_cache[target];
 							} else
-								material=material_cache[target];
+								material = material_cache[target];
 
-							mi->set_surface_material(i,material);
-						} else if (matname!=""){
-							print_line("Warning, unreferenced material in geometry instance: "+matname);
+							mi->set_surface_material(i, material);
+						} else if (matname != "") {
+							print_line("Warning, unreferenced material in geometry instance: " + matname);
 						}
-
 					}
 				}
 			}
 		}
 	}
 
-	for(int i=0;i<p_node->children.size();i++) {
+	for (int i = 0; i < p_node->children.size(); i++) {
 
 		Error err = _create_resources(p_node->children[i]);
 		if (err)
@@ -1815,64 +1707,60 @@ Error ColladaImport::_create_resources(Collada::Node *p_node) {
 	return OK;
 }
 
+Error ColladaImport::load(const String &p_path, int p_flags, bool p_force_make_tangents) {
 
-Error ColladaImport::load(const String& p_path,int p_flags,bool p_force_make_tangents) {
-
-	Error err = collada.load(p_path,p_flags);
-	ERR_FAIL_COND_V(err,err);
+	Error err = collada.load(p_path, p_flags);
+	ERR_FAIL_COND_V(err, err);
 
-	force_make_tangents=p_force_make_tangents;
-	ERR_FAIL_COND_V( !collada.state.visual_scene_map.has( collada.state.root_visual_scene ), ERR_INVALID_DATA );
-	Collada::VisualScene &vs = collada.state.visual_scene_map[ collada.state.root_visual_scene ];
+	force_make_tangents = p_force_make_tangents;
+	ERR_FAIL_COND_V(!collada.state.visual_scene_map.has(collada.state.root_visual_scene), ERR_INVALID_DATA);
+	Collada::VisualScene &vs = collada.state.visual_scene_map[collada.state.root_visual_scene];
 
-	scene = memnew( Spatial ); // root
+	scene = memnew(Spatial); // root
 
 	//determine what's going on with the lights
-	for(int i=0;i<vs.root_nodes.size();i++) {
+	for (int i = 0; i < vs.root_nodes.size(); i++) {
 
 		_pre_process_lights(vs.root_nodes[i]);
-
 	}
 	//import scene
 
-	for(int i=0;i<vs.root_nodes.size();i++) {
+	for (int i = 0; i < vs.root_nodes.size(); i++) {
 
 		Error err = _create_scene_skeletons(vs.root_nodes[i]);
-		if (err!=OK)  {
+		if (err != OK) {
 			memdelete(scene);
-			ERR_FAIL_COND_V(err,err);
+			ERR_FAIL_COND_V(err, err);
 		}
 	}
 
-	for(int i=0;i<vs.root_nodes.size();i++) {
+	for (int i = 0; i < vs.root_nodes.size(); i++) {
 
-		Error err = _create_scene(vs.root_nodes[i],scene);
-		if (err!=OK)  {
+		Error err = _create_scene(vs.root_nodes[i], scene);
+		if (err != OK) {
 			memdelete(scene);
-			ERR_FAIL_COND_V(err,err);
+			ERR_FAIL_COND_V(err, err);
 		}
 
 		Error err2 = _create_resources(vs.root_nodes[i]);
-		if (err2!=OK)  {
+		if (err2 != OK) {
 			memdelete(scene);
-			ERR_FAIL_COND_V(err2,err2);
+			ERR_FAIL_COND_V(err2, err2);
 		}
 	}
 
 	//optatively, set unit scale in the root
 	scene->set_transform(collada.get_root_transform());
 
-
 	return OK;
-
 }
 
 void ColladaImport::_fix_param_animation_tracks() {
 
-	for (Map<String,Collada::Node*>::Element *E=collada.state.scene_map.front();E;E=E->next()) {
+	for (Map<String, Collada::Node *>::Element *E = collada.state.scene_map.front(); E; E = E->next()) {
 
 		Collada::Node *n = E->get();
-		switch(n->type)	{
+		switch (n->type) {
 
 			case Collada::Node::TYPE_NODE: {
 				// ? do nothing
@@ -1891,86 +1779,77 @@ void ColladaImport::_fix_param_animation_tracks() {
 			} break;
 			case Collada::Node::TYPE_GEOMETRY: {
 
-				Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry*>(n);
+				Collada::NodeGeometry *ng = static_cast<Collada::NodeGeometry *>(n);
 				// test source(s)
 				String source = ng->source;
 
-				while (source!="") {
+				while (source != "") {
 
 					if (collada.state.skin_controller_data_map.has(source)) {
 
-						const Collada::SkinControllerData& skin = collada.state.skin_controller_data_map[source];
+						const Collada::SkinControllerData &skin = collada.state.skin_controller_data_map[source];
 
 						//nothing to animate here i think
 
-						source=skin.base;
+						source = skin.base;
 					} else if (collada.state.morph_controller_data_map.has(source)) {
 
-
-						const Collada::MorphControllerData& morph = collada.state.morph_controller_data_map[source];
+						const Collada::MorphControllerData &morph = collada.state.morph_controller_data_map[source];
 
 						if (morph.targets.has("MORPH_WEIGHT") && morph.targets.has("MORPH_TARGET")) {
 
-
 							String weights = morph.targets["MORPH_WEIGHT"];
 							String targets = morph.targets["MORPH_TARGET"];
 							//fails here
 
 							if (morph.sources.has(targets) && morph.sources.has(weights)) {
-								const Collada::MorphControllerData::Source &weight_src=morph.sources[weights];
-								const Collada::MorphControllerData::Source &target_src=morph.sources[targets];
-
+								const Collada::MorphControllerData::Source &weight_src = morph.sources[weights];
+								const Collada::MorphControllerData::Source &target_src = morph.sources[targets];
 
 								ERR_FAIL_COND(weight_src.array.size() != target_src.sarray.size());
 
-								for(int i=0;i<weight_src.array.size();i++) {
+								for (int i = 0; i < weight_src.array.size(); i++) {
 
-									String track_name = weights+"("+itos(i)+")";
+									String track_name = weights + "(" + itos(i) + ")";
 									String mesh_name = target_src.sarray[i];
 									if (collada.state.mesh_name_map.has(mesh_name) && collada.state.referenced_tracks.has(track_name)) {
 
+										const Vector<int> &rt = collada.state.referenced_tracks[track_name];
 
-										const Vector<int>&rt = collada.state.referenced_tracks[track_name];
-
-										for(int rti=0;rti<rt.size();rti++) {
+										for (int rti = 0; rti < rt.size(); rti++) {
 											Collada::AnimationTrack *at = &collada.state.animation_tracks[rt[rti]];
 
-											at->target=E->key();
-											at->param="morph/"+collada.state.mesh_name_map[mesh_name];
-											at->property=true;
+											at->target = E->key();
+											at->param = "morph/" + collada.state.mesh_name_map[mesh_name];
+											at->property = true;
 											//at->param
 										}
 									}
 								}
 							}
 						}
-						source=morph.mesh;
+						source = morph.mesh;
 					} else {
 
-						source=""; // for now nothing else supported
+						source = ""; // for now nothing else supported
 					}
 				}
 
 			} break;
-
 		}
 	}
-
 }
 
 void ColladaImport::create_animations(bool p_make_tracks_in_all_bones, bool p_import_value_tracks) {
 
-
 	_fix_param_animation_tracks();
-	for(int i=0;i<collada.state.animation_clips.size();i++) {
+	for (int i = 0; i < collada.state.animation_clips.size(); i++) {
 
-		for(int j=0;j<collada.state.animation_clips[i].tracks.size();j++)
+		for (int j = 0; j < collada.state.animation_clips[i].tracks.size(); j++)
 			tracks_in_clips.insert(collada.state.animation_clips[i].tracks[j]);
 	}
 
-
-
-	for(int i=0;i<collada.state.animation_tracks.size();i++) {
+	for (int i = 0; i < collada.state.animation_tracks.size(); i++) {
 
 		Collada::AnimationTrack &at = collada.state.animation_tracks[i];
 		//print_line("CHANNEL: "+at.target+" PARAM: "+at.param);
@@ -1981,16 +1860,15 @@ void ColladaImport::create_animations(bool p_make_tracks_in_all_bones, bool p_im
 
 			if (node_name_map.has(at.target)) {
 
-				node=node_name_map[at.target];
+				node = node_name_map[at.target];
 			} else {
-				print_line("Coudlnt find node: "+at.target);
+				print_line("Coudlnt find node: " + at.target);
 				continue;
 			}
 		} else {
-			node=at.target;
+			node = at.target;
 		}
 
-
 		if (at.property) {
 
 			valid_animated_properties.push_back(i);
@@ -2000,22 +1878,19 @@ void ColladaImport::create_animations(bool p_make_tracks_in_all_bones, bool p_im
 			node_map[node].anim_tracks.push_back(i);
 			valid_animated_nodes.insert(node);
 		}
-
 	}
 
-	create_animation(-1,p_make_tracks_in_all_bones, p_import_value_tracks);
+	create_animation(-1, p_make_tracks_in_all_bones, p_import_value_tracks);
 	//print_line("clipcount: "+itos(collada.state.animation_clips.size()));
-	for(int i=0;i<collada.state.animation_clips.size();i++)
+	for (int i = 0; i < collada.state.animation_clips.size(); i++)
 		create_animation(i, p_make_tracks_in_all_bones, p_import_value_tracks);
-
 }
 
 void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones, bool p_import_value_tracks) {
 
-	Ref<Animation> animation = Ref<Animation>( memnew( Animation ));
-
+	Ref<Animation> animation = Ref<Animation>(memnew(Animation));
 
-	if (p_clip==-1) {
+	if (p_clip == -1) {
 
 		//print_line("default");
 		animation->set_name("default");
@@ -2024,33 +1899,32 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 		animation->set_name(collada.state.animation_clips[p_clip].name);
 	}
 
-	for(Map<String,NodeMap>::Element *E=node_map.front();E;E=E->next()) {
+	for (Map<String, NodeMap>::Element *E = node_map.front(); E; E = E->next()) {
 
-		if (E->get().bone<0)
+		if (E->get().bone < 0)
 			continue;
-		bones_with_animation[E->key()]=false;
+		bones_with_animation[E->key()] = false;
 	}
 	//store and validate tracks
 
-	if (p_clip==-1) {
+	if (p_clip == -1) {
 		//main anim
 	}
 
 	Set<int> track_filter;
 
+	if (p_clip == -1) {
 
-	if (p_clip==-1) {
-
-		for(int i=0;i<collada.state.animation_clips.size();i++) {
+		for (int i = 0; i < collada.state.animation_clips.size(); i++) {
 
 			int tc = collada.state.animation_clips[i].tracks.size();
-			for(int j=0;j<tc;j++) {
+			for (int j = 0; j < tc; j++) {
 
 				String n = collada.state.animation_clips[i].tracks[j];
 				if (collada.state.by_id_tracks.has(n)) {
 
-					const Vector<int>&ti = collada.state.by_id_tracks[n];
-					for(int k=0;k<ti.size();k++) {
+					const Vector<int> &ti = collada.state.by_id_tracks[n];
+					for (int k = 0; k < ti.size(); k++) {
 						track_filter.insert(ti[k]);
 					}
 				}
@@ -2059,18 +1933,17 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 	} else {
 
 		int tc = collada.state.animation_clips[p_clip].tracks.size();
-		for(int j=0;j<tc;j++) {
+		for (int j = 0; j < tc; j++) {
 
 			String n = collada.state.animation_clips[p_clip].tracks[j];
 			if (collada.state.by_id_tracks.has(n)) {
 
-				const Vector<int>&ti = collada.state.by_id_tracks[n];
-				for(int k=0;k<ti.size();k++) {
+				const Vector<int> &ti = collada.state.by_id_tracks[n];
+				for (int k = 0; k < ti.size(); k++) {
 					track_filter.insert(ti[k]);
 				}
 			}
 		}
-
 	}
 
 	//animation->set_loop(true);
@@ -2078,37 +1951,33 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 
 	Vector<float> base_snapshots;
 
-	float f=0;
-	float snapshot_interval = 1.0/bake_fps; //should be customizable somewhere...
+	float f = 0;
+	float snapshot_interval = 1.0 / bake_fps; //should be customizable somewhere...
 
-	float anim_length=collada.state.animation_length;
-	if (p_clip>=0 && collada.state.animation_clips[p_clip].end)
-		anim_length=collada.state.animation_clips[p_clip].end;
+	float anim_length = collada.state.animation_length;
+	if (p_clip >= 0 && collada.state.animation_clips[p_clip].end)
+		anim_length = collada.state.animation_clips[p_clip].end;
 
-	while(f<anim_length) {
+	while (f < anim_length) {
 
 		base_snapshots.push_back(f);
 
-		f+=snapshot_interval;
+		f += snapshot_interval;
 
-		if (f>=anim_length) {
+		if (f >= anim_length) {
 			base_snapshots.push_back(anim_length);
-
 		}
 	}
 
 	//print_line("anim len: "+rtos(anim_length));
 	animation->set_length(anim_length);
 
-	bool tracks_found=false;
-
-
+	bool tracks_found = false;
 
-	for(Set<String>::Element* E=valid_animated_nodes.front();E;E=E->next()) {
+	for (Set<String>::Element *E = valid_animated_nodes.front(); E; E = E->next()) {
 
 		// take snapshots
 
-
 		if (!collada.state.scene_map.has(E->get())) {
 
 			continue;
@@ -2117,14 +1986,13 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 		NodeMap &nm = node_map[E->get()];
 		String path = scene->get_path_to(nm.node);
 
-		if (nm.bone>=0) {
-			Skeleton *sk = static_cast<Skeleton*>(nm.node);
+		if (nm.bone >= 0) {
+			Skeleton *sk = static_cast<Skeleton *>(nm.node);
 			String name = sk->get_bone_name(nm.bone);
-			path=path+":"+name;
+			path = path + ":" + name;
 		}
 
-		bool found_anim=false;
-
+		bool found_anim = false;
 
 		Collada::Node *cn = collada.state.scene_map[E->get()];
 		if (cn->ignore_anim) {
@@ -2132,34 +2000,27 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 			continue;
 		}
 
-
-
 		animation->add_track(Animation::TYPE_TRANSFORM);
-		int track = animation->get_track_count() -1;
-		animation->track_set_path( track , path );
-		animation->track_set_imported( track , true ); //helps merging later
+		int track = animation->get_track_count() - 1;
+		animation->track_set_path(track, path);
+		animation->track_set_imported(track, true); //helps merging later
 
 		Vector<float> snapshots = base_snapshots;
 
-		if (nm.anim_tracks.size()==1) {
+		if (nm.anim_tracks.size() == 1) {
 			//use snapshot keys from anim track instead, because this was most likely exported baked
 			Collada::AnimationTrack &at = collada.state.animation_tracks[nm.anim_tracks.front()->get()];
 			snapshots.clear();
-			for(int i=0;i<at.keys.size();i++)
+			for (int i = 0; i < at.keys.size(); i++)
 				snapshots.push_back(at.keys[i].time);
-
-
 		}
 
+		for (int i = 0; i < snapshots.size(); i++) {
 
-		for(int i=0;i<snapshots.size();i++) {
-
-
-			for(List<int>::Element *ET=nm.anim_tracks.front();ET;ET=ET->next()) {
+			for (List<int>::Element *ET = nm.anim_tracks.front(); ET; ET = ET->next()) {
 				//apply tracks
 
-
-				if (p_clip==-1) {
+				if (p_clip == -1) {
 
 					if (track_filter.has(ET->get())) {
 
@@ -2169,66 +2030,61 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 
 					if (!track_filter.has(ET->get()))
 						continue;
-
 				}
 
-				found_anim=true;
+				found_anim = true;
 
 				Collada::AnimationTrack &at = collada.state.animation_tracks[ET->get()];
 
-				int xform_idx=-1;
-				for(int j=0;j<cn->xform_list.size();j++) {
+				int xform_idx = -1;
+				for (int j = 0; j < cn->xform_list.size(); j++) {
 
+					if (cn->xform_list[j].id == at.param) {
 
-					if (cn->xform_list[j].id==at.param) {
-
-						xform_idx=j;
+						xform_idx = j;
 						break;
 					}
 				}
 
-				if (xform_idx==-1) {
-				    print_line("couldnt find matching node "+at.target+" xform for track "+at.param);
-				    continue;
+				if (xform_idx == -1) {
+					print_line("couldnt find matching node " + at.target + " xform for track " + at.param);
+					continue;
 				}
 
-				ERR_CONTINUE(xform_idx==-1);
+				ERR_CONTINUE(xform_idx == -1);
 
 				Vector<float> data = at.get_value_at_time(snapshots[i]);
 				ERR_CONTINUE(data.empty());
 
-
 				Collada::Node::XForm &xf = cn->xform_list[xform_idx];
 
-				if (at.component=="ANGLE") {
-					ERR_CONTINUE(data.size()!=1);
-					ERR_CONTINUE(xf.op!=Collada::Node::XForm::OP_ROTATE);
-					ERR_CONTINUE(xf.data.size()<4);
-					xf.data[3]=data[0];
-				} else if (at.component=="X" || at.component=="Y" || at.component=="Z") {
-					int cn=at.component[0]-'X';
-					ERR_CONTINUE(cn>=xf.data.size());
-					ERR_CONTINUE(data.size()>1);
-					xf.data[cn]=data[0];
-				} else if (data.size()==xf.data.size()) {
+				if (at.component == "ANGLE") {
+					ERR_CONTINUE(data.size() != 1);
+					ERR_CONTINUE(xf.op != Collada::Node::XForm::OP_ROTATE);
+					ERR_CONTINUE(xf.data.size() < 4);
+					xf.data[3] = data[0];
+				} else if (at.component == "X" || at.component == "Y" || at.component == "Z") {
+					int cn = at.component[0] - 'X';
+					ERR_CONTINUE(cn >= xf.data.size());
+					ERR_CONTINUE(data.size() > 1);
+					xf.data[cn] = data[0];
+				} else if (data.size() == xf.data.size()) {
 
-					xf.data=data;
+					xf.data = data;
 				} else {
 
-
-					if ( data.size()!=xf.data.size() ) {
-					    print_line("component "+at.component+" datasize "+itos(data.size())+" xfdatasize "+itos(xf.data.size()));
+					if (data.size() != xf.data.size()) {
+						print_line("component " + at.component + " datasize " + itos(data.size()) + " xfdatasize " + itos(xf.data.size()));
 					}
 
-					ERR_CONTINUE( data.size()!=xf.data.size() );
+					ERR_CONTINUE(data.size() != xf.data.size());
 				}
 			}
 
 			Transform xform = cn->compute_transform(collada);
 			xform = collada.fix_transform(xform) * cn->post_transform;
 
-
-			if (nm.bone>=0) {
+			if (nm.bone >= 0) {
 				//make bone transform relative to rest (in case of skeleton)
 				Skeleton *sk = nm.node->cast_to<Skeleton>();
 				if (sk) {
@@ -2245,29 +2101,25 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 			Vector3 s = xform.basis.get_scale();
 			Vector3 l = xform.origin;
 
-			animation->transform_track_insert_key(track,snapshots[i],l,q,s);
-
+			animation->transform_track_insert_key(track, snapshots[i], l, q, s);
 		}
 
-
-
-		if (nm.bone>=0) {
+		if (nm.bone >= 0) {
 			if (found_anim)
-				bones_with_animation[E->get()]=true;
+				bones_with_animation[E->get()] = true;
 		}
 
 		if (found_anim)
-			tracks_found=true;
+			tracks_found = true;
 		else {
-			animation->remove_track( track );
+			animation->remove_track(track);
 		}
-
 	}
 
 	if (p_make_tracks_in_all_bones) {
 
 		//some bones may lack animation, but since we don't store pose as a property, we must add keyframes!
-		for(Map<String,bool>::Element *E=bones_with_animation.front();E;E=E->next()) {
+		for (Map<String, bool>::Element *E = bones_with_animation.front(); E; E = E->next()) {
 
 			if (E->get())
 				continue;
@@ -2276,22 +2128,21 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 
 			NodeMap &nm = node_map[E->key()];
 			String path = scene->get_path_to(nm.node);
-			ERR_CONTINUE( nm.bone <0 );
-			Skeleton *sk = static_cast<Skeleton*>(nm.node);
+			ERR_CONTINUE(nm.bone < 0);
+			Skeleton *sk = static_cast<Skeleton *>(nm.node);
 			String name = sk->get_bone_name(nm.bone);
-			path=path+":"+name;
+			path = path + ":" + name;
 
 			Collada::Node *cn = collada.state.scene_map[E->key()];
 			if (cn->ignore_anim) {
-				print_line("warning, ignoring animation on node: "+path);
+				print_line("warning, ignoring animation on node: " + path);
 				continue;
 			}
 
 			animation->add_track(Animation::TYPE_TRANSFORM);
-			int track = animation->get_track_count() -1;
-			animation->track_set_path( track , path );
-			animation->track_set_imported( track , true ); //helps merging later
-
+			int track = animation->get_track_count() - 1;
+			animation->track_set_path(track, path);
+			animation->track_set_imported(track, true); //helps merging later
 
 			Transform xform = cn->compute_transform(collada);
 			xform = collada.fix_transform(xform) * cn->post_transform;
@@ -2303,33 +2154,27 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 			Vector3 s = xform.basis.get_scale();
 			Vector3 l = xform.origin;
 
-			animation->transform_track_insert_key(track,0,l,q,s);
+			animation->transform_track_insert_key(track, 0, l, q, s);
 
-			tracks_found=true;
+			tracks_found = true;
 		}
 	}
 
-
-
 	if (p_import_value_tracks) {
 		for (int i = 0; i < valid_animated_properties.size(); i++) {
 
-
 			int ti = valid_animated_properties[i];
 
 			if (p_clip == -1) {
 
 				if (track_filter.has(ti))
 					continue;
-			}
-			else {
+			} else {
 
 				if (!track_filter.has(ti))
 					continue;
-
 			}
 
-
 			Collada::AnimationTrack &at = collada.state.animation_tracks[ti];
 
 			// take snapshots
@@ -2346,7 +2191,6 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 			animation->track_set_path(track, path);
 			animation->track_set_imported(track, true); //helps merging later
 
-
 			for (int i = 0; i < at.keys.size(); i++) {
 
 				float time = at.keys[i].time;
@@ -2356,12 +2200,10 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 					//push a float
 					value = data[0];
 
-				}
-				else if (data.size() == 16) {
+				} else if (data.size() == 16) {
 					//matrix
 					print_line("value keys for matrices not supported");
-				}
-				else {
+				} else {
 
 					print_line("don't know what to do with this amount of value keys: " + itos(data.size()));
 				}
@@ -2369,55 +2211,43 @@ void ColladaImport::create_animation(int p_clip, bool p_make_tracks_in_all_bones
 				animation->track_insert_key(track, time, value);
 			}
 
-
 			tracks_found = true;
-
 		}
 	}
 
-
-
 	if (tracks_found) {
 
 		animations.push_back(animation);
 	}
-
-
-
 }
 
-
 /*********************************************************************************/
 /*************************************** SCENE ***********************************/
 /*********************************************************************************/
 
-
 #define DEBUG_ANIMATION
 
-
 uint32_t EditorSceneImporterCollada::get_import_flags() const {
 
-	return IMPORT_SCENE|IMPORT_ANIMATION;
-
+	return IMPORT_SCENE | IMPORT_ANIMATION;
 }
 void EditorSceneImporterCollada::get_extensions(List<String> *r_extensions) const {
 
-
 	r_extensions->push_back("dae");
 }
-Node* EditorSceneImporterCollada::import_scene(const String& p_path, uint32_t p_flags,int p_bake_fps, List<String> *r_missing_deps, Error* r_err) {
+Node *EditorSceneImporterCollada::import_scene(const String &p_path, uint32_t p_flags, int p_bake_fps, List<String> *r_missing_deps, Error *r_err) {
 
 	ColladaImport state;
-	uint32_t flags=Collada::IMPORT_FLAG_SCENE;
-	if (p_flags&IMPORT_ANIMATION)
-		flags|=Collada::IMPORT_FLAG_ANIMATION;
+	uint32_t flags = Collada::IMPORT_FLAG_SCENE;
+	if (p_flags & IMPORT_ANIMATION)
+		flags |= Collada::IMPORT_FLAG_ANIMATION;
 
-	state.use_mesh_builtin_materials=!(p_flags&IMPORT_MATERIALS_IN_INSTANCES);
-	state.bake_fps=p_bake_fps;
+	state.use_mesh_builtin_materials = !(p_flags & IMPORT_MATERIALS_IN_INSTANCES);
+	state.bake_fps = p_bake_fps;
 
-	Error err = state.load(p_path,flags,p_flags&EditorSceneImporter::IMPORT_GENERATE_TANGENT_ARRAYS);
+	Error err = state.load(p_path, flags, p_flags & EditorSceneImporter::IMPORT_GENERATE_TANGENT_ARRAYS);
 
-	ERR_FAIL_COND_V(err!=OK,NULL);
+	ERR_FAIL_COND_V(err != OK, NULL);
 
 	if (state.missing_textures.size()) {
 
@@ -2427,82 +2257,70 @@ Node* EditorSceneImporterCollada::import_scene(const String& p_path, uint32_t p_
 		}
 		*/
 
-
 		if (r_missing_deps) {
 
-			for(int i=0;i<state.missing_textures.size();i++) {
+			for (int i = 0; i < state.missing_textures.size(); i++) {
 				//EditorNode::add_io_error("Texture Not Found: "+state.missing_textures[i]);
 				r_missing_deps->push_back(state.missing_textures[i]);
 			}
-
 		}
 	}
 
-	if (p_flags&IMPORT_ANIMATION) {
+	if (p_flags & IMPORT_ANIMATION) {
 
-		state.create_animations(p_flags&IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS,p_flags&EditorSceneImporter::IMPORT_ANIMATION_KEEP_VALUE_TRACKS);
-		AnimationPlayer *ap = memnew( AnimationPlayer );
-		for(int i=0;i<state.animations.size();i++) {
+		state.create_animations(p_flags & IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS, p_flags & EditorSceneImporter::IMPORT_ANIMATION_KEEP_VALUE_TRACKS);
+		AnimationPlayer *ap = memnew(AnimationPlayer);
+		for (int i = 0; i < state.animations.size(); i++) {
 			String name;
-			if (state.animations[i]->get_name()=="")
-				name="default";
+			if (state.animations[i]->get_name() == "")
+				name = "default";
 			else
-				name=state.animations[i]->get_name();
+				name = state.animations[i]->get_name();
 
-			if (p_flags&IMPORT_ANIMATION_DETECT_LOOP) {
+			if (p_flags & IMPORT_ANIMATION_DETECT_LOOP) {
 
 				if (name.begins_with("loop") || name.ends_with("loop") || name.begins_with("cycle") || name.ends_with("cycle")) {
 					state.animations[i]->set_loop(true);
 				}
 			}
 
-			ap->add_animation(name,state.animations[i]);
+			ap->add_animation(name, state.animations[i]);
 		}
 		state.scene->add_child(ap);
 		ap->set_owner(state.scene);
-
 	}
 
 	return state.scene;
-
 }
 
-Ref<Animation> EditorSceneImporterCollada::import_animation(const String& p_path,uint32_t p_flags) {
-
+Ref<Animation> EditorSceneImporterCollada::import_animation(const String &p_path, uint32_t p_flags) {
 
 	ColladaImport state;
 
+	state.use_mesh_builtin_materials = false;
 
-	state.use_mesh_builtin_materials=false;
-
-	Error err = state.load(p_path,Collada::IMPORT_FLAG_ANIMATION,p_flags&EditorSceneImporter::IMPORT_GENERATE_TANGENT_ARRAYS);
-	ERR_FAIL_COND_V(err!=OK,RES());
+	Error err = state.load(p_path, Collada::IMPORT_FLAG_ANIMATION, p_flags & EditorSceneImporter::IMPORT_GENERATE_TANGENT_ARRAYS);
+	ERR_FAIL_COND_V(err != OK, RES());
 
-
-	state.create_animations(p_flags&EditorSceneImporter::IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS,p_flags&EditorSceneImporter::IMPORT_ANIMATION_KEEP_VALUE_TRACKS);
+	state.create_animations(p_flags & EditorSceneImporter::IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS, p_flags & EditorSceneImporter::IMPORT_ANIMATION_KEEP_VALUE_TRACKS);
 	if (state.scene)
 		memdelete(state.scene);
 
-	if (state.animations.size()==0)
+	if (state.animations.size() == 0)
 		return Ref<Animation>();
-	Ref<Animation> anim=state.animations[0];
-	anim=state.animations[0];
+	Ref<Animation> anim = state.animations[0];
+	anim = state.animations[0];
 	print_line("Anim Load OK");
 	String base = p_path.get_basename().to_lower();
-	if (p_flags&IMPORT_ANIMATION_DETECT_LOOP) {
+	if (p_flags & IMPORT_ANIMATION_DETECT_LOOP) {
 
 		if (base.begins_with("loop") || base.ends_with("loop") || base.begins_with("cycle") || base.ends_with("cycle")) {
 			anim->set_loop(true);
 		}
 	}
 
-
 	return anim;
 }
 
-
 EditorSceneImporterCollada::EditorSceneImporterCollada() {
-
-
 }
-