ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 813 insertions, 784 deletions

diff --git a/source/blender/collada/ArmatureImporter.cpp b/source/blender/collada/ArmatureImporter.cpp
index bd06a8e5319..038dbd0c30d 100644
--- a/source/blender/collada/ArmatureImporter.cpp
+++ b/source/blender/collada/ArmatureImporter.cpp
@@ -18,7 +18,6 @@
  * \ingroup collada
  */
 
-
 /* COLLADABU_ASSERT, may be able to remove later */
 #include "COLLADABUPlatform.h"
 
@@ -41,170 +40,182 @@ extern "C" {
 #include "ArmatureImporter.h"
 
 // use node name, or fall back to original id if not present (name is optional)
-template<class T>
-static const char *bc_get_joint_name(T *node)
+template<class T> static const char *bc_get_joint_name(T *node)
 {
-	const std::string& id = node->getName();
-	return id.size() ? id.c_str() : node->getOriginalId().c_str();
+  const std::string &id = node->getName();
+  return id.size() ? id.c_str() : node->getOriginalId().c_str();
 }
 
-
-ArmatureImporter::ArmatureImporter(
-        UnitConverter *conv, MeshImporterBase *mesh, Main *bmain, Scene *sce, ViewLayer *view_layer, const ImportSettings *import_settings) :
-	TransformReader(conv),
-	m_bmain(bmain),
-	scene(sce),
-	view_layer(view_layer),
-	unit_converter(conv),
-	import_settings(import_settings),
-	empty(NULL),
-	mesh_importer(mesh) {
+ArmatureImporter::ArmatureImporter(UnitConverter *conv,
+                                   MeshImporterBase *mesh,
+                                   Main *bmain,
+                                   Scene *sce,
+                                   ViewLayer *view_layer,
+                                   const ImportSettings *import_settings)
+    : TransformReader(conv),
+      m_bmain(bmain),
+      scene(sce),
+      view_layer(view_layer),
+      unit_converter(conv),
+      import_settings(import_settings),
+      empty(NULL),
+      mesh_importer(mesh)
+{
 }
 
 ArmatureImporter::~ArmatureImporter()
 {
-	// free skin controller data if we forget to do this earlier
-	std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
-	for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
-		it->second.free();
-	}
+  // free skin controller data if we forget to do this earlier
+  std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
+  for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
+    it->second.free();
+  }
 }
 
 #if 0
 JointData *ArmatureImporter::get_joint_data(COLLADAFW::Node *node);
 {
-	const COLLADAFW::UniqueId& joint_id = node->getUniqueId();
+  const COLLADAFW::UniqueId& joint_id = node->getUniqueId();
 
-	if (joint_id_to_joint_index_map.find(joint_id) == joint_id_to_joint_index_map.end()) {
-		fprintf(stderr, "Cannot find a joint index by joint id for %s.\n",
-		        node->getOriginalId().c_str());
-		return NULL;
-	}
+  if (joint_id_to_joint_index_map.find(joint_id) == joint_id_to_joint_index_map.end()) {
+    fprintf(stderr, "Cannot find a joint index by joint id for %s.\n",
+            node->getOriginalId().c_str());
+    return NULL;
+  }
 
-	int joint_index = joint_id_to_joint_index_map[joint_id];
+  int joint_index = joint_id_to_joint_index_map[joint_id];
 
-	return &joint_index_to_joint_info_map[joint_index];
+  return &joint_index_to_joint_info_map[joint_index];
 }
 #endif
 
-int ArmatureImporter::create_bone(SkinInfo *skin, COLLADAFW::Node *node, EditBone *parent, int totchild,
-	float parent_mat[4][4], bArmature *arm, std::vector<std::string> &layer_labels)
+int ArmatureImporter::create_bone(SkinInfo *skin,
+                                  COLLADAFW::Node *node,
+                                  EditBone *parent,
+                                  int totchild,
+                                  float parent_mat[4][4],
+                                  bArmature *arm,
+                                  std::vector<std::string> &layer_labels)
 {
-	float mat[4][4];
-	float joint_inv_bind_mat[4][4];
-	float joint_bind_mat[4][4];
-	int chain_length = 0;
-
-	//Checking if bone is already made.
-	std::vector<COLLADAFW::Node *>::iterator it;
-	it = std::find(finished_joints.begin(), finished_joints.end(), node);
-	if (it != finished_joints.end()) return chain_length;
-
-	EditBone *bone = ED_armature_ebone_add(arm, bc_get_joint_name(node));
-	totbone++;
-
-	/*
-	 * We use the inv_bind_shape matrix to apply the armature bind pose as its rest pose.
-	 */
-
-	std::map<COLLADAFW::UniqueId, SkinInfo>::iterator skin_it;
-	bool bone_is_skinned = false;
-	for (skin_it = skin_by_data_uid.begin(); skin_it != skin_by_data_uid.end(); skin_it++) {
-
-		SkinInfo *b = &skin_it->second;
-		if (b->get_joint_inv_bind_matrix(joint_inv_bind_mat, node)) {
-
-			// get original world-space matrix
-			invert_m4_m4(mat, joint_inv_bind_mat);
-			copy_m4_m4(joint_bind_mat, mat);
-			// And make local to armature
-			Object *ob_arm = skin->BKE_armature_from_object();
-			if (ob_arm) {
-				float invmat[4][4];
-				invert_m4_m4(invmat, ob_arm->obmat);
-				mul_m4_m4m4(mat, invmat, mat);
-			}
-
-			bone_is_skinned = true;
-			break;
-		}
-	}
-
-	// create a bone even if there's no joint data for it (i.e. it has no influence)
-	if (!bone_is_skinned) {
-		get_node_mat(mat, node, NULL, NULL, parent_mat);
-	}
-
-	if (parent) bone->parent = parent;
-
-	float loc[3], size[3], rot[3][3];
-	BoneExtensionMap &extended_bones = bone_extension_manager.getExtensionMap(arm);
-	BoneExtended &be = add_bone_extended(bone, node, totchild, layer_labels, extended_bones);
-	int layer = be.get_bone_layers();
-	if (layer) bone->layer = layer;
-	arm->layer |= layer; // ensure that all populated bone layers are visible after import
-
-	float *tail = be.get_tail();
-	int use_connect = be.get_use_connect();
-
-	switch (use_connect) {
-		case 1: bone->flag |= BONE_CONNECTED;
-			break;
-		case -1:/* Connect type not specified */
-		case 0: bone->flag &= ~BONE_CONNECTED;
-			break;
-	}
-
-	if (be.has_roll()) {
-		bone->roll = be.get_roll();
-	}
-	else {
-		float angle;
-		mat4_to_loc_rot_size(loc, rot, size, mat);
-		mat3_to_vec_roll(rot, NULL, &angle);
-		bone->roll = angle;
-	}
-	copy_v3_v3(bone->head, mat[3]);
-
-	if (bone_is_skinned && this->import_settings->keep_bind_info)
-	{
-		float rest_mat[4][4];
-		get_node_mat(rest_mat, node, NULL, NULL, NULL);
-		bc_set_IDPropertyMatrix(bone, "bind_mat", joint_bind_mat);
-		bc_set_IDPropertyMatrix(bone, "rest_mat", rest_mat);
-	}
-
-	add_v3_v3v3(bone->tail, bone->head, tail); //tail must be non zero
-
-	/* find smallest bone length in armature (used later for leaf bone length) */
-	if (parent) {
-
-		if (use_connect == 1) {
-			copy_v3_v3(parent->tail, bone->head);
-		}
-
-		/* guess reasonable leaf bone length */
-		float length = len_v3v3(parent->head, bone->head);
-		if ((length < leaf_bone_length || totbone == 0) && length > MINIMUM_BONE_LENGTH) {
-			leaf_bone_length = length;
-		}
-	}
-
-	COLLADAFW::NodePointerArray& children = node->getChildNodes();
-
-	for (unsigned int i = 0; i < children.getCount(); i++) {
-		int cl = create_bone(skin, children[i], bone, children.getCount(), mat, arm, layer_labels);
-		if (cl > chain_length)
-			chain_length = cl;
-	}
-
-	bone->length = len_v3v3(bone->head, bone->tail);
-	joint_by_uid[node->getUniqueId()] = node;
-	finished_joints.push_back(node);
-
-	be.set_chain_length(chain_length + 1);
-
-	return chain_length + 1;
+  float mat[4][4];
+  float joint_inv_bind_mat[4][4];
+  float joint_bind_mat[4][4];
+  int chain_length = 0;
+
+  //Checking if bone is already made.
+  std::vector<COLLADAFW::Node *>::iterator it;
+  it = std::find(finished_joints.begin(), finished_joints.end(), node);
+  if (it != finished_joints.end())
+    return chain_length;
+
+  EditBone *bone = ED_armature_ebone_add(arm, bc_get_joint_name(node));
+  totbone++;
+
+  /*
+   * We use the inv_bind_shape matrix to apply the armature bind pose as its rest pose.
+   */
+
+  std::map<COLLADAFW::UniqueId, SkinInfo>::iterator skin_it;
+  bool bone_is_skinned = false;
+  for (skin_it = skin_by_data_uid.begin(); skin_it != skin_by_data_uid.end(); skin_it++) {
+
+    SkinInfo *b = &skin_it->second;
+    if (b->get_joint_inv_bind_matrix(joint_inv_bind_mat, node)) {
+
+      // get original world-space matrix
+      invert_m4_m4(mat, joint_inv_bind_mat);
+      copy_m4_m4(joint_bind_mat, mat);
+      // And make local to armature
+      Object *ob_arm = skin->BKE_armature_from_object();
+      if (ob_arm) {
+        float invmat[4][4];
+        invert_m4_m4(invmat, ob_arm->obmat);
+        mul_m4_m4m4(mat, invmat, mat);
+      }
+
+      bone_is_skinned = true;
+      break;
+    }
+  }
+
+  // create a bone even if there's no joint data for it (i.e. it has no influence)
+  if (!bone_is_skinned) {
+    get_node_mat(mat, node, NULL, NULL, parent_mat);
+  }
+
+  if (parent)
+    bone->parent = parent;
+
+  float loc[3], size[3], rot[3][3];
+  BoneExtensionMap &extended_bones = bone_extension_manager.getExtensionMap(arm);
+  BoneExtended &be = add_bone_extended(bone, node, totchild, layer_labels, extended_bones);
+  int layer = be.get_bone_layers();
+  if (layer)
+    bone->layer = layer;
+  arm->layer |= layer;  // ensure that all populated bone layers are visible after import
+
+  float *tail = be.get_tail();
+  int use_connect = be.get_use_connect();
+
+  switch (use_connect) {
+    case 1:
+      bone->flag |= BONE_CONNECTED;
+      break;
+    case -1: /* Connect type not specified */
+    case 0:
+      bone->flag &= ~BONE_CONNECTED;
+      break;
+  }
+
+  if (be.has_roll()) {
+    bone->roll = be.get_roll();
+  }
+  else {
+    float angle;
+    mat4_to_loc_rot_size(loc, rot, size, mat);
+    mat3_to_vec_roll(rot, NULL, &angle);
+    bone->roll = angle;
+  }
+  copy_v3_v3(bone->head, mat[3]);
+
+  if (bone_is_skinned && this->import_settings->keep_bind_info) {
+    float rest_mat[4][4];
+    get_node_mat(rest_mat, node, NULL, NULL, NULL);
+    bc_set_IDPropertyMatrix(bone, "bind_mat", joint_bind_mat);
+    bc_set_IDPropertyMatrix(bone, "rest_mat", rest_mat);
+  }
+
+  add_v3_v3v3(bone->tail, bone->head, tail);  //tail must be non zero
+
+  /* find smallest bone length in armature (used later for leaf bone length) */
+  if (parent) {
+
+    if (use_connect == 1) {
+      copy_v3_v3(parent->tail, bone->head);
+    }
+
+    /* guess reasonable leaf bone length */
+    float length = len_v3v3(parent->head, bone->head);
+    if ((length < leaf_bone_length || totbone == 0) && length > MINIMUM_BONE_LENGTH) {
+      leaf_bone_length = length;
+    }
+  }
+
+  COLLADAFW::NodePointerArray &children = node->getChildNodes();
+
+  for (unsigned int i = 0; i < children.getCount(); i++) {
+    int cl = create_bone(skin, children[i], bone, children.getCount(), mat, arm, layer_labels);
+    if (cl > chain_length)
+      chain_length = cl;
+  }
+
+  bone->length = len_v3v3(bone->head, bone->tail);
+  joint_by_uid[node->getUniqueId()] = node;
+  finished_joints.push_back(node);
+
+  be.set_chain_length(chain_length + 1);
+
+  return chain_length + 1;
 }
 
 /**
@@ -213,464 +224,473 @@ int ArmatureImporter::create_bone(SkinInfo *skin, COLLADAFW::Node *node, EditBon
  * tail locations for the affected bones (nodes which don't have any connected child)
  * Hint: The extended_bones set gets populated in ArmatureImporter::create_bone
  */
-void ArmatureImporter::fix_leaf_bone_hierarchy(bArmature *armature, Bone *bone, bool fix_orientation)
+void ArmatureImporter::fix_leaf_bone_hierarchy(bArmature *armature,
+                                               Bone *bone,
+                                               bool fix_orientation)
 {
-	if (bone == NULL)
-		return;
-
-	if (bc_is_leaf_bone(bone)) {
-		BoneExtensionMap &extended_bones = bone_extension_manager.getExtensionMap(armature);
-		BoneExtended *be = extended_bones[bone->name];
-		EditBone *ebone = bc_get_edit_bone(armature, bone->name);
-		fix_leaf_bone(armature, ebone, be, fix_orientation);
-	}
-
-	for (Bone *child = (Bone *)bone->childbase.first; child; child = child->next) {
-		fix_leaf_bone_hierarchy(armature, child, fix_orientation);
-	}
+  if (bone == NULL)
+    return;
+
+  if (bc_is_leaf_bone(bone)) {
+    BoneExtensionMap &extended_bones = bone_extension_manager.getExtensionMap(armature);
+    BoneExtended *be = extended_bones[bone->name];
+    EditBone *ebone = bc_get_edit_bone(armature, bone->name);
+    fix_leaf_bone(armature, ebone, be, fix_orientation);
+  }
+
+  for (Bone *child = (Bone *)bone->childbase.first; child; child = child->next) {
+    fix_leaf_bone_hierarchy(armature, child, fix_orientation);
+  }
 }
 
-void ArmatureImporter::fix_leaf_bone(bArmature *armature, EditBone *ebone, BoneExtended *be , bool fix_orientation)
+void ArmatureImporter::fix_leaf_bone(bArmature *armature,
+                                     EditBone *ebone,
+                                     BoneExtended *be,
+                                     bool fix_orientation)
 {
-	if (be == NULL || !be->has_tail()) {
-
-		/* Collada only knows Joints, Here we guess a reasonable leaf bone length */
-		float leaf_length = (leaf_bone_length == FLT_MAX) ? 1.0 : leaf_bone_length;
-
-
-		float vec[3];
-
-		if (fix_orientation && ebone->parent != NULL) {
-			EditBone *parent = ebone->parent;
-			sub_v3_v3v3(vec, ebone->head, parent->head);
-			if (len_squared_v3(vec) < MINIMUM_BONE_LENGTH)
-			{
-				sub_v3_v3v3(vec, parent->tail, parent->head);
-			}
-		}
-		else {
-			vec[2] = 0.1f;
-			sub_v3_v3v3(vec, ebone->tail, ebone->head);
-		}
-
-		normalize_v3_v3(vec, vec);
-		mul_v3_fl(vec, leaf_length);
-		add_v3_v3v3(ebone->tail, ebone->head, vec);
-	}
+  if (be == NULL || !be->has_tail()) {
+
+    /* Collada only knows Joints, Here we guess a reasonable leaf bone length */
+    float leaf_length = (leaf_bone_length == FLT_MAX) ? 1.0 : leaf_bone_length;
+
+    float vec[3];
+
+    if (fix_orientation && ebone->parent != NULL) {
+      EditBone *parent = ebone->parent;
+      sub_v3_v3v3(vec, ebone->head, parent->head);
+      if (len_squared_v3(vec) < MINIMUM_BONE_LENGTH) {
+        sub_v3_v3v3(vec, parent->tail, parent->head);
+      }
+    }
+    else {
+      vec[2] = 0.1f;
+      sub_v3_v3v3(vec, ebone->tail, ebone->head);
+    }
+
+    normalize_v3_v3(vec, vec);
+    mul_v3_fl(vec, leaf_length);
+    add_v3_v3v3(ebone->tail, ebone->head, vec);
+  }
 }
 
 void ArmatureImporter::fix_parent_connect(bArmature *armature, Bone *bone)
 {
-	/* armature has no bones */
-	if (bone == NULL)
-		return;
-
-	if (bone->parent && bone->flag & BONE_CONNECTED) {
-		copy_v3_v3(bone->parent->tail, bone->head);
-	}
+  /* armature has no bones */
+  if (bone == NULL)
+    return;
 
-	for (Bone *child = (Bone *)bone->childbase.first; child; child = child->next) {
-		fix_parent_connect(armature, child);
-	}
+  if (bone->parent && bone->flag & BONE_CONNECTED) {
+    copy_v3_v3(bone->parent->tail, bone->head);
+  }
 
+  for (Bone *child = (Bone *)bone->childbase.first; child; child = child->next) {
+    fix_parent_connect(armature, child);
+  }
 }
 
 void ArmatureImporter::connect_bone_chains(bArmature *armature, Bone *parentbone, int clip)
 {
-	BoneExtensionMap &extended_bones = bone_extension_manager.getExtensionMap(armature);
-	BoneExtended *dominant_child = NULL;
-	int maxlen = 0;
-
-	if (parentbone == NULL)
-		return;
-
-	Bone *child = (Bone *)parentbone->childbase.first;
-	if (child && (import_settings->find_chains || child->next==NULL)) {
-		for (; child; child = child->next) {
-			BoneExtended *be = extended_bones[child->name];
-			if (be != NULL) {
-				int chain_len = be->get_chain_length();
-				if (chain_len <= clip) {
-					if (chain_len > maxlen) {
-						dominant_child = be;
-						maxlen = chain_len;
-					}
-					else if (chain_len == maxlen) {
-						dominant_child = NULL;
-					}
-				}
-			}
-		}
-	}
-
-	BoneExtended *pbe = extended_bones[parentbone->name];
-	if (dominant_child != NULL) {
-		/* Found a valid chain. Now connect current bone with that chain.*/
-		EditBone *pebone = bc_get_edit_bone(armature, parentbone->name);
-		EditBone *cebone = bc_get_edit_bone(armature, dominant_child->get_name());
-		if (pebone && !(cebone->flag & BONE_CONNECTED)) {
-			float vec[3];
-			sub_v3_v3v3(vec, cebone->head, pebone->head);
-
-			/*
-			 * It is possible that the child's head is located on the parents head.
-			 * When this happens, then moving the parent's tail to the child's head
-			 * would result in a zero sized bone and Blender would  silently remove the bone.
-			 * So we move the tail only when the resulting bone has a minimum length:
-			 */
-
-			if (len_squared_v3(vec) > MINIMUM_BONE_LENGTH)
-			{
-				copy_v3_v3(pebone->tail, cebone->head);
-				pbe->set_tail(pebone->tail); /* to make fix_leafbone happy ...*/
-				if (pbe && pbe->get_chain_length() >= this->import_settings->min_chain_length) {
-
-					BoneExtended *cbe = extended_bones[cebone->name];
-					cbe->set_use_connect(true);
-
-					cebone->flag |= BONE_CONNECTED;
-					pbe->set_leaf_bone(false);
-					printf("Connect Bone chain: parent (%s --> %s) child)\n", pebone->name, cebone->name);
-				}
-			}
-		}
-		for (Bone *ch = (Bone *)parentbone->childbase.first; ch; ch = ch->next) {
-			ArmatureImporter::connect_bone_chains(armature, ch, UNLIMITED_CHAIN_MAX);
-		}
-	}
-	else if (maxlen>1 && maxlen > this->import_settings->min_chain_length) {
-		/* Try again with smaller chain length */
-		ArmatureImporter::connect_bone_chains(armature, parentbone, maxlen - 1);
-	}
-	else {
-		/* can't connect this Bone. Proceed with children ... */
-		if (pbe) pbe->set_leaf_bone(true);
-		for (Bone *ch = (Bone *)parentbone->childbase.first; ch; ch = ch->next) {
-			ArmatureImporter::connect_bone_chains(armature, ch, UNLIMITED_CHAIN_MAX);
-		}
-	}
-
+  BoneExtensionMap &extended_bones = bone_extension_manager.getExtensionMap(armature);
+  BoneExtended *dominant_child = NULL;
+  int maxlen = 0;
+
+  if (parentbone == NULL)
+    return;
+
+  Bone *child = (Bone *)parentbone->childbase.first;
+  if (child && (import_settings->find_chains || child->next == NULL)) {
+    for (; child; child = child->next) {
+      BoneExtended *be = extended_bones[child->name];
+      if (be != NULL) {
+        int chain_len = be->get_chain_length();
+        if (chain_len <= clip) {
+          if (chain_len > maxlen) {
+            dominant_child = be;
+            maxlen = chain_len;
+          }
+          else if (chain_len == maxlen) {
+            dominant_child = NULL;
+          }
+        }
+      }
+    }
+  }
+
+  BoneExtended *pbe = extended_bones[parentbone->name];
+  if (dominant_child != NULL) {
+    /* Found a valid chain. Now connect current bone with that chain.*/
+    EditBone *pebone = bc_get_edit_bone(armature, parentbone->name);
+    EditBone *cebone = bc_get_edit_bone(armature, dominant_child->get_name());
+    if (pebone && !(cebone->flag & BONE_CONNECTED)) {
+      float vec[3];
+      sub_v3_v3v3(vec, cebone->head, pebone->head);
+
+      /*
+       * It is possible that the child's head is located on the parents head.
+       * When this happens, then moving the parent's tail to the child's head
+       * would result in a zero sized bone and Blender would  silently remove the bone.
+       * So we move the tail only when the resulting bone has a minimum length:
+       */
+
+      if (len_squared_v3(vec) > MINIMUM_BONE_LENGTH) {
+        copy_v3_v3(pebone->tail, cebone->head);
+        pbe->set_tail(pebone->tail); /* to make fix_leafbone happy ...*/
+        if (pbe && pbe->get_chain_length() >= this->import_settings->min_chain_length) {
+
+          BoneExtended *cbe = extended_bones[cebone->name];
+          cbe->set_use_connect(true);
+
+          cebone->flag |= BONE_CONNECTED;
+          pbe->set_leaf_bone(false);
+          printf("Connect Bone chain: parent (%s --> %s) child)\n", pebone->name, cebone->name);
+        }
+      }
+    }
+    for (Bone *ch = (Bone *)parentbone->childbase.first; ch; ch = ch->next) {
+      ArmatureImporter::connect_bone_chains(armature, ch, UNLIMITED_CHAIN_MAX);
+    }
+  }
+  else if (maxlen > 1 && maxlen > this->import_settings->min_chain_length) {
+    /* Try again with smaller chain length */
+    ArmatureImporter::connect_bone_chains(armature, parentbone, maxlen - 1);
+  }
+  else {
+    /* can't connect this Bone. Proceed with children ... */
+    if (pbe)
+      pbe->set_leaf_bone(true);
+    for (Bone *ch = (Bone *)parentbone->childbase.first; ch; ch = ch->next) {
+      ArmatureImporter::connect_bone_chains(armature, ch, UNLIMITED_CHAIN_MAX);
+    }
+  }
 }
 
 #if 0
 void ArmatureImporter::set_leaf_bone_shapes(Object *ob_arm)
 {
-	bPose *pose = ob_arm->pose;
-
-	std::vector<LeafBone>::iterator it;
-	for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
-		LeafBone& leaf = *it;
-
-		bPoseChannel *pchan = BKE_pose_channel_find_name(pose, leaf.name);
-		if (pchan) {
-			pchan->custom = get_empty_for_leaves();
-		}
-		else {
-			fprintf(stderr, "Cannot find a pose channel for leaf bone %s\n", leaf.name);
-		}
-	}
+  bPose *pose = ob_arm->pose;
+
+  std::vector<LeafBone>::iterator it;
+  for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
+    LeafBone& leaf = *it;
+
+    bPoseChannel *pchan = BKE_pose_channel_find_name(pose, leaf.name);
+    if (pchan) {
+      pchan->custom = get_empty_for_leaves();
+    }
+    else {
+      fprintf(stderr, "Cannot find a pose channel for leaf bone %s\n", leaf.name);
+    }
+  }
 }
 
 void ArmatureImporter::set_euler_rotmode()
 {
-	// just set rotmode = ROT_MODE_EUL on pose channel for each joint
+  // just set rotmode = ROT_MODE_EUL on pose channel for each joint
 
-	std::map<COLLADAFW::UniqueId, COLLADAFW::Node *>::iterator it;
+  std::map<COLLADAFW::UniqueId, COLLADAFW::Node *>::iterator it;
 
-	for (it = joint_by_uid.begin(); it != joint_by_uid.end(); it++) {
+  for (it = joint_by_uid.begin(); it != joint_by_uid.end(); it++) {
 
-		COLLADAFW::Node *joint = it->second;
+    COLLADAFW::Node *joint = it->second;
 
-		std::map<COLLADAFW::UniqueId, SkinInfo>::iterator sit;
+    std::map<COLLADAFW::UniqueId, SkinInfo>::iterator sit;
 
-		for (sit = skin_by_data_uid.begin(); sit != skin_by_data_uid.end(); sit++) {
-			SkinInfo& skin = sit->second;
+    for (sit = skin_by_data_uid.begin(); sit != skin_by_data_uid.end(); sit++) {
+      SkinInfo& skin = sit->second;
 
-			if (skin.uses_joint_or_descendant(joint)) {
-				bPoseChannel *pchan = skin.get_pose_channel_from_node(joint);
+      if (skin.uses_joint_or_descendant(joint)) {
+        bPoseChannel *pchan = skin.get_pose_channel_from_node(joint);
 
-				if (pchan) {
-					pchan->rotmode = ROT_MODE_EUL;
-				}
-				else {
-					fprintf(stderr, "Cannot find pose channel for %s.\n", get_joint_name(joint));
-				}
+        if (pchan) {
+          pchan->rotmode = ROT_MODE_EUL;
+        }
+        else {
+          fprintf(stderr, "Cannot find pose channel for %s.\n", get_joint_name(joint));
+        }
 
-				break;
-			}
-		}
-	}
+        break;
+      }
+    }
+  }
 }
 #endif
 
 Object *ArmatureImporter::get_empty_for_leaves()
 {
-	if (empty) return empty;
+  if (empty)
+    return empty;
 
-	empty = bc_add_object(m_bmain, scene, view_layer, OB_EMPTY, NULL);
-	empty->empty_drawtype = OB_EMPTY_SPHERE;
+  empty = bc_add_object(m_bmain, scene, view_layer, OB_EMPTY, NULL);
+  empty->empty_drawtype = OB_EMPTY_SPHERE;
 
-	return empty;
+  return empty;
 }
 
 #if 0
 Object *ArmatureImporter::find_armature(COLLADAFW::Node *node)
 {
-	JointData *jd = get_joint_data(node);
-	if (jd) return jd->ob_arm;
+  JointData *jd = get_joint_data(node);
+  if (jd) return jd->ob_arm;
 
-	COLLADAFW::NodePointerArray& children = node->getChildNodes();
-	for (int i = 0; i < children.getCount(); i++) {
-		Object *ob_arm = find_armature(children[i]);
-		if (ob_arm) return ob_arm;
-	}
+  COLLADAFW::NodePointerArray& children = node->getChildNodes();
+  for (int i = 0; i < children.getCount(); i++) {
+    Object *ob_arm = find_armature(children[i]);
+    if (ob_arm) return ob_arm;
+  }
 
-	return NULL;
+  return NULL;
 }
 
 ArmatureJoints& ArmatureImporter::get_armature_joints(Object *ob_arm)
 {
-	// try finding it
-	std::vector<ArmatureJoints>::iterator it;
-	for (it = armature_joints.begin(); it != armature_joints.end(); it++) {
-		if ((*it).ob_arm == ob_arm) return *it;
-	}
-
-	// not found, create one
-	ArmatureJoints aj;
-	aj.ob_arm = ob_arm;
-	armature_joints.push_back(aj);
-
-	return armature_joints.back();
+  // try finding it
+  std::vector<ArmatureJoints>::iterator it;
+  for (it = armature_joints.begin(); it != armature_joints.end(); it++) {
+    if ((*it).ob_arm == ob_arm) return *it;
+  }
+
+  // not found, create one
+  ArmatureJoints aj;
+  aj.ob_arm = ob_arm;
+  armature_joints.push_back(aj);
+
+  return armature_joints.back();
 }
 #endif
 void ArmatureImporter::create_armature_bones(Main *bmain, std::vector<Object *> &ob_arms)
 {
-	std::vector<COLLADAFW::Node *>::iterator ri;
-	std::vector<std::string> layer_labels;
-
-	//if there is an armature created for root_joint next root_joint
-	for (ri = root_joints.begin(); ri != root_joints.end(); ri++) {
-		if (get_armature_for_joint(*ri) != NULL) continue;
-
-		Object *ob_arm = joint_parent_map[(*ri)->getUniqueId()];
-		if (!ob_arm)
-			continue;
-
-		bArmature *armature = (bArmature *)ob_arm->data;
-		if (!armature)
-			continue;
-
-		char *bone_name = (char *)bc_get_joint_name(*ri);
-		Bone *bone = BKE_armature_find_bone_name(armature, bone_name);
-		if (bone) {
-			fprintf(stderr, "Reuse of child bone [%s] as root bone in same Armature is not supported.\n", bone_name);
-			continue;
-		}
-
-		ED_armature_to_edit(armature);
-		armature->layer = 0; // layer is set according to imported bone set in create_bone()
-
-		create_bone(NULL, *ri , NULL, (*ri)->getChildNodes().getCount(), NULL, armature, layer_labels);
-		if (this->import_settings->find_chains) {
-			connect_bone_chains(armature, (Bone *)armature->bonebase.first, UNLIMITED_CHAIN_MAX);
-		}
-
-		/* exit armature edit mode to populate the Armature object */
-		ED_armature_from_edit(bmain, armature);
-		ED_armature_edit_free(armature);
-
-		ED_armature_to_edit(armature);
-
-		fix_leaf_bone_hierarchy(armature, (Bone *)armature->bonebase.first, this->import_settings->fix_orientation);
-		unskinned_armature_map[(*ri)->getUniqueId()] = ob_arm;
-
-		ED_armature_from_edit(bmain, armature);
-		ED_armature_edit_free(armature);
-
-		int index = std::find(ob_arms.begin(), ob_arms.end(), ob_arm) - ob_arms.begin();
-		if (index == 0) {
-			ob_arms.push_back(ob_arm);
-		}
-
-		DEG_id_tag_update(&ob_arm->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
-	}
+  std::vector<COLLADAFW::Node *>::iterator ri;
+  std::vector<std::string> layer_labels;
+
+  //if there is an armature created for root_joint next root_joint
+  for (ri = root_joints.begin(); ri != root_joints.end(); ri++) {
+    if (get_armature_for_joint(*ri) != NULL)
+      continue;
+
+    Object *ob_arm = joint_parent_map[(*ri)->getUniqueId()];
+    if (!ob_arm)
+      continue;
+
+    bArmature *armature = (bArmature *)ob_arm->data;
+    if (!armature)
+      continue;
+
+    char *bone_name = (char *)bc_get_joint_name(*ri);
+    Bone *bone = BKE_armature_find_bone_name(armature, bone_name);
+    if (bone) {
+      fprintf(stderr,
+              "Reuse of child bone [%s] as root bone in same Armature is not supported.\n",
+              bone_name);
+      continue;
+    }
+
+    ED_armature_to_edit(armature);
+    armature->layer = 0;  // layer is set according to imported bone set in create_bone()
+
+    create_bone(NULL, *ri, NULL, (*ri)->getChildNodes().getCount(), NULL, armature, layer_labels);
+    if (this->import_settings->find_chains) {
+      connect_bone_chains(armature, (Bone *)armature->bonebase.first, UNLIMITED_CHAIN_MAX);
+    }
+
+    /* exit armature edit mode to populate the Armature object */
+    ED_armature_from_edit(bmain, armature);
+    ED_armature_edit_free(armature);
+
+    ED_armature_to_edit(armature);
+
+    fix_leaf_bone_hierarchy(
+        armature, (Bone *)armature->bonebase.first, this->import_settings->fix_orientation);
+    unskinned_armature_map[(*ri)->getUniqueId()] = ob_arm;
+
+    ED_armature_from_edit(bmain, armature);
+    ED_armature_edit_free(armature);
+
+    int index = std::find(ob_arms.begin(), ob_arms.end(), ob_arm) - ob_arms.begin();
+    if (index == 0) {
+      ob_arms.push_back(ob_arm);
+    }
+
+    DEG_id_tag_update(&ob_arm->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
+  }
 }
 
-Object *ArmatureImporter::create_armature_bones(Main *bmain, SkinInfo& skin)
+Object *ArmatureImporter::create_armature_bones(Main *bmain, SkinInfo &skin)
 {
-	// just do like so:
-	// - get armature
-	// - enter editmode
-	// - add edit bones and head/tail properties using matrices and parent-child info
-	// - exit edit mode
-	// - set a sphere shape to leaf bones
-
-	Object *ob_arm = NULL;
-
-	/*
-	 * find if there's another skin sharing at least one bone with this skin
-	 * if so, use that skin's armature
-	 */
-
-	/**
-	 * Pseudocode:
-	 *
-	 * find_node_in_tree(node, root_joint)
-	 *
-	 * skin::find_root_joints(root_joints):
-	 *     std::vector root_joints;
-	 *     for each root in root_joints:
-	 *         for each joint in joints:
-	 *             if find_node_in_tree(joint, root):
-	 *                 if (std::find(root_joints.begin(), root_joints.end(), root) == root_joints.end())
-	 *                     root_joints.push_back(root);
-	 *
-	 * for (each skin B with armature) {
-	 *     find all root joints for skin B
-	 *
-	 *     for each joint X in skin A:
-	 *         for each root joint R in skin B:
-	 *             if (find_node_in_tree(X, R)) {
-	 *                 shared = 1;
-	 *                 goto endloop;
-	 *             }
-	 * }
-	 *
-	 * endloop:
-	 */
-
-	SkinInfo *a = &skin;
-	Object *shared = NULL;
-	std::vector<COLLADAFW::Node *> skin_root_joints;
-	std::vector<std::string> layer_labels;
-
-	std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
-	for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
-		SkinInfo *b = &it->second;
-		if (b == a || b->BKE_armature_from_object() == NULL)
-			continue;
-
-		skin_root_joints.clear();
-
-		b->find_root_joints(root_joints, joint_by_uid, skin_root_joints);
-
-		std::vector<COLLADAFW::Node *>::iterator ri;
-		for (ri = skin_root_joints.begin(); ri != skin_root_joints.end(); ri++) {
-			if (a->uses_joint_or_descendant(*ri)) {
-				shared = b->BKE_armature_from_object();
-				break;
-			}
-		}
-
-		if (shared != NULL)
-			break;
-	}
-
-	if (!shared && this->joint_parent_map.size() > 0) {
-		// All armatures have been created while creating the Node tree.
-		// The Collada exporter currently does not create a
-		// strict relationship between geometries and armatures
-		// So when we reimport a Blender collada file, then we have
-		// to guess what is meant.
-		// XXX This is not safe when we have more than one armatures
-		// in the import.
-		shared = this->joint_parent_map.begin()->second;
-	}
-
-	if (shared) {
-		ob_arm = skin.set_armature(shared);
-	}
-	else {
-		ob_arm = skin.create_armature(m_bmain, scene, view_layer);  //once for every armature
-	}
-
-	// enter armature edit mode
-	bArmature *armature = (bArmature *)ob_arm->data;
-	ED_armature_to_edit(armature);
-
-	totbone = 0;
-	// bone_direction_row = 1; // TODO: don't default to Y but use asset and based on it decide on default row
-
-	// create bones
-	/*
-	   TODO:
-	   check if bones have already been created for a given joint
-	 */
-
-	std::vector<COLLADAFW::Node *>::iterator ri;
-	for (ri = root_joints.begin(); ri != root_joints.end(); ri++) {
-		// for shared armature check if bone tree is already created
-		if (shared && std::find(skin_root_joints.begin(), skin_root_joints.end(), *ri) != skin_root_joints.end())
-			continue;
-
-		// since root_joints may contain joints for multiple controllers, we need to filter
-		if (skin.uses_joint_or_descendant(*ri)) {
-
-			create_bone(&skin, *ri, NULL, (*ri)->getChildNodes().getCount(), NULL, armature, layer_labels);
-
-			if (joint_parent_map.find((*ri)->getUniqueId()) != joint_parent_map.end() && !skin.get_parent())
-				skin.set_parent(joint_parent_map[(*ri)->getUniqueId()]);
-		}
-	}
-
-	/* exit armature edit mode to populate the Armature object */
-	ED_armature_from_edit(bmain, armature);
-	ED_armature_edit_free(armature);
-
-	ED_armature_to_edit(armature);
-	if (this->import_settings->find_chains) {
-		connect_bone_chains(armature, (Bone *)armature->bonebase.first, UNLIMITED_CHAIN_MAX);
-	}
-	fix_leaf_bone_hierarchy(armature, (Bone *)armature->bonebase.first, this->import_settings->fix_orientation);
-	ED_armature_from_edit(bmain, armature);
-	ED_armature_edit_free(armature);
-
-	DEG_id_tag_update(&ob_arm->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
-
-	return ob_arm;
+  // just do like so:
+  // - get armature
+  // - enter editmode
+  // - add edit bones and head/tail properties using matrices and parent-child info
+  // - exit edit mode
+  // - set a sphere shape to leaf bones
+
+  Object *ob_arm = NULL;
+
+  /*
+   * find if there's another skin sharing at least one bone with this skin
+   * if so, use that skin's armature
+   */
+
+  /**
+   * Pseudocode:
+   *
+   * find_node_in_tree(node, root_joint)
+   *
+   * skin::find_root_joints(root_joints):
+   *     std::vector root_joints;
+   *     for each root in root_joints:
+   *         for each joint in joints:
+   *             if find_node_in_tree(joint, root):
+   *                 if (std::find(root_joints.begin(), root_joints.end(), root) == root_joints.end())
+   *                     root_joints.push_back(root);
+   *
+   * for (each skin B with armature) {
+   *     find all root joints for skin B
+   *
+   *     for each joint X in skin A:
+   *         for each root joint R in skin B:
+   *             if (find_node_in_tree(X, R)) {
+   *                 shared = 1;
+   *                 goto endloop;
+   *             }
+   * }
+   *
+   * endloop:
+   */
+
+  SkinInfo *a = &skin;
+  Object *shared = NULL;
+  std::vector<COLLADAFW::Node *> skin_root_joints;
+  std::vector<std::string> layer_labels;
+
+  std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
+  for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
+    SkinInfo *b = &it->second;
+    if (b == a || b->BKE_armature_from_object() == NULL)
+      continue;
+
+    skin_root_joints.clear();
+
+    b->find_root_joints(root_joints, joint_by_uid, skin_root_joints);
+
+    std::vector<COLLADAFW::Node *>::iterator ri;
+    for (ri = skin_root_joints.begin(); ri != skin_root_joints.end(); ri++) {
+      if (a->uses_joint_or_descendant(*ri)) {
+        shared = b->BKE_armature_from_object();
+        break;
+      }
+    }
+
+    if (shared != NULL)
+      break;
+  }
+
+  if (!shared && this->joint_parent_map.size() > 0) {
+    // All armatures have been created while creating the Node tree.
+    // The Collada exporter currently does not create a
+    // strict relationship between geometries and armatures
+    // So when we reimport a Blender collada file, then we have
+    // to guess what is meant.
+    // XXX This is not safe when we have more than one armatures
+    // in the import.
+    shared = this->joint_parent_map.begin()->second;
+  }
+
+  if (shared) {
+    ob_arm = skin.set_armature(shared);
+  }
+  else {
+    ob_arm = skin.create_armature(m_bmain, scene, view_layer);  //once for every armature
+  }
+
+  // enter armature edit mode
+  bArmature *armature = (bArmature *)ob_arm->data;
+  ED_armature_to_edit(armature);
+
+  totbone = 0;
+  // bone_direction_row = 1; // TODO: don't default to Y but use asset and based on it decide on default row
+
+  // create bones
+  /*
+     TODO:
+     check if bones have already been created for a given joint
+   */
+
+  std::vector<COLLADAFW::Node *>::iterator ri;
+  for (ri = root_joints.begin(); ri != root_joints.end(); ri++) {
+    // for shared armature check if bone tree is already created
+    if (shared &&
+        std::find(skin_root_joints.begin(), skin_root_joints.end(), *ri) != skin_root_joints.end())
+      continue;
+
+    // since root_joints may contain joints for multiple controllers, we need to filter
+    if (skin.uses_joint_or_descendant(*ri)) {
+
+      create_bone(
+          &skin, *ri, NULL, (*ri)->getChildNodes().getCount(), NULL, armature, layer_labels);
+
+      if (joint_parent_map.find((*ri)->getUniqueId()) != joint_parent_map.end() &&
+          !skin.get_parent())
+        skin.set_parent(joint_parent_map[(*ri)->getUniqueId()]);
+    }
+  }
+
+  /* exit armature edit mode to populate the Armature object */
+  ED_armature_from_edit(bmain, armature);
+  ED_armature_edit_free(armature);
+
+  ED_armature_to_edit(armature);
+  if (this->import_settings->find_chains) {
+    connect_bone_chains(armature, (Bone *)armature->bonebase.first, UNLIMITED_CHAIN_MAX);
+  }
+  fix_leaf_bone_hierarchy(
+      armature, (Bone *)armature->bonebase.first, this->import_settings->fix_orientation);
+  ED_armature_from_edit(bmain, armature);
+  ED_armature_edit_free(armature);
+
+  DEG_id_tag_update(&ob_arm->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
+
+  return ob_arm;
 }
 
-void ArmatureImporter::set_pose(Object *ob_arm,  COLLADAFW::Node *root_node, const char *parentname, float parent_mat[4][4])
+void ArmatureImporter::set_pose(Object *ob_arm,
+                                COLLADAFW::Node *root_node,
+                                const char *parentname,
+                                float parent_mat[4][4])
 {
-	const char *bone_name = bc_get_joint_name(root_node);
-	float mat[4][4];
-	float obmat[4][4];
-
-	// object-space
-	get_node_mat(obmat, root_node, NULL, NULL);
-
-	//if (*edbone)
-	bPoseChannel *pchan  = BKE_pose_channel_find_name(ob_arm->pose, bone_name);
-	//else fprintf ( "",
-
-	// get world-space
-	if (parentname) {
-		mul_m4_m4m4(mat, parent_mat, obmat);
-		bPoseChannel *parchan = BKE_pose_channel_find_name(ob_arm->pose, parentname);
-
-		mul_m4_m4m4(pchan->pose_mat, parchan->pose_mat, mat);
-
-	}
-	else {
-
-		copy_m4_m4(mat, obmat);
-		float invObmat[4][4];
-		invert_m4_m4(invObmat, ob_arm->obmat);
-		mul_m4_m4m4(pchan->pose_mat, invObmat, mat);
-
-	}
-
-	//float angle = 0.0f;
-	///*mat4_to_axis_angle(ax, &angle, mat);
-	//pchan->bone->roll = angle;*/
-
-
-	COLLADAFW::NodePointerArray& children = root_node->getChildNodes();
-	for (unsigned int i = 0; i < children.getCount(); i++) {
-		set_pose(ob_arm, children[i], bone_name, mat);
-	}
-
+  const char *bone_name = bc_get_joint_name(root_node);
+  float mat[4][4];
+  float obmat[4][4];
+
+  // object-space
+  get_node_mat(obmat, root_node, NULL, NULL);
+
+  //if (*edbone)
+  bPoseChannel *pchan = BKE_pose_channel_find_name(ob_arm->pose, bone_name);
+  //else fprintf ( "",
+
+  // get world-space
+  if (parentname) {
+    mul_m4_m4m4(mat, parent_mat, obmat);
+    bPoseChannel *parchan = BKE_pose_channel_find_name(ob_arm->pose, parentname);
+
+    mul_m4_m4m4(pchan->pose_mat, parchan->pose_mat, mat);
+  }
+  else {
+
+    copy_m4_m4(mat, obmat);
+    float invObmat[4][4];
+    invert_m4_m4(invObmat, ob_arm->obmat);
+    mul_m4_m4m4(pchan->pose_mat, invObmat, mat);
+  }
+
+  //float angle = 0.0f;
+  ///*mat4_to_axis_angle(ax, &angle, mat);
+  //pchan->bone->roll = angle;*/
+
+  COLLADAFW::NodePointerArray &children = root_node->getChildNodes();
+  for (unsigned int i = 0; i < children.getCount(); i++) {
+    set_pose(ob_arm, children[i], bone_name, mat);
+  }
 }
 
 /**
@@ -680,335 +700,344 @@ void ArmatureImporter::set_pose(Object *ob_arm,  COLLADAFW::Node *root_node, con
  */
 void ArmatureImporter::add_root_joint(COLLADAFW::Node *node, Object *parent)
 {
-	root_joints.push_back(node);
-	if (parent) {
-		joint_parent_map[node->getUniqueId()] = parent;
-	}
+  root_joints.push_back(node);
+  if (parent) {
+    joint_parent_map[node->getUniqueId()] = parent;
+  }
 }
 
 #if 0
 void ArmatureImporter::add_root_joint(COLLADAFW::Node *node)
 {
-	// root_joints.push_back(node);
-	Object *ob_arm = find_armature(node);
-	if (ob_arm) {
-		get_armature_joints(ob_arm).root_joints.push_back(node);
-	}
-#ifdef COLLADA_DEBUG
-	else {
-		fprintf(stderr, "%s cannot be added to armature.\n", get_joint_name(node));
-	}
-#endif
+  // root_joints.push_back(node);
+  Object *ob_arm = find_armature(node);
+  if (ob_arm) {
+    get_armature_joints(ob_arm).root_joints.push_back(node);
+  }
+#  ifdef COLLADA_DEBUG
+  else {
+    fprintf(stderr, "%s cannot be added to armature.\n", get_joint_name(node));
+  }
+#  endif
 }
 #endif
 
 // here we add bones to armatures, having armatures previously created in write_controller
 void ArmatureImporter::make_armatures(bContext *C, std::vector<Object *> &objects_to_scale)
 {
-	Main *bmain = CTX_data_main(C);
-	std::vector<Object *> ob_arms;
-	std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
+  Main *bmain = CTX_data_main(C);
+  std::vector<Object *> ob_arms;
+  std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
 
-	leaf_bone_length = FLT_MAX; /*TODO: Make this work for more than one armature in the import file*/
+  leaf_bone_length =
+      FLT_MAX; /*TODO: Make this work for more than one armature in the import file*/
 
-	for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
+  for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
 
-		SkinInfo& skin = it->second;
+    SkinInfo &skin = it->second;
 
-		Object *ob_arm = create_armature_bones(bmain, skin);
+    Object *ob_arm = create_armature_bones(bmain, skin);
 
-		// link armature with a mesh object
-		const COLLADAFW::UniqueId &uid = skin.get_controller_uid();
-		const COLLADAFW::UniqueId *guid = get_geometry_uid(uid);
-		if (guid != NULL) {
-			Object *ob = mesh_importer->get_object_by_geom_uid(*guid);
-			if (ob) {
-				skin.link_armature(C, ob, joint_by_uid, this);
+    // link armature with a mesh object
+    const COLLADAFW::UniqueId &uid = skin.get_controller_uid();
+    const COLLADAFW::UniqueId *guid = get_geometry_uid(uid);
+    if (guid != NULL) {
+      Object *ob = mesh_importer->get_object_by_geom_uid(*guid);
+      if (ob) {
+        skin.link_armature(C, ob, joint_by_uid, this);
 
-				std::vector<Object *>::iterator ob_it = std::find(objects_to_scale.begin(), objects_to_scale.end(), ob);
+        std::vector<Object *>::iterator ob_it = std::find(
+            objects_to_scale.begin(), objects_to_scale.end(), ob);
 
-				if (ob_it != objects_to_scale.end()) {
-					int index = ob_it - objects_to_scale.begin();
-					objects_to_scale.erase(objects_to_scale.begin() + index);
-				}
+        if (ob_it != objects_to_scale.end()) {
+          int index = ob_it - objects_to_scale.begin();
+          objects_to_scale.erase(objects_to_scale.begin() + index);
+        }
 
-				if (std::find(objects_to_scale.begin(), objects_to_scale.end(), ob_arm) == objects_to_scale.end()) {
-					objects_to_scale.push_back(ob_arm);
-				}
+        if (std::find(objects_to_scale.begin(), objects_to_scale.end(), ob_arm) ==
+            objects_to_scale.end()) {
+          objects_to_scale.push_back(ob_arm);
+        }
 
-				if (std::find(ob_arms.begin(), ob_arms.end(), ob_arm) == ob_arms.end()) {
-					ob_arms.push_back(ob_arm);
-				}
-			}
-			else
-				fprintf(stderr, "Cannot find object to link armature with.\n");
-		}
-		else
-			fprintf(stderr, "Cannot find geometry to link armature with.\n");
+        if (std::find(ob_arms.begin(), ob_arms.end(), ob_arm) == ob_arms.end()) {
+          ob_arms.push_back(ob_arm);
+        }
+      }
+      else
+        fprintf(stderr, "Cannot find object to link armature with.\n");
+    }
+    else
+      fprintf(stderr, "Cannot find geometry to link armature with.\n");
 
-		// set armature parent if any
-		Object *par = skin.get_parent();
-		if (par)
-			bc_set_parent(skin.BKE_armature_from_object(), par, C, false);
+    // set armature parent if any
+    Object *par = skin.get_parent();
+    if (par)
+      bc_set_parent(skin.BKE_armature_from_object(), par, C, false);
 
-		// free memory stolen from SkinControllerData
-		skin.free();
-	}
+    // free memory stolen from SkinControllerData
+    skin.free();
+  }
 
-	//for bones without skins
-	create_armature_bones(bmain, ob_arms);
+  //for bones without skins
+  create_armature_bones(bmain, ob_arms);
 
-	// Fix bone relations
-	std::vector<Object *>::iterator ob_arm_it;
-	for (ob_arm_it = ob_arms.begin(); ob_arm_it != ob_arms.end(); ob_arm_it++) {
+  // Fix bone relations
+  std::vector<Object *>::iterator ob_arm_it;
+  for (ob_arm_it = ob_arms.begin(); ob_arm_it != ob_arms.end(); ob_arm_it++) {
 
-		Object *ob_arm = *ob_arm_it;
-		bArmature *armature = (bArmature *)ob_arm->data;
+    Object *ob_arm = *ob_arm_it;
+    bArmature *armature = (bArmature *)ob_arm->data;
 
-		/* and step back to edit mode to fix the leaf nodes */
-		ED_armature_to_edit(armature);
+    /* and step back to edit mode to fix the leaf nodes */
+    ED_armature_to_edit(armature);
 
-		fix_parent_connect(armature, (Bone *)armature->bonebase.first);
+    fix_parent_connect(armature, (Bone *)armature->bonebase.first);
 
-		ED_armature_from_edit(bmain, armature);
-		ED_armature_edit_free(armature);
-	}
+    ED_armature_from_edit(bmain, armature);
+    ED_armature_edit_free(armature);
+  }
 }
 
 #if 0
 // link with meshes, create vertex groups, assign weights
 void ArmatureImporter::link_armature(Object *ob_arm, const COLLADAFW::UniqueId& geom_id, const COLLADAFW::UniqueId& controller_data_id)
 {
-	Object *ob = mesh_importer->get_object_by_geom_uid(geom_id);
+  Object *ob = mesh_importer->get_object_by_geom_uid(geom_id);
 
-	if (!ob) {
-		fprintf(stderr, "Cannot find object by geometry UID.\n");
-		return;
-	}
+  if (!ob) {
+    fprintf(stderr, "Cannot find object by geometry UID.\n");
+    return;
+  }
 
-	if (skin_by_data_uid.find(controller_data_id) == skin_by_data_uid.end()) {
-		fprintf(stderr, "Cannot find skin info by controller data UID.\n");
-		return;
-	}
+  if (skin_by_data_uid.find(controller_data_id) == skin_by_data_uid.end()) {
+    fprintf(stderr, "Cannot find skin info by controller data UID.\n");
+    return;
+  }
 
-	SkinInfo& skin = skin_by_data_uid[conroller_data_id];
+  SkinInfo& skin = skin_by_data_uid[conroller_data_id];
 
-	// create vertex groups
+  // create vertex groups
 }
 #endif
 
 bool ArmatureImporter::write_skin_controller_data(const COLLADAFW::SkinControllerData *data)
 {
-	// at this stage we get vertex influence info that should go into me->verts and ob->defbase
-	// there's no info to which object this should be long so we associate it with skin controller data UID
+  // at this stage we get vertex influence info that should go into me->verts and ob->defbase
+  // there's no info to which object this should be long so we associate it with skin controller data UID
 
-	// don't forget to call defgroup_unique_name before we copy
+  // don't forget to call defgroup_unique_name before we copy
 
-	// controller data uid -> [armature] -> joint data,
-	// [mesh object]
-	//
+  // controller data uid -> [armature] -> joint data,
+  // [mesh object]
+  //
 
-	SkinInfo skin(unit_converter);
-	skin.borrow_skin_controller_data(data);
+  SkinInfo skin(unit_converter);
+  skin.borrow_skin_controller_data(data);
 
-	// store join inv bind matrix to use it later in armature construction
-	const COLLADAFW::Matrix4Array& inv_bind_mats = data->getInverseBindMatrices();
-	for (unsigned int i = 0; i < data->getJointsCount(); i++) {
-		skin.add_joint(inv_bind_mats[i]);
-	}
+  // store join inv bind matrix to use it later in armature construction
+  const COLLADAFW::Matrix4Array &inv_bind_mats = data->getInverseBindMatrices();
+  for (unsigned int i = 0; i < data->getJointsCount(); i++) {
+    skin.add_joint(inv_bind_mats[i]);
+  }
 
-	skin_by_data_uid[data->getUniqueId()] = skin;
+  skin_by_data_uid[data->getUniqueId()] = skin;
 
-	return true;
+  return true;
 }
 
 bool ArmatureImporter::write_controller(const COLLADAFW::Controller *controller)
 {
-	// - create and store armature object
-	const COLLADAFW::UniqueId& con_id = controller->getUniqueId();
-
-	if (controller->getControllerType() == COLLADAFW::Controller::CONTROLLER_TYPE_SKIN) {
-		COLLADAFW::SkinController *co = (COLLADAFW::SkinController *)controller;
-		// to be able to find geom id by controller id
-		geom_uid_by_controller_uid[con_id] = co->getSource();
-
-		const COLLADAFW::UniqueId& data_uid = co->getSkinControllerData();
-		if (skin_by_data_uid.find(data_uid) == skin_by_data_uid.end()) {
-			fprintf(stderr, "Cannot find skin by controller data UID.\n");
-			return true;
-		}
-
-		skin_by_data_uid[data_uid].set_controller(co);
-	}
-	// morph controller
-	else if (controller->getControllerType() == COLLADAFW::Controller::CONTROLLER_TYPE_MORPH) {
-		COLLADAFW::MorphController *co = (COLLADAFW::MorphController *)controller;
-		// to be able to find geom id by controller id
-		geom_uid_by_controller_uid[con_id] = co->getSource();
-		//Shape keys are applied in DocumentImporter->finish()
-		morph_controllers.push_back(co);
-	}
-
-	return true;
+  // - create and store armature object
+  const COLLADAFW::UniqueId &con_id = controller->getUniqueId();
+
+  if (controller->getControllerType() == COLLADAFW::Controller::CONTROLLER_TYPE_SKIN) {
+    COLLADAFW::SkinController *co = (COLLADAFW::SkinController *)controller;
+    // to be able to find geom id by controller id
+    geom_uid_by_controller_uid[con_id] = co->getSource();
+
+    const COLLADAFW::UniqueId &data_uid = co->getSkinControllerData();
+    if (skin_by_data_uid.find(data_uid) == skin_by_data_uid.end()) {
+      fprintf(stderr, "Cannot find skin by controller data UID.\n");
+      return true;
+    }
+
+    skin_by_data_uid[data_uid].set_controller(co);
+  }
+  // morph controller
+  else if (controller->getControllerType() == COLLADAFW::Controller::CONTROLLER_TYPE_MORPH) {
+    COLLADAFW::MorphController *co = (COLLADAFW::MorphController *)controller;
+    // to be able to find geom id by controller id
+    geom_uid_by_controller_uid[con_id] = co->getSource();
+    //Shape keys are applied in DocumentImporter->finish()
+    morph_controllers.push_back(co);
+  }
+
+  return true;
 }
 
 void ArmatureImporter::make_shape_keys(bContext *C)
 {
-	Main *bmain = CTX_data_main(C);
-	std::vector<COLLADAFW::MorphController *>::iterator mc;
-	float weight;
-
-	for (mc = morph_controllers.begin(); mc != morph_controllers.end(); mc++) {
-		//Controller data
-		COLLADAFW::UniqueIdArray& morphTargetIds = (*mc)->getMorphTargets();
-		COLLADAFW::FloatOrDoubleArray& morphWeights = (*mc)->getMorphWeights();
-
-		//Prereq: all the geometries must be imported and mesh objects must be made
-		Object *source_ob = this->mesh_importer->get_object_by_geom_uid((*mc)->getSource());
-
-		if (source_ob) {
-
-			Mesh *source_me = (Mesh *)source_ob->data;
-			//insert key to source mesh
-			Key *key = source_me->key = BKE_key_add(bmain, (ID *)source_me);
-			key->type = KEY_RELATIVE;
-			KeyBlock *kb;
-
-			//insert basis key
-			kb = BKE_keyblock_add_ctime(key, "Basis", false);
-			BKE_keyblock_convert_from_mesh(source_me, key, kb);
-
-			//insert other shape keys
-			for (int i = 0 ; i < morphTargetIds.getCount() ; i++ ) {
-				//better to have a separate map of morph objects,
-				//This'll do for now since only mesh morphing is imported
-
-				Mesh *me = this->mesh_importer->get_mesh_by_geom_uid(morphTargetIds[i]);
-
-				if (me) {
-					me->key = key;
-					std::string morph_name = *this->mesh_importer->get_geometry_name(me->id.name);
-
-					kb = BKE_keyblock_add_ctime(key, morph_name.c_str(), false);
-					BKE_keyblock_convert_from_mesh(me, key, kb);
-
-					//apply weights
-					weight =  morphWeights.getFloatValues()->getData()[i];
-					kb->curval = weight;
-				}
-				else {
-					fprintf(stderr, "Morph target geometry not found.\n");
-				}
-			}
-		}
-		else {
-			fprintf(stderr, "Morph target object not found.\n");
-		}
-	}
+  Main *bmain = CTX_data_main(C);
+  std::vector<COLLADAFW::MorphController *>::iterator mc;
+  float weight;
+
+  for (mc = morph_controllers.begin(); mc != morph_controllers.end(); mc++) {
+    //Controller data
+    COLLADAFW::UniqueIdArray &morphTargetIds = (*mc)->getMorphTargets();
+    COLLADAFW::FloatOrDoubleArray &morphWeights = (*mc)->getMorphWeights();
+
+    //Prereq: all the geometries must be imported and mesh objects must be made
+    Object *source_ob = this->mesh_importer->get_object_by_geom_uid((*mc)->getSource());
+
+    if (source_ob) {
+
+      Mesh *source_me = (Mesh *)source_ob->data;
+      //insert key to source mesh
+      Key *key = source_me->key = BKE_key_add(bmain, (ID *)source_me);
+      key->type = KEY_RELATIVE;
+      KeyBlock *kb;
+
+      //insert basis key
+      kb = BKE_keyblock_add_ctime(key, "Basis", false);
+      BKE_keyblock_convert_from_mesh(source_me, key, kb);
+
+      //insert other shape keys
+      for (int i = 0; i < morphTargetIds.getCount(); i++) {
+        //better to have a separate map of morph objects,
+        //This'll do for now since only mesh morphing is imported
+
+        Mesh *me = this->mesh_importer->get_mesh_by_geom_uid(morphTargetIds[i]);
+
+        if (me) {
+          me->key = key;
+          std::string morph_name = *this->mesh_importer->get_geometry_name(me->id.name);
+
+          kb = BKE_keyblock_add_ctime(key, morph_name.c_str(), false);
+          BKE_keyblock_convert_from_mesh(me, key, kb);
+
+          //apply weights
+          weight = morphWeights.getFloatValues()->getData()[i];
+          kb->curval = weight;
+        }
+        else {
+          fprintf(stderr, "Morph target geometry not found.\n");
+        }
+      }
+    }
+    else {
+      fprintf(stderr, "Morph target object not found.\n");
+    }
+  }
 }
 
-
-COLLADAFW::UniqueId *ArmatureImporter::get_geometry_uid(const COLLADAFW::UniqueId& controller_uid)
+COLLADAFW::UniqueId *ArmatureImporter::get_geometry_uid(const COLLADAFW::UniqueId &controller_uid)
 {
-	if (geom_uid_by_controller_uid.find(controller_uid) == geom_uid_by_controller_uid.end())
-		return NULL;
+  if (geom_uid_by_controller_uid.find(controller_uid) == geom_uid_by_controller_uid.end())
+    return NULL;
 
-	return &geom_uid_by_controller_uid[controller_uid];
+  return &geom_uid_by_controller_uid[controller_uid];
 }
 
 Object *ArmatureImporter::get_armature_for_joint(COLLADAFW::Node *node)
 {
-	std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
-	for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
-		SkinInfo& skin = it->second;
-
-		if (skin.uses_joint_or_descendant(node))
-			return skin.BKE_armature_from_object();
-	}
-
-	std::map<COLLADAFW::UniqueId, Object *>::iterator arm;
-	for (arm = unskinned_armature_map.begin(); arm != unskinned_armature_map.end(); arm++) {
-		if (arm->first == node->getUniqueId() )
-			return arm->second;
-	}
-	return NULL;
+  std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
+  for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
+    SkinInfo &skin = it->second;
+
+    if (skin.uses_joint_or_descendant(node))
+      return skin.BKE_armature_from_object();
+  }
+
+  std::map<COLLADAFW::UniqueId, Object *>::iterator arm;
+  for (arm = unskinned_armature_map.begin(); arm != unskinned_armature_map.end(); arm++) {
+    if (arm->first == node->getUniqueId())
+      return arm->second;
+  }
+  return NULL;
 }
 
-void ArmatureImporter::set_tags_map(TagsMap & tagsMap)
+void ArmatureImporter::set_tags_map(TagsMap &tagsMap)
 {
-	this->uid_tags_map = tagsMap;
+  this->uid_tags_map = tagsMap;
 }
 
-void ArmatureImporter::get_rna_path_for_joint(COLLADAFW::Node *node, char *joint_path, size_t count)
+void ArmatureImporter::get_rna_path_for_joint(COLLADAFW::Node *node,
+                                              char *joint_path,
+                                              size_t count)
 {
-	BLI_snprintf(joint_path, count, "pose.bones[\"%s\"]", bc_get_joint_name(node));
+  BLI_snprintf(joint_path, count, "pose.bones[\"%s\"]", bc_get_joint_name(node));
 }
 
 // gives a world-space mat
 bool ArmatureImporter::get_joint_bind_mat(float m[4][4], COLLADAFW::Node *joint)
 {
-	std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
-	bool found = false;
-	for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
-		SkinInfo& skin = it->second;
-		if ((found = skin.get_joint_inv_bind_matrix(m, joint))) {
-			invert_m4(m);
-			break;
-		}
-	}
-
-	return found;
+  std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
+  bool found = false;
+  for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
+    SkinInfo &skin = it->second;
+    if ((found = skin.get_joint_inv_bind_matrix(m, joint))) {
+      invert_m4(m);
+      break;
+    }
+  }
+
+  return found;
 }
 
-BoneExtended &ArmatureImporter::add_bone_extended(EditBone *bone, COLLADAFW::Node *node, int sibcount, std::vector<std::string> &layer_labels, BoneExtensionMap &extended_bones)
+BoneExtended &ArmatureImporter::add_bone_extended(EditBone *bone,
+                                                  COLLADAFW::Node *node,
+                                                  int sibcount,
+                                                  std::vector<std::string> &layer_labels,
+                                                  BoneExtensionMap &extended_bones)
 {
-	BoneExtended *be = new BoneExtended(bone);
-	extended_bones[bone->name] = be;
+  BoneExtended *be = new BoneExtended(bone);
+  extended_bones[bone->name] = be;
 
-	TagsMap::iterator etit;
-	ExtraTags *et = 0;
-	etit = uid_tags_map.find(node->getUniqueId().toAscii());
+  TagsMap::iterator etit;
+  ExtraTags *et = 0;
+  etit = uid_tags_map.find(node->getUniqueId().toAscii());
 
-	bool has_connect = false;
-	int connect_type = -1;
+  bool has_connect = false;
+  int connect_type = -1;
 
-	if (etit != uid_tags_map.end()) {
+  if (etit != uid_tags_map.end()) {
 
-		float tail[3] = { FLT_MAX, FLT_MAX, FLT_MAX };
-		float roll = 0;
-		std::string layers;
+    float tail[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
+    float roll = 0;
+    std::string layers;
 
-		et = etit->second;
+    et = etit->second;
 
-		bool has_tail = false;
-		has_tail |= et->setData("tip_x", &tail[0]);
-		has_tail |= et->setData("tip_y", &tail[1]);
-		has_tail |= et->setData("tip_z", &tail[2]);
+    bool has_tail = false;
+    has_tail |= et->setData("tip_x", &tail[0]);
+    has_tail |= et->setData("tip_y", &tail[1]);
+    has_tail |= et->setData("tip_z", &tail[2]);
 
-		has_connect   = et->setData("connect", &connect_type);
-		bool has_roll = et->setData("roll", &roll);
+    has_connect = et->setData("connect", &connect_type);
+    bool has_roll = et->setData("roll", &roll);
 
-		layers = et->setData("layer", layers);
+    layers = et->setData("layer", layers);
 
-		if (has_tail && !has_connect)
-		{
-			/* got a bone tail definition but no connect info -> bone is not connected */
-			has_connect  = true;
-			connect_type = 0;
-		}
+    if (has_tail && !has_connect) {
+      /* got a bone tail definition but no connect info -> bone is not connected */
+      has_connect = true;
+      connect_type = 0;
+    }
 
-		be->set_bone_layers(layers, layer_labels);
-		if (has_tail) be->set_tail(tail);
-		if (has_roll) be->set_roll(roll);
-	}
+    be->set_bone_layers(layers, layer_labels);
+    if (has_tail)
+      be->set_tail(tail);
+    if (has_roll)
+      be->set_roll(roll);
+  }
 
-	if (!has_connect && this->import_settings->auto_connect) {
-		/* auto connect only whyen parent has exactly one child*/
-		connect_type = sibcount == 1;
-	}
+  if (!has_connect && this->import_settings->auto_connect) {
+    /* auto connect only whyen parent has exactly one child*/
+    connect_type = sibcount == 1;
+  }
 
-	be->set_use_connect(connect_type);
-	be->set_leaf_bone(true);
+  be->set_use_connect(connect_type);
+  be->set_leaf_bone(true);
 
-	return *be;
+  return *be;
 }