// TODO:
// * name imported objects
// * import object rotation as euler

#include "COLLADAFWRoot.h"
#include "COLLADAFWIWriter.h"
#include "COLLADAFWStableHeaders.h"
#include "COLLADAFWAnimationCurve.h"
#include "COLLADAFWAnimationList.h"
#include "COLLADAFWCamera.h"
#include "COLLADAFWColorOrTexture.h"
#include "COLLADAFWEffect.h"
#include "COLLADAFWFloatOrDoubleArray.h"
#include "COLLADAFWGeometry.h"
#include "COLLADAFWImage.h"
#include "COLLADAFWIndexList.h"
#include "COLLADAFWInstanceGeometry.h"
#include "COLLADAFWLight.h"
#include "COLLADAFWMaterial.h"
#include "COLLADAFWMesh.h"
#include "COLLADAFWMeshPrimitiveWithFaceVertexCount.h"
#include "COLLADAFWNode.h"
#include "COLLADAFWPolygons.h"
#include "COLLADAFWSampler.h"
#include "COLLADAFWSkinController.h"
#include "COLLADAFWSkinControllerData.h"
#include "COLLADAFWTransformation.h"
#include "COLLADAFWTranslate.h"
#include "COLLADAFWRotate.h"
#include "COLLADAFWScale.h"
#include "COLLADAFWMatrix.h"
#include "COLLADAFWTypes.h"
#include "COLLADAFWVisualScene.h"
#include "COLLADAFWFileInfo.h"
#include "COLLADAFWArrayPrimitiveType.h"

#include "COLLADASaxFWLLoader.h"

// TODO move "extern C" into header files
extern "C" 
{
#include "ED_keyframing.h"
#include "ED_armature.h"
#include "ED_mesh.h" // ED_vgroup_vert_add, ...
#include "ED_anim_api.h"
#include "ED_object.h"

#include "WM_types.h"
#include "WM_api.h"

#include "BKE_main.h"
#include "BKE_customdata.h"
#include "BKE_library.h"
#include "BKE_texture.h"
#include "BKE_fcurve.h"
#include "BKE_depsgraph.h"
#include "BLI_path_util.h"
#include "BKE_displist.h"
#include "BLI_math.h"
#include "BKE_scene.h"
}
#include "BKE_armature.h"
#include "BKE_mesh.h"
#include "BKE_global.h"
#include "BKE_context.h"
#include "BKE_object.h"
#include "BKE_image.h"
#include "BKE_material.h"
#include "BKE_utildefines.h"
#include "BKE_action.h"

#include "BLI_math.h"
#include "BLI_listbase.h"
#include "BLI_string.h"

#include "DNA_lamp_types.h"
#include "DNA_armature_types.h"
#include "DNA_anim_types.h"
#include "DNA_curve_types.h"
#include "DNA_texture_types.h"
#include "DNA_camera_types.h"
#include "DNA_object_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_mesh_types.h"
#include "DNA_material_types.h"
#include "DNA_scene_types.h"
#include "DNA_modifier_types.h"

#include "MEM_guardedalloc.h"

#include "DocumentImporter.h"
#include "collada_internal.h"

#include <string>
#include <map>
#include <algorithm> // sort()

#include <math.h>
#include <float.h>

// #define COLLADA_DEBUG

// creates empties for each imported bone on layer 2, for debugging
// #define ARMATURE_TEST

char *CustomData_get_layer_name(const struct CustomData *data, int type, int n);

static const char *primTypeToStr(COLLADAFW::MeshPrimitive::PrimitiveType type)
{
	using namespace COLLADAFW;
	
	switch (type) {
	case MeshPrimitive::LINES:
		return "LINES";
	case MeshPrimitive::LINE_STRIPS:
		return "LINESTRIPS";
	case MeshPrimitive::POLYGONS:
		return "POLYGONS";
	case MeshPrimitive::POLYLIST:
		return "POLYLIST";
	case MeshPrimitive::TRIANGLES:
		return "TRIANGLES";
	case MeshPrimitive::TRIANGLE_FANS:
		return "TRIANGLE_FANS";
	case MeshPrimitive::TRIANGLE_STRIPS:
		return "TRIANGLE_FANS";
	case MeshPrimitive::POINTS:
		return "POINTS";
	case MeshPrimitive::UNDEFINED_PRIMITIVE_TYPE:
		return "UNDEFINED_PRIMITIVE_TYPE";
	}
	return "UNKNOWN";
}

static const char *geomTypeToStr(COLLADAFW::Geometry::GeometryType type)
{
	switch (type) {
	case COLLADAFW::Geometry::GEO_TYPE_MESH:
		return "MESH";
	case COLLADAFW::Geometry::GEO_TYPE_SPLINE:
		return "SPLINE";
	case COLLADAFW::Geometry::GEO_TYPE_CONVEX_MESH:
		return "CONVEX_MESH";
	case COLLADAFW::Geometry::GEO_TYPE_UNKNOWN:
	default:
		return "UNKNOWN";
	}
}

// works for COLLADAFW::Node, COLLADAFW::Geometry
template<class T>
static const char *get_dae_name(T *node)
{
	const std::string& name = node->getName();
	return name.size() ? name.c_str() : node->getOriginalId().c_str();
}

// use this for retrieving bone names, since these must be unique
template<class T>
static const char *get_joint_name(T *node)
{
	const std::string& id = node->getOriginalId();
	return id.size() ? id.c_str() : node->getName().c_str();
}

static float get_float_value(const COLLADAFW::FloatOrDoubleArray& array, unsigned int index)
{
	if (index >= array.getValuesCount())
		return 0.0f;

	if (array.getType() == COLLADAFW::MeshVertexData::DATA_TYPE_FLOAT)
		return array.getFloatValues()->getData()[index];
	else 
		return array.getDoubleValues()->getData()[index];
}

typedef std::map<COLLADAFW::TextureMapId, std::vector<MTex*> > TexIndexTextureArrayMap;

class TransformReader : public TransformBase
{
protected:

	UnitConverter *unit_converter;

	struct Animation {
		Object *ob;
		COLLADAFW::Node *node;
		COLLADAFW::Transformation *tm; // which transform is animated by an AnimationList->id
	};

public:

	TransformReader(UnitConverter* conv) : unit_converter(conv) {}

	void get_node_mat(float mat[][4], COLLADAFW::Node *node, std::map<COLLADAFW::UniqueId, Animation> *animation_map,
					  Object *ob)
	{
		float cur[4][4];
		float copy[4][4];

		unit_m4(mat);
		
		for (unsigned int i = 0; i < node->getTransformations().getCount(); i++) {

			COLLADAFW::Transformation *tm = node->getTransformations()[i];
			COLLADAFW::Transformation::TransformationType type = tm->getTransformationType();

			switch(type) {
			case COLLADAFW::Transformation::TRANSLATE:
				dae_translate_to_mat4(tm, cur);
				break;
			case COLLADAFW::Transformation::ROTATE:
				dae_rotate_to_mat4(tm, cur);
				break;
			case COLLADAFW::Transformation::SCALE:
				dae_scale_to_mat4(tm, cur);
				break;
			case COLLADAFW::Transformation::MATRIX:
				dae_matrix_to_mat4(tm, cur);
				break;
			case COLLADAFW::Transformation::LOOKAT:
			case COLLADAFW::Transformation::SKEW:
				fprintf(stderr, "LOOKAT and SKEW transformations are not supported yet.\n");
				break;
			}

			copy_m4_m4(copy, mat);
			mul_m4_m4m4(mat, cur, copy);

			if (animation_map) {
				// AnimationList that drives this Transformation
				const COLLADAFW::UniqueId& anim_list_id = tm->getAnimationList();
			
				// store this so later we can link animation data with ob
				Animation anim = {ob, node, tm};
				(*animation_map)[anim_list_id] = anim;
			}
		}
	}

	void dae_rotate_to_mat4(COLLADAFW::Transformation *tm, float m[][4])
	{
		COLLADAFW::Rotate *ro = (COLLADAFW::Rotate*)tm;
		COLLADABU::Math::Vector3& axis = ro->getRotationAxis();
		float angle = (float)(ro->getRotationAngle() * M_PI / 180.0f);
		float ax[] = {axis[0], axis[1], axis[2]};
		// float quat[4];
		// axis_angle_to_quat(quat, axis, angle);
		// quat_to_mat4(m, quat);
		axis_angle_to_mat4(m, ax, angle);
	}

	void dae_translate_to_mat4(COLLADAFW::Transformation *tm, float m[][4])
	{
		COLLADAFW::Translate *tra = (COLLADAFW::Translate*)tm;
		COLLADABU::Math::Vector3& t = tra->getTranslation();

		unit_m4(m);

		m[3][0] = (float)t[0];
		m[3][1] = (float)t[1];
		m[3][2] = (float)t[2];
	}

	void dae_scale_to_mat4(COLLADAFW::Transformation *tm, float m[][4])
	{
		COLLADABU::Math::Vector3& s = ((COLLADAFW::Scale*)tm)->getScale();
		float size[3] = {(float)s[0], (float)s[1], (float)s[2]};
		size_to_mat4(m, size);
	}

	void dae_matrix_to_mat4(COLLADAFW::Transformation *tm, float m[][4])
	{
		unit_converter->dae_matrix_to_mat4(m, ((COLLADAFW::Matrix*)tm)->getMatrix());
	}

	void dae_translate_to_v3(COLLADAFW::Transformation *tm, float v[3])
	{
		dae_vector3_to_v3(((COLLADAFW::Translate*)tm)->getTranslation(), v);
	}

	void dae_scale_to_v3(COLLADAFW::Transformation *tm, float v[3])
	{
		dae_vector3_to_v3(((COLLADAFW::Scale*)tm)->getScale(), v);
	}

	void dae_vector3_to_v3(const COLLADABU::Math::Vector3 &v3, float v[3])
	{
		v[0] = v3.x;
		v[1] = v3.y;
		v[2] = v3.z;
	}
};

// only for ArmatureImporter to "see" MeshImporter::get_object_by_geom_uid
class MeshImporterBase
{
public:
	virtual Object *get_object_by_geom_uid(const COLLADAFW::UniqueId& geom_uid) = 0;
};

// ditto as above
class AnimationImporterBase
{
public:
	// virtual void change_eul_to_quat(Object *ob, bAction *act) = 0;
};

class ArmatureImporter : private TransformReader
{
private:
	Scene *scene;
	UnitConverter *unit_converter;

	// std::map<int, JointData> joint_index_to_joint_info_map;
	// std::map<COLLADAFW::UniqueId, int> joint_id_to_joint_index_map;

	struct LeafBone {
		// COLLADAFW::Node *node;
		EditBone *bone;
		char name[32];
		float mat[4][4]; // bone matrix, derived from inv_bind_mat
	};
	std::vector<LeafBone> leaf_bones;
	// int bone_direction_row; // XXX not used
	float leaf_bone_length;
	int totbone;
	// XXX not used
	// float min_angle; // minimum angle between bone head-tail and a row of bone matrix

#if 0
	struct ArmatureJoints {
		Object *ob_arm;
		std::vector<COLLADAFW::Node*> root_joints;
	};
	std::vector<ArmatureJoints> armature_joints;
#endif

	Object *empty; // empty for leaf bones

	std::map<COLLADAFW::UniqueId, COLLADAFW::UniqueId> geom_uid_by_controller_uid;
	std::map<COLLADAFW::UniqueId, COLLADAFW::Node*> joint_by_uid; // contains all joints
	std::vector<COLLADAFW::Node*> root_joints;

	std::vector<Object*> armature_objects;

	MeshImporterBase *mesh_importer;
	AnimationImporterBase *anim_importer;

	// This is used to store data passed in write_controller_data.
	// Arrays from COLLADAFW::SkinControllerData lose ownership, so do this class members
	// so that arrays don't get freed until we free them explicitly.
	class SkinInfo
	{
	private:
		// to build armature bones from inverse bind matrices
		struct JointData {
			float inv_bind_mat[4][4]; // joint inverse bind matrix
			COLLADAFW::UniqueId joint_uid; // joint node UID
			// Object *ob_arm;			  // armature object
		};

		float bind_shape_matrix[4][4];

		// data from COLLADAFW::SkinControllerData, each array should be freed
		COLLADAFW::UIntValuesArray joints_per_vertex;
		COLLADAFW::UIntValuesArray weight_indices;
		COLLADAFW::IntValuesArray joint_indices;
		// COLLADAFW::FloatOrDoubleArray weights;
		std::vector<float> weights;

		std::vector<JointData> joint_data; // index to this vector is joint index

		UnitConverter *unit_converter;

		Object *ob_arm;
		COLLADAFW::UniqueId controller_uid;

	public:

		SkinInfo() {}

		SkinInfo(const SkinInfo& skin) : weights(skin.weights),
										 joint_data(skin.joint_data),
										 unit_converter(skin.unit_converter),
										 ob_arm(skin.ob_arm),
										 controller_uid(skin.controller_uid)
		{
			copy_m4_m4(bind_shape_matrix, (float (*)[4])skin.bind_shape_matrix);

			transfer_uint_array_data_const(skin.joints_per_vertex, joints_per_vertex);
			transfer_uint_array_data_const(skin.weight_indices, weight_indices);
			transfer_int_array_data_const(skin.joint_indices, joint_indices);
		}

		SkinInfo(UnitConverter *conv) : unit_converter(conv), ob_arm(NULL) {}

		// nobody owns the data after this, so it should be freed manually with releaseMemory
		template <class T>
		void transfer_array_data(T& src, T& dest)
		{
			dest.setData(src.getData(), src.getCount());
			src.yieldOwnerShip();
			dest.yieldOwnerShip();
		}

		// when src is const we cannot src.yieldOwnerShip, this is used by copy constructor
		void transfer_int_array_data_const(const COLLADAFW::IntValuesArray& src, COLLADAFW::IntValuesArray& dest)
		{
			dest.setData((int*)src.getData(), src.getCount());
			dest.yieldOwnerShip();
		}

		void transfer_uint_array_data_const(const COLLADAFW::UIntValuesArray& src, COLLADAFW::UIntValuesArray& dest)
		{
			dest.setData((unsigned int*)src.getData(), src.getCount());
			dest.yieldOwnerShip();
		}

		void borrow_skin_controller_data(const COLLADAFW::SkinControllerData* skin)
		{
			transfer_array_data((COLLADAFW::UIntValuesArray&)skin->getJointsPerVertex(), joints_per_vertex);
			transfer_array_data((COLLADAFW::UIntValuesArray&)skin->getWeightIndices(), weight_indices);
			transfer_array_data((COLLADAFW::IntValuesArray&)skin->getJointIndices(), joint_indices);
			// transfer_array_data(skin->getWeights(), weights);

			// cannot transfer data for FloatOrDoubleArray, copy values manually
			const COLLADAFW::FloatOrDoubleArray& weight = skin->getWeights();
			for (unsigned int i = 0; i < weight.getValuesCount(); i++)
				weights.push_back(get_float_value(weight, i));

			unit_converter->dae_matrix_to_mat4(bind_shape_matrix, skin->getBindShapeMatrix());
		}
			
		void free()
		{
			joints_per_vertex.releaseMemory();
			weight_indices.releaseMemory();
			joint_indices.releaseMemory();
			// weights.releaseMemory();
		}

		// using inverse bind matrices to construct armature
		// it is safe to invert them to get the original matrices
		// because if they are inverse matrices, they can be inverted
		void add_joint(const COLLADABU::Math::Matrix4& matrix)
		{
			JointData jd;
			unit_converter->dae_matrix_to_mat4(jd.inv_bind_mat, matrix);
			joint_data.push_back(jd);
		}

		// called from write_controller
		Object *create_armature(const COLLADAFW::SkinController* co, Scene *scene)
		{
			ob_arm = add_object(scene, OB_ARMATURE);

			controller_uid = co->getUniqueId();

			const COLLADAFW::UniqueIdArray& joint_uids = co->getJoints();
			for (unsigned int i = 0; i < joint_uids.getCount(); i++) {
				joint_data[i].joint_uid = joint_uids[i];

				// // store armature pointer
				// JointData& jd = joint_index_to_joint_info_map[i];
				// jd.ob_arm = ob_arm;

				// now we'll be able to get inv bind matrix from joint id
				// joint_id_to_joint_index_map[joint_ids[i]] = i;
			}

			return ob_arm;
		}

		bool get_joint_inv_bind_matrix(float inv_bind_mat[][4], COLLADAFW::Node *node)
		{
			const COLLADAFW::UniqueId& uid = node->getUniqueId();
			std::vector<JointData>::iterator it;
			for (it = joint_data.begin(); it != joint_data.end(); it++) {
				if ((*it).joint_uid == uid) {
					copy_m4_m4(inv_bind_mat, (*it).inv_bind_mat);
					return true;
				}
			}

			return false;
		}

		Object *get_armature()
		{
			return ob_arm;
		}

		const COLLADAFW::UniqueId& get_controller_uid()
		{
			return controller_uid;
		}

		// some nodes may not be referenced by SkinController,
		// in this case to determine if the node belongs to this armature,
		// we need to search down the tree
		bool uses_joint(COLLADAFW::Node *node)
		{
			const COLLADAFW::UniqueId& uid = node->getUniqueId();
			std::vector<JointData>::iterator it;
			for (it = joint_data.begin(); it != joint_data.end(); it++) {
				if ((*it).joint_uid == uid)
					return true;
			}

			COLLADAFW::NodePointerArray& children = node->getChildNodes();
			for (unsigned int i = 0; i < children.getCount(); i++) {
				if (this->uses_joint(children[i]))
					return true;
			}

			return false;
		}

		void link_armature(bContext *C, Object *ob, std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& joint_by_uid,
						   TransformReader *tm)
		{
			Object workob;
			Scene *scene = CTX_data_scene(C);

			ModifierData *md = ED_object_modifier_add(NULL, scene, ob, NULL, eModifierType_Armature);
			((ArmatureModifierData *)md)->object = ob_arm;

			tm->decompose(bind_shape_matrix, ob->loc, ob->rot, NULL, ob->size);

			ob->parent = ob_arm;
			ob->partype = PAROBJECT;

			what_does_parent(scene, ob, &workob);
			invert_m4_m4(ob->parentinv, workob.obmat);

			ob->recalc |= OB_RECALC_OB|OB_RECALC_DATA;

			((bArmature*)ob_arm->data)->deformflag = ARM_DEF_VGROUP;

			// create all vertex groups
			std::vector<JointData>::iterator it;
			int joint_index;
			for (it = joint_data.begin(), joint_index = 0; it != joint_data.end(); it++, joint_index++) {
				const char *name = "Group";

				// name group by joint node name
				if (joint_by_uid.find((*it).joint_uid) != joint_by_uid.end()) {
					name = get_joint_name(joint_by_uid[(*it).joint_uid]);
				}

				ED_vgroup_add_name(ob, (char*)name);
			}

			// <vcount> - number of joints per vertex - joints_per_vertex
			// <v> - [[bone index, weight index] * joints per vertex] * vertices - weight indices
			// ^ bone index can be -1 meaning weight toward bind shape, how to express this in Blender?

			// for each vertex in weight indices
			//   for each bone index in vertex
			//     add vertex to group at group index
			//     treat group index -1 specially

			// get def group by index with BLI_findlink

			for (unsigned int vertex = 0, weight = 0; vertex < joints_per_vertex.getCount(); vertex++) {

				unsigned int limit = weight + joints_per_vertex[vertex];
				for ( ; weight < limit; weight++) {
					int joint = joint_indices[weight], joint_weight = weight_indices[weight];

					// -1 means "weight towards the bind shape", we just don't assign it to any group
					if (joint != -1) {
						bDeformGroup *def = (bDeformGroup*)BLI_findlink(&ob->defbase, joint);

						ED_vgroup_vert_add(ob, def, vertex, weights[joint_weight], WEIGHT_REPLACE);
					}
				}
			}

			DAG_scene_sort(scene);
			DAG_ids_flush_update(0);
			WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, NULL);
		}

		bPoseChannel *get_pose_channel_from_node(COLLADAFW::Node *node)
		{
			return get_pose_channel(ob_arm->pose, get_joint_name(node));
		}
	};

	std::map<COLLADAFW::UniqueId, SkinInfo> skin_by_data_uid; // data UID = skin controller data UID
#if 0
	JointData *get_joint_data(COLLADAFW::Node *node)
	{
		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;
		}

		int joint_index = joint_id_to_joint_index_map[joint_id];

		return &joint_index_to_joint_info_map[joint_index];
	}
#endif

	void create_bone(SkinInfo& skin, COLLADAFW::Node *node, EditBone *parent, int totchild,
					 float parent_mat[][4], bArmature *arm)
	{
		float joint_inv_bind_mat[4][4];

		// JointData* jd = get_joint_data(node);

		float mat[4][4];

		if (skin.get_joint_inv_bind_matrix(joint_inv_bind_mat, node)) {
			// get original world-space matrix
			invert_m4_m4(mat, joint_inv_bind_mat);
		}
		// create a bone even if there's no joint data for it (i.e. it has no influence)
		else {
			float obmat[4][4];

			// object-space
			get_node_mat(obmat, node, NULL, NULL);

			// get world-space
			if (parent)
				mul_m4_m4m4(mat, obmat, parent_mat);
			else
				copy_m4_m4(mat, obmat);
		}

		// TODO rename from Node "name" attrs later
		EditBone *bone = ED_armature_edit_bone_add(arm, (char*)get_joint_name(node));
		totbone++;

		if (parent) bone->parent = parent;

		// set head
		copy_v3_v3(bone->head, mat[3]);

		// set tail, don't set it to head because 0-length bones are not allowed
		float vec[3] = {0.0f, 0.5f, 0.0f};
		add_v3_v3v3(bone->tail, bone->head, vec);

		// set parent tail
		if (parent && totchild == 1) {
			copy_v3_v3(parent->tail, bone->head);

			// not setting BONE_CONNECTED because this would lock child bone location with respect to parent
			// bone->flag |= BONE_CONNECTED;

			// XXX increase this to prevent "very" small bones?
			const float epsilon = 0.000001f;

			// derive leaf bone length
			float length = len_v3v3(parent->head, parent->tail);
			if ((length < leaf_bone_length || totbone == 0) && length > epsilon) {
				leaf_bone_length = length;
			}

			// treat zero-sized bone like a leaf bone
			if (length <= epsilon) {
				add_leaf_bone(parent_mat, parent);
			}

			/*
#if 0
			// and which row in mat is bone direction
			float vec[3];
			sub_v3_v3v3(vec, parent->tail, parent->head);
#ifdef COLLADA_DEBUG
			print_v3("tail - head", vec);
			print_m4("matrix", parent_mat);
#endif
			for (int i = 0; i < 3; i++) {
#ifdef COLLADA_DEBUG
				char *axis_names[] = {"X", "Y", "Z"};
				printf("%s-axis length is %f\n", axis_names[i], len_v3(parent_mat[i]));
#endif
				float angle = angle_v2v2(vec, parent_mat[i]);
				if (angle < min_angle) {
#ifdef COLLADA_DEBUG
					print_v3("picking", parent_mat[i]);
					printf("^ %s axis of %s's matrix\n", axis_names[i], get_dae_name(node));
#endif
					bone_direction_row = i;
					min_angle = angle;
				}
			}
#endif
			*/
		}

		COLLADAFW::NodePointerArray& children = node->getChildNodes();
		for (unsigned int i = 0; i < children.getCount(); i++) {
			create_bone(skin, children[i], bone, children.getCount(), mat, arm);
		}

		// in second case it's not a leaf bone, but we handle it the same way
		if (!children.getCount() || children.getCount() > 1) {
			add_leaf_bone(mat, bone);
		}
	}

	void add_leaf_bone(float mat[][4], EditBone *bone)
	{
		LeafBone leaf;

		leaf.bone = bone;
		copy_m4_m4(leaf.mat, mat);
		BLI_strncpy(leaf.name, bone->name, sizeof(leaf.name));

		leaf_bones.push_back(leaf);
	}

	void fix_leaf_bones()
	{
		// just setting tail for leaf bones here

		std::vector<LeafBone>::iterator it;
		for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
			LeafBone& leaf = *it;

			// pointing up
			float vec[3] = {0.0f, 0.0f, 1.0f};

			mul_v3_fl(vec, leaf_bone_length);

			copy_v3_v3(leaf.bone->tail, leaf.bone->head);
			add_v3_v3v3(leaf.bone->tail, leaf.bone->head, vec);
		}
	}

	void 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 = get_pose_channel(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);
			}
		}
	}

#if 0
	void set_euler_rotmode()
	{
		// just set rotmode = ROT_MODE_EUL on pose channel for each joint

		std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>::iterator it;

		for (it = joint_by_uid.begin(); it != joint_by_uid.end(); it++) {

			COLLADAFW::Node *joint = it->second;

			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;

				if (skin.uses_joint(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));
					}

					break;
				}
			}
		}
	}
#endif

	Object *get_empty_for_leaves()
	{
		if (empty) return empty;
		
		empty = add_object(scene, OB_EMPTY);
		empty->empty_drawtype = OB_EMPTY_SPHERE;

		return empty;
	}

#if 0
	Object *find_armature(COLLADAFW::Node *node)
	{
		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;
		}

		return NULL;
	}

	ArmatureJoints& 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();
	}
#endif

	void create_armature_bones(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 = skin.get_armature();

		// enter armature edit mode
		ED_armature_to_edit(ob_arm);

		leaf_bones.clear();
		totbone = 0;
		// bone_direction_row = 1; // TODO: don't default to Y but use asset and based on it decide on default row
		leaf_bone_length = 0.1f;
		// min_angle = 360.0f;		// minimum angle between bone head-tail and a row of bone matrix

		// create bones

		std::vector<COLLADAFW::Node*>::iterator it;
		for (it = root_joints.begin(); it != root_joints.end(); it++) {
			// since root_joints may contain joints for multiple controllers, we need to filter
			if (skin.uses_joint(*it)) {
				create_bone(skin, *it, NULL, (*it)->getChildNodes().getCount(), NULL, (bArmature*)ob_arm->data);
			}
		}

		fix_leaf_bones();

		// exit armature edit mode
		ED_armature_from_edit(ob_arm);
		ED_armature_edit_free(ob_arm);
		DAG_id_flush_update(&ob_arm->id, OB_RECALC_OB|OB_RECALC_DATA);

		set_leaf_bone_shapes(ob_arm);

		// set_euler_rotmode();
	}
	

public:

	ArmatureImporter(UnitConverter *conv, MeshImporterBase *mesh, AnimationImporterBase *anim, Scene *sce) :
		TransformReader(conv), scene(sce), empty(NULL), mesh_importer(mesh), anim_importer(anim) {}

	~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();
		}
	}

	// root - if this joint is the top joint in hierarchy, if a joint
	// is a child of a node (not joint), root should be true since
	// this is where we build armature bones from
	void add_joint(COLLADAFW::Node *node, bool root)
	{
		joint_by_uid[node->getUniqueId()] = node;
		if (root) root_joints.push_back(node);
	}

#if 0
	void 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
	}
#endif

	// here we add bones to armatures, having armatures previously created in write_controller
	void make_armatures(bContext *C)
	{
		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;

			create_armature_bones(skin);

			// link armature with an object
			Object *ob = mesh_importer->get_object_by_geom_uid(*get_geometry_uid(skin.get_controller_uid()));
			if (ob) {
				skin.link_armature(C, ob, joint_by_uid, this);
			}
			else {
				fprintf(stderr, "Cannot find object to link armature with.\n");
			}

			// free memory stolen from SkinControllerData
			skin.free();
		}
	}

#if 0
	// link with meshes, create vertex groups, assign weights
	void 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);

		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;
		}

		SkinInfo& skin = skin_by_data_uid[conroller_data_id];

		// create vertex groups
	}
#endif

	bool 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

		// don't forget to call defgroup_unique_name before we copy

		// controller data uid -> [armature] -> joint data, 
		// [mesh object]
		// 

		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]);
		}

		skin_by_data_uid[data->getUniqueId()] = skin;

		return true;
	}

	bool write_controller(const COLLADAFW::Controller* controller)
	{
		// - create and store armature object

		const COLLADAFW::UniqueId& skin_id = controller->getUniqueId();

		if (controller->getControllerType() == COLLADAFW::Controller::CONTROLLER_TYPE_SKIN) {

			COLLADAFW::SkinController *co = (COLLADAFW::SkinController*)controller;

			// to find geom id by controller id
			geom_uid_by_controller_uid[skin_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;
			}

			Object *ob_arm = skin_by_data_uid[data_uid].create_armature(co, scene);

			armature_objects.push_back(ob_arm);
		}
		// morph controller
		else {
			// shape keys? :)
			fprintf(stderr, "Morph controller is not supported yet.\n");
		}

		return true;
	}

	COLLADAFW::UniqueId *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;

		return &geom_uid_by_controller_uid[controller_uid];
	}

	Object *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(node))
				return skin.get_armature();
		}

		return NULL;
	}

	void get_rna_path_for_joint(COLLADAFW::Node *node, char *joint_path, size_t count)
	{
		BLI_snprintf(joint_path, count, "pose.bones[\"%s\"]", get_joint_name(node));
	}
	
#if 0
	void fix_animation()
	{
		/* Change Euler rotation to Quaternion for bone animation */
		std::vector<Object*>::iterator it;
		for (it = armature_objects.begin(); it != armature_objects.end(); it++) {
			Object *ob = *it;
			if (!ob || !ob->adt || !ob->adt->action) continue;
			anim_importer->change_eul_to_quat(ob, ob->adt->action);
		}
	}
#endif

	// gives a world-space mat
	bool get_joint_bind_mat(float m[][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;
	}
};

class MeshImporter : public MeshImporterBase
{
private:

	Scene *scene;
	ArmatureImporter *armature_importer;

	std::map<COLLADAFW::UniqueId, Mesh*> uid_mesh_map; // geometry unique id-to-mesh map
	std::map<COLLADAFW::UniqueId, Object*> uid_object_map; // geom uid-to-object
	// this structure is used to assign material indices to faces
	// it holds a portion of Mesh faces and corresponds to a DAE primitive list (<triangles>, <polylist>, etc.)
	struct Primitive {
		MFace *mface;
		unsigned int totface;
	};
	typedef std::map<COLLADAFW::MaterialId, std::vector<Primitive> > MaterialIdPrimitiveArrayMap;
	std::map<COLLADAFW::UniqueId, MaterialIdPrimitiveArrayMap> geom_uid_mat_mapping_map; // crazy name!
	
	class UVDataWrapper
	{
		COLLADAFW::MeshVertexData *mVData;
	public:
		UVDataWrapper(COLLADAFW::MeshVertexData& vdata) : mVData(&vdata)
		{}

#ifdef COLLADA_DEBUG
		void print()
		{
			fprintf(stderr, "UVs:\n");
			switch(mVData->getType()) {
			case COLLADAFW::MeshVertexData::DATA_TYPE_FLOAT:
				{
					COLLADAFW::ArrayPrimitiveType<float>* values = mVData->getFloatValues();
					if (values->getCount()) {
						for (int i = 0; i < values->getCount(); i += 2) {
							fprintf(stderr, "%.1f, %.1f\n", (*values)[i], (*values)[i+1]);
						}
					}
				}
				break;
			case COLLADAFW::MeshVertexData::DATA_TYPE_DOUBLE:
				{
					COLLADAFW::ArrayPrimitiveType<double>* values = mVData->getDoubleValues();
					if (values->getCount()) {
						for (int i = 0; i < values->getCount(); i += 2) {
							fprintf(stderr, "%.1f, %.1f\n", (float)(*values)[i], (float)(*values)[i+1]);
						}
					}
				}
				break;
			}
			fprintf(stderr, "\n");
		}
#endif

		void getUV(int uv_set_index, int uv_index[2], float *uv)
		{
			switch(mVData->getType()) {
			case COLLADAFW::MeshVertexData::DATA_TYPE_FLOAT:
				{
					COLLADAFW::ArrayPrimitiveType<float>* values = mVData->getFloatValues();
					if (values->empty()) return;
					uv[0] = (*values)[uv_index[0]];
					uv[1] = (*values)[uv_index[1]];
					
				}
				break;
			case COLLADAFW::MeshVertexData::DATA_TYPE_DOUBLE:
				{
					COLLADAFW::ArrayPrimitiveType<double>* values = mVData->getDoubleValues();
					if (values->empty()) return;
					uv[0] = (float)(*values)[uv_index[0]];
					uv[1] = (float)(*values)[uv_index[1]];
					
				}
				break;
			case COLLADAFW::MeshVertexData::DATA_TYPE_UNKNOWN:	
			default:
				fprintf(stderr, "MeshImporter.getUV(): unknown data type\n");
			}
		}
	};

	void set_face_indices(MFace *mface, unsigned int *indices, bool quad)
	{
		mface->v1 = indices[0];
		mface->v2 = indices[1];
		mface->v3 = indices[2];
		if (quad) mface->v4 = indices[3];
		else mface->v4 = 0;
#ifdef COLLADA_DEBUG
		// fprintf(stderr, "%u, %u, %u \n", indices[0], indices[1], indices[2]);
#endif
	}

	// not used anymore, test_index_face from blenkernel is better
#if 0
	// change face indices order so that v4 is not 0
	void rotate_face_indices(MFace *mface) {
		mface->v4 = mface->v1;
		mface->v1 = mface->v2;
		mface->v2 = mface->v3;
		mface->v3 = 0;
	}
#endif
	
	void set_face_uv(MTFace *mtface, UVDataWrapper &uvs, int uv_set_index,
					 COLLADAFW::IndexList& index_list, unsigned int *tris_indices)
	{
		int uv_indices[4][2];

		// per face vertex indices, this means for quad we have 4 indices, not 8
		COLLADAFW::UIntValuesArray& indices = index_list.getIndices();

		// make indices into FloatOrDoubleArray
		for (int i = 0; i < 3; i++) {
			int uv_index = indices[tris_indices[i]];
			uv_indices[i][0] = uv_index * 2;
			uv_indices[i][1] = uv_index * 2 + 1;
		}

		uvs.getUV(uv_set_index, uv_indices[0], mtface->uv[0]);
		uvs.getUV(uv_set_index, uv_indices[1], mtface->uv[1]);
		uvs.getUV(uv_set_index, uv_indices[2], mtface->uv[2]);
	}

	void set_face_uv(MTFace *mtface, UVDataWrapper &uvs, int uv_set_index,
					COLLADAFW::IndexList& index_list, int index, bool quad)
	{
		int uv_indices[4][2];

		// per face vertex indices, this means for quad we have 4 indices, not 8
		COLLADAFW::UIntValuesArray& indices = index_list.getIndices();

		// make indices into FloatOrDoubleArray
		for (int i = 0; i < (quad ? 4 : 3); i++) {
			int uv_index = indices[index + i];
			uv_indices[i][0] = uv_index * 2;
			uv_indices[i][1] = uv_index * 2 + 1;
		}

		uvs.getUV(uv_set_index, uv_indices[0], mtface->uv[0]);
		uvs.getUV(uv_set_index, uv_indices[1], mtface->uv[1]);
		uvs.getUV(uv_set_index, uv_indices[2], mtface->uv[2]);

		if (quad) uvs.getUV(uv_set_index, uv_indices[3], mtface->uv[3]);

#ifdef COLLADA_DEBUG
		/*if (quad) {
			fprintf(stderr, "face uv:\n"
					"((%d, %d), (%d, %d), (%d, %d), (%d, %d))\n"
					"((%.1f, %.1f), (%.1f, %.1f), (%.1f, %.1f), (%.1f, %.1f))\n",

					uv_indices[0][0], uv_indices[0][1],
					uv_indices[1][0], uv_indices[1][1],
					uv_indices[2][0], uv_indices[2][1],
					uv_indices[3][0], uv_indices[3][1],

					mtface->uv[0][0], mtface->uv[0][1],
					mtface->uv[1][0], mtface->uv[1][1],
					mtface->uv[2][0], mtface->uv[2][1],
					mtface->uv[3][0], mtface->uv[3][1]);
		}
		else {
			fprintf(stderr, "face uv:\n"
					"((%d, %d), (%d, %d), (%d, %d))\n"
					"((%.1f, %.1f), (%.1f, %.1f), (%.1f, %.1f))\n",

					uv_indices[0][0], uv_indices[0][1],
					uv_indices[1][0], uv_indices[1][1],
					uv_indices[2][0], uv_indices[2][1],

					mtface->uv[0][0], mtface->uv[0][1],
					mtface->uv[1][0], mtface->uv[1][1],
					mtface->uv[2][0], mtface->uv[2][1]);
		}*/
#endif
	}

#ifdef COLLADA_DEBUG
	void print_index_list(COLLADAFW::IndexList& index_list)
	{
		fprintf(stderr, "Index list for \"%s\":\n", index_list.getName().c_str());
		for (int i = 0; i < index_list.getIndicesCount(); i += 2) {
			fprintf(stderr, "%u, %u\n", index_list.getIndex(i), index_list.getIndex(i + 1));
		}
		fprintf(stderr, "\n");
	}
#endif

	bool is_nice_mesh(COLLADAFW::Mesh *mesh)
	{
		COLLADAFW::MeshPrimitiveArray& prim_arr = mesh->getMeshPrimitives();

		const char *name = get_dae_name(mesh);
		
		for (unsigned i = 0; i < prim_arr.getCount(); i++) {
			
			COLLADAFW::MeshPrimitive *mp = prim_arr[i];
			COLLADAFW::MeshPrimitive::PrimitiveType type = mp->getPrimitiveType();

			const char *type_str = primTypeToStr(type);
			
			// OpenCollada passes POLYGONS type for <polylist>
			if (type == COLLADAFW::MeshPrimitive::POLYLIST || type == COLLADAFW::MeshPrimitive::POLYGONS) {

				COLLADAFW::Polygons *mpvc = (COLLADAFW::Polygons*)mp;
				COLLADAFW::Polygons::VertexCountArray& vca = mpvc->getGroupedVerticesVertexCountArray();
				
				for(unsigned int j = 0; j < vca.getCount(); j++){
					int count = vca[j];
					if (count < 3) {
						fprintf(stderr, "Primitive %s in %s has at least one face with vertex count < 3\n",
								type_str, name);
						return false;
					}
				}
					
			}
			else if(type != COLLADAFW::MeshPrimitive::TRIANGLES) {
				fprintf(stderr, "Primitive type %s is not supported.\n", type_str);
				return false;
			}
		}
		
		if (mesh->getPositions().empty()) {
			fprintf(stderr, "Mesh %s has no vertices.\n", name);
			return false;
		}

		return true;
	}

	void read_vertices(COLLADAFW::Mesh *mesh, Mesh *me)
	{
		// vertices	
		me->totvert = mesh->getPositions().getFloatValues()->getCount() / 3;
		me->mvert = (MVert*)CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, me->totvert);

		COLLADAFW::MeshVertexData& pos = mesh->getPositions();
		MVert *mvert;
		int i;

		for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++)
			get_vector(mvert->co, pos, i);
	}
	
	int triangulate_poly(unsigned int *indices, int totvert, MVert *verts, std::vector<unsigned int>& tri)
	{
		ListBase dispbase;
		DispList *dl;
		float *vert;
		int i = 0;
		
		dispbase.first = dispbase.last = NULL;
		
		dl = (DispList*)MEM_callocN(sizeof(DispList), "poly disp");
		dl->nr = totvert;
		dl->type = DL_POLY;
		dl->parts = 1;
		dl->verts = vert = (float*)MEM_callocN(totvert * 3 * sizeof(float), "poly verts");
		dl->index = (int*)MEM_callocN(sizeof(int) * 3 * totvert, "dl index");

		BLI_addtail(&dispbase, dl);
		
		for (i = 0; i < totvert; i++) {
			copy_v3_v3(vert, verts[indices[i]].co);
			vert += 3;
		}
		
		filldisplist(&dispbase, &dispbase);

		int tottri = 0;
		dl= (DispList*)dispbase.first;

		if (dl->type == DL_INDEX3) {
			tottri = dl->parts;

			int *index = dl->index;
			for (i= 0; i < tottri; i++) {
				int t[3]= {*index, *(index + 1), *(index + 2)};

				std::sort(t, t + 3);

				tri.push_back(t[0]);
				tri.push_back(t[1]);
				tri.push_back(t[2]);

				index += 3;
			}
		}

		freedisplist(&dispbase);

		return tottri;
	}
	
	int count_new_tris(COLLADAFW::Mesh *mesh, Mesh *me)
	{
		COLLADAFW::MeshPrimitiveArray& prim_arr = mesh->getMeshPrimitives();
		unsigned int i;
		int tottri = 0;
		
		for (i = 0; i < prim_arr.getCount(); i++) {
			
			COLLADAFW::MeshPrimitive *mp = prim_arr[i];
			int type = mp->getPrimitiveType();
			size_t prim_totface = mp->getFaceCount();
			unsigned int *indices = mp->getPositionIndices().getData();
			
			if (type == COLLADAFW::MeshPrimitive::POLYLIST ||
				type == COLLADAFW::MeshPrimitive::POLYGONS) {
				
				COLLADAFW::Polygons *mpvc =	(COLLADAFW::Polygons*)mp;
				COLLADAFW::Polygons::VertexCountArray& vcounta = mpvc->getGroupedVerticesVertexCountArray();
				
				for (unsigned int j = 0; j < prim_totface; j++) {
					int vcount = vcounta[j];
					
					if (vcount > 4) {
						std::vector<unsigned int> tri;
						
						// tottri += triangulate_poly(indices, vcount, me->mvert, tri) - 1; // XXX why - 1?!
						tottri += triangulate_poly(indices, vcount, me->mvert, tri);
					}

					indices += vcount;
				}
			}
		}
		return tottri;
	}
	
	// TODO: import uv set names
	void read_faces(COLLADAFW::Mesh *mesh, Mesh *me, int new_tris)
	{
		unsigned int i;
		
		// allocate faces
		me->totface = mesh->getFacesCount() + new_tris;
		me->mface = (MFace*)CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, me->totface);
		
		// allocate UV layers
		unsigned int totuvset = mesh->getUVCoords().getInputInfosArray().getCount();

		for (i = 0; i < totuvset; i++) {
			CustomData_add_layer(&me->fdata, CD_MTFACE, CD_CALLOC, NULL, me->totface);
			//this->set_layername_map[i] = CustomData_get_layer_name(&me->fdata, CD_MTFACE, i);
		}

		// activate the first uv layer
		if (totuvset) me->mtface = (MTFace*)CustomData_get_layer_n(&me->fdata, CD_MTFACE, 0);

		UVDataWrapper uvs(mesh->getUVCoords());

#ifdef COLLADA_DEBUG
		// uvs.print();
#endif

		MFace *mface = me->mface;

		MaterialIdPrimitiveArrayMap mat_prim_map;

		int face_index = 0;

		COLLADAFW::MeshPrimitiveArray& prim_arr = mesh->getMeshPrimitives();

		bool has_normals = mesh->hasNormals();
		COLLADAFW::MeshVertexData& nor = mesh->getNormals();

		for (i = 0; i < prim_arr.getCount(); i++) {
			
 			COLLADAFW::MeshPrimitive *mp = prim_arr[i];

			// faces
			size_t prim_totface = mp->getFaceCount();
			unsigned int *indices = mp->getPositionIndices().getData();
			unsigned int *nind = mp->getNormalIndices().getData();
			unsigned int j, k;
			int type = mp->getPrimitiveType();
			int index = 0;
			
			// since we cannot set mface->mat_nr here, we store a portion of me->mface in Primitive
			Primitive prim = {mface, 0};
			COLLADAFW::IndexListArray& index_list_array = mp->getUVCoordIndicesArray();

#ifdef COLLADA_DEBUG
			/*
			fprintf(stderr, "Primitive %d:\n", i);
			for (int j = 0; j < totuvset; j++) {
				print_index_list(*index_list_array[j]);
			}
			*/
#endif
			
			if (type == COLLADAFW::MeshPrimitive::TRIANGLES) {
				for (j = 0; j < prim_totface; j++){
					
					set_face_indices(mface, indices, false);
					indices += 3;

					for (k = 0; k < totuvset; k++) {
						// get mtface by face index and uv set index
						MTFace *mtface = (MTFace*)CustomData_get_layer_n(&me->fdata, CD_MTFACE, k);
						set_face_uv(&mtface[face_index], uvs, k, *index_list_array[k], index, false);
					}

					test_index_face(mface, &me->fdata, face_index, 3);

					if (has_normals) {
						if (!flat_face(nind, nor, 3))
							mface->flag |= ME_SMOOTH;

						nind += 3;
					}
					
					index += 3;
					mface++;
					face_index++;
					prim.totface++;
				}
			}
			else if (type == COLLADAFW::MeshPrimitive::POLYLIST || type == COLLADAFW::MeshPrimitive::POLYGONS) {
				COLLADAFW::Polygons *mpvc =	(COLLADAFW::Polygons*)mp;
				COLLADAFW::Polygons::VertexCountArray& vcounta = mpvc->getGroupedVerticesVertexCountArray();
				
				for (j = 0; j < prim_totface; j++) {
					
					// face
					int vcount = vcounta[j];
					if (vcount == 3 || vcount == 4) {
						
						set_face_indices(mface, indices, vcount == 4);
						
						// set mtface for each uv set
						// it is assumed that all primitives have equal number of UV sets
						
						for (k = 0; k < totuvset; k++) {
							// get mtface by face index and uv set index
							MTFace *mtface = (MTFace*)CustomData_get_layer_n(&me->fdata, CD_MTFACE, k);
							set_face_uv(&mtface[face_index], uvs, k, *index_list_array[k], index, mface->v4 != 0);
						}

						test_index_face(mface, &me->fdata, face_index, vcount);

						if (has_normals) {
							if (!flat_face(nind, nor, vcount))
								mface->flag |= ME_SMOOTH;

							nind += vcount;
						}
						
						mface++;
						face_index++;
						prim.totface++;
						
					}
					else {
						std::vector<unsigned int> tri;
						
						triangulate_poly(indices, vcount, me->mvert, tri);
						
						for (k = 0; k < tri.size() / 3; k++) {
							int v = k * 3;
							unsigned int uv_indices[3] = {
								index + tri[v],
								index + tri[v + 1],
								index + tri[v + 2]
							};
							unsigned int tri_indices[3] = {
								indices[tri[v]],
								indices[tri[v + 1]],
								indices[tri[v + 2]]
							};

							set_face_indices(mface, tri_indices, false);
							
							for (unsigned int l = 0; l < totuvset; l++) {
								// get mtface by face index and uv set index
								MTFace *mtface = (MTFace*)CustomData_get_layer_n(&me->fdata, CD_MTFACE, l);
								set_face_uv(&mtface[face_index], uvs, l, *index_list_array[l], uv_indices);
							}

							test_index_face(mface, &me->fdata, face_index, 3);

							if (has_normals) {
								unsigned int ntri[3] = {nind[tri[v]], nind[tri[v + 1]], nind[tri[v + 2]]};

								if (!flat_face(ntri, nor, 3))
									mface->flag |= ME_SMOOTH;
							}
							
							mface++;
							face_index++;
							prim.totface++;
						}

						if (has_normals)
							nind += vcount;
					}

					index += vcount;
					indices += vcount;
				}
			}
			
		   	mat_prim_map[mp->getMaterialId()].push_back(prim);
		}

		geom_uid_mat_mapping_map[mesh->getUniqueId()] = mat_prim_map;
	}

	void get_vector(float v[3], COLLADAFW::MeshVertexData& arr, int i)
	{
		i *= 3;

		switch(arr.getType()) {
		case COLLADAFW::MeshVertexData::DATA_TYPE_FLOAT:
			{
				COLLADAFW::ArrayPrimitiveType<float>* values = arr.getFloatValues();
				if (values->empty()) return;

				v[0] = (*values)[i++];
				v[1] = (*values)[i++];
				v[2] = (*values)[i];
			}
			break;
		case COLLADAFW::MeshVertexData::DATA_TYPE_DOUBLE:
			{
				COLLADAFW::ArrayPrimitiveType<double>* values = arr.getDoubleValues();
				if (values->empty()) return;

				v[0] = (float)(*values)[i++];
				v[1] = (float)(*values)[i++];
				v[2] = (float)(*values)[i];
			}
			break;
		default:
			break;
		}
	}

	bool flat_face(unsigned int *nind, COLLADAFW::MeshVertexData& nor, int count)
	{
		float a[3], b[3];

		get_vector(a, nor, *nind);
		normalize_v3(a);

		nind++;

		for (int i = 1; i < count; i++, nind++) {
			get_vector(b, nor, *nind);
			normalize_v3(b);

			float dp = dot_v3v3(a, b);

			if (dp < 0.99999f || dp > 1.00001f)
				return false;
		}

		return true;
	}

public:

	MeshImporter(ArmatureImporter *arm, Scene *sce) : scene(sce), armature_importer(arm) {}

	virtual Object *get_object_by_geom_uid(const COLLADAFW::UniqueId& geom_uid)
	{
		if (uid_object_map.find(geom_uid) != uid_object_map.end())
			return uid_object_map[geom_uid];
		return NULL;
	}
	
	MTex *assign_textures_to_uvlayer(COLLADAFW::TextureCoordinateBinding &ctexture,
									 Mesh *me, TexIndexTextureArrayMap& texindex_texarray_map,
									 MTex *color_texture)
	{
		COLLADAFW::TextureMapId texture_index = ctexture.getTextureMapId();
		char *uvname = CustomData_get_layer_name(&me->fdata, CD_MTFACE, ctexture.getSetIndex());

		if (texindex_texarray_map.find(texture_index) == texindex_texarray_map.end()) {
			
			fprintf(stderr, "Cannot find texture array by texture index.\n");
			return color_texture;
		}
		
		std::vector<MTex*> textures = texindex_texarray_map[texture_index];
		
		std::vector<MTex*>::iterator it;
		
		for (it = textures.begin(); it != textures.end(); it++) {
			
			MTex *texture = *it;
			
			if (texture) {
				strcpy(texture->uvname, uvname);
				if (texture->mapto == MAP_COL) color_texture = texture;
			}
		}
		return color_texture;
	}
	
	MTFace *assign_material_to_geom(COLLADAFW::MaterialBinding cmaterial,
									std::map<COLLADAFW::UniqueId, Material*>& uid_material_map,
									Object *ob, const COLLADAFW::UniqueId *geom_uid, 
									MTex **color_texture, char *layername, MTFace *texture_face,
									std::map<Material*, TexIndexTextureArrayMap>& material_texture_mapping_map, int mat_index)
	{
		Mesh *me = (Mesh*)ob->data;
		const COLLADAFW::UniqueId& ma_uid = cmaterial.getReferencedMaterial();
		
		// do we know this material?
		if (uid_material_map.find(ma_uid) == uid_material_map.end()) {
			
			fprintf(stderr, "Cannot find material by UID.\n");
			return NULL;
		}
		
		Material *ma = uid_material_map[ma_uid];
		assign_material(ob, ma, ob->totcol + 1);
		
		COLLADAFW::TextureCoordinateBindingArray& tex_array = 
			cmaterial.getTextureCoordinateBindingArray();
		TexIndexTextureArrayMap texindex_texarray_map = material_texture_mapping_map[ma];
		unsigned int i;
		// loop through <bind_vertex_inputs>
		for (i = 0; i < tex_array.getCount(); i++) {
			
			*color_texture = assign_textures_to_uvlayer(tex_array[i], me, texindex_texarray_map,
														*color_texture);
		}
		
		// set texture face
		if (*color_texture &&
			strlen((*color_texture)->uvname) &&
			strcmp(layername, (*color_texture)->uvname) != 0) {
			
			texture_face = (MTFace*)CustomData_get_layer_named(&me->fdata, CD_MTFACE,
															   (*color_texture)->uvname);
			strcpy(layername, (*color_texture)->uvname);
		}
		
		MaterialIdPrimitiveArrayMap& mat_prim_map = geom_uid_mat_mapping_map[*geom_uid];
		COLLADAFW::MaterialId mat_id = cmaterial.getMaterialId();
		
		// assign material indices to mesh faces
		if (mat_prim_map.find(mat_id) != mat_prim_map.end()) {
			
			std::vector<Primitive>& prims = mat_prim_map[mat_id];
			
			std::vector<Primitive>::iterator it;
			
			for (it = prims.begin(); it != prims.end(); it++) {
				Primitive& prim = *it;
				i = 0;
				while (i++ < prim.totface) {
					prim.mface->mat_nr = mat_index;
					prim.mface++;
					// bind texture images to faces
					if (texture_face && (*color_texture)) {
						texture_face->mode = TF_TEX;
						texture_face->tpage = (Image*)(*color_texture)->tex->ima;
						texture_face++;
					}
				}
			}
		}
		
		return texture_face;
	}
	
	
	Object *create_mesh_object(COLLADAFW::Node *node, COLLADAFW::InstanceGeometry *geom,
							   bool isController,
							   std::map<COLLADAFW::UniqueId, Material*>& uid_material_map,
							   std::map<Material*, TexIndexTextureArrayMap>& material_texture_mapping_map)
	{
		const COLLADAFW::UniqueId *geom_uid = &geom->getInstanciatedObjectId();
		
		// check if node instanciates controller or geometry
		if (isController) {
			
			geom_uid = armature_importer->get_geometry_uid(*geom_uid);
			
			if (!geom_uid) {
				fprintf(stderr, "Couldn't find a mesh UID by controller's UID.\n");
				return NULL;
			}
		}
		else {
			
			if (uid_mesh_map.find(*geom_uid) == uid_mesh_map.end()) {
				// this could happen if a mesh was not created
				// (e.g. if it contains unsupported geometry)
				fprintf(stderr, "Couldn't find a mesh by UID.\n");
				return NULL;
			}
		}
		if (!uid_mesh_map[*geom_uid]) return NULL;
		
		Object *ob = add_object(scene, OB_MESH);

		// store object pointer for ArmatureImporter
		uid_object_map[*geom_uid] = ob;
		
		// name Object
		const std::string& id = node->getOriginalId();
		if (id.length())
			rename_id(&ob->id, (char*)id.c_str());
		
		// replace ob->data freeing the old one
		Mesh *old_mesh = (Mesh*)ob->data;

		set_mesh(ob, uid_mesh_map[*geom_uid]);
		
		if (old_mesh->id.us == 0) free_libblock(&G.main->mesh, old_mesh);
		
		char layername[100];
		MTFace *texture_face = NULL;
		MTex *color_texture = NULL;
		
		COLLADAFW::MaterialBindingArray& mat_array =
			geom->getMaterialBindings();
		
		// loop through geom's materials
		for (unsigned int i = 0; i < mat_array.getCount(); i++)	{
			
			texture_face = assign_material_to_geom(mat_array[i], uid_material_map, ob, geom_uid,
												   &color_texture, layername, texture_face,
												   material_texture_mapping_map, i);
		}
			
		return ob;
	}

	// create a mesh storing a pointer in a map so it can be retrieved later by geometry UID
	bool write_geometry(const COLLADAFW::Geometry* geom) 
	{
		// TODO: import also uvs, normals
		// XXX what to do with normal indices?
		// XXX num_normals may be != num verts, then what to do?

		// check geometry->getType() first
		if (geom->getType() != COLLADAFW::Geometry::GEO_TYPE_MESH) {
			// TODO: report warning
			fprintf(stderr, "Mesh type %s is not supported\n", geomTypeToStr(geom->getType()));
			return true;
		}
		
		COLLADAFW::Mesh *mesh = (COLLADAFW::Mesh*)geom;
		
		if (!is_nice_mesh(mesh)) {
			fprintf(stderr, "Ignoring mesh %s\n", get_dae_name(mesh));
			return true;
		}
		
		const std::string& str_geom_id = mesh->getOriginalId();
		Mesh *me = add_mesh((char*)str_geom_id.c_str());

		// store the Mesh pointer to link it later with an Object
		this->uid_mesh_map[mesh->getUniqueId()] = me;
		
		int new_tris = 0;
		
		read_vertices(mesh, me);

		new_tris = count_new_tris(mesh, me);
		
		read_faces(mesh, me, new_tris);

		make_edges(me, 0);
		
 		mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);

		return true;
	}

};

class AnimationImporter : private TransformReader, public AnimationImporterBase
{
private:

	ArmatureImporter *armature_importer;
	Scene *scene;

	std::map<COLLADAFW::UniqueId, std::vector<FCurve*> > curve_map;
	std::map<COLLADAFW::UniqueId, TransformReader::Animation> uid_animated_map;
	// std::map<bActionGroup*, std::vector<FCurve*> > fcurves_actionGroup_map;
	std::map<COLLADAFW::UniqueId, const COLLADAFW::AnimationList*> animlist_map;
	std::vector<FCurve*> unused_curves;
	std::map<COLLADAFW::UniqueId, Object*> joint_objects;
	
	FCurve *create_fcurve(int array_index, const char *rna_path)
	{
		FCurve *fcu = (FCurve*)MEM_callocN(sizeof(FCurve), "FCurve");
		
		fcu->flag = (FCURVE_VISIBLE|FCURVE_AUTO_HANDLES|FCURVE_SELECTED);
		fcu->rna_path = BLI_strdupn(rna_path, strlen(rna_path));
		fcu->array_index = array_index;
		return fcu;
	}
	
	void create_bezt(FCurve *fcu, float frame, float output)
	{
		BezTriple bez;
		memset(&bez, 0, sizeof(BezTriple));
		bez.vec[1][0] = frame;
		bez.vec[1][1] = output;
		bez.ipo = U.ipo_new; /* use default interpolation mode here... */
		bez.f1 = bez.f2 = bez.f3 = SELECT;
		bez.h1 = bez.h2 = HD_AUTO;
		insert_bezt_fcurve(fcu, &bez, 0);
		calchandles_fcurve(fcu);
	}

	// create one or several fcurves depending on the number of parameters being animated
	void animation_to_fcurves(COLLADAFW::AnimationCurve *curve)
	{
		COLLADAFW::FloatOrDoubleArray& input = curve->getInputValues();
		COLLADAFW::FloatOrDoubleArray& output = curve->getOutputValues();
		// COLLADAFW::FloatOrDoubleArray& intan = curve->getInTangentValues();
		// COLLADAFW::FloatOrDoubleArray& outtan = curve->getOutTangentValues();
		float fps = (float)FPS;
		size_t dim = curve->getOutDimension();
		unsigned int i;

		std::vector<FCurve*>& fcurves = curve_map[curve->getUniqueId()];

		if (dim == 1) {
			FCurve *fcu = (FCurve*)MEM_callocN(sizeof(FCurve), "FCurve");

			fcu->flag = (FCURVE_VISIBLE|FCURVE_AUTO_HANDLES|FCURVE_SELECTED);
			// fcu->rna_path = BLI_strdupn(path, strlen(path));
			fcu->array_index = 0;
			//fcu->totvert = curve->getKeyCount();
			
			// create beztriple for each key
			for (i = 0; i < curve->getKeyCount(); i++) {
				BezTriple bez;
				memset(&bez, 0, sizeof(BezTriple));

				// intangent
				// bez.vec[0][0] = get_float_value(intan, i + i) * fps;
				// bez.vec[0][1] = get_float_value(intan, i + i + 1);

				// input, output
				bez.vec[1][0] = get_float_value(input, i) * fps;
				bez.vec[1][1] = get_float_value(output, i);

				// outtangent
				// bez.vec[2][0] = get_float_value(outtan, i + i) * fps;
				// bez.vec[2][1] = get_float_value(outtan, i + i + 1);
				
				bez.ipo = U.ipo_new; /* use default interpolation mode here... */
				bez.f1 = bez.f2 = bez.f3 = SELECT;
				bez.h1 = bez.h2 = HD_AUTO;
				insert_bezt_fcurve(fcu, &bez, 0);
			}

			calchandles_fcurve(fcu);

			fcurves.push_back(fcu);
		}
		else if(dim == 3) {
			for (i = 0; i < dim; i++ ) {
				FCurve *fcu = (FCurve*)MEM_callocN(sizeof(FCurve), "FCurve");
				
				fcu->flag = (FCURVE_VISIBLE|FCURVE_AUTO_HANDLES|FCURVE_SELECTED);
				// fcu->rna_path = BLI_strdupn(path, strlen(path));
				fcu->array_index = 0;
				//fcu->totvert = curve->getKeyCount();
				
				// create beztriple for each key
				for (unsigned int j = 0; j < curve->getKeyCount(); j++) {
					BezTriple bez;
					memset(&bez, 0, sizeof(BezTriple));

					// intangent
					// bez.vec[0][0] = get_float_value(intan, j * 6 + i + i) * fps;
					// bez.vec[0][1] = get_float_value(intan, j * 6 + i + i + 1);

					// input, output
					bez.vec[1][0] = get_float_value(input, j) * fps; 
					bez.vec[1][1] = get_float_value(output, j * 3 + i);

					// outtangent
					// bez.vec[2][0] = get_float_value(outtan, j * 6 + i + i) * fps;
					// bez.vec[2][1] = get_float_value(outtan, j * 6 + i + i + 1);

					bez.ipo = U.ipo_new; /* use default interpolation mode here... */
					bez.f1 = bez.f2 = bez.f3 = SELECT;
					bez.h1 = bez.h2 = HD_AUTO;
					insert_bezt_fcurve(fcu, &bez, 0);
				}

				calchandles_fcurve(fcu);

				fcurves.push_back(fcu);
			}
		}

		for (std::vector<FCurve*>::iterator it = fcurves.begin(); it != fcurves.end(); it++)
			unused_curves.push_back(*it);
	}

	void fcurve_deg_to_rad(FCurve *cu)
	{
		for (unsigned int i = 0; i < cu->totvert; i++) {
			// TODO convert handles too
			cu->bezt[i].vec[1][1] *= M_PI / 180.0f;
		}
	}

	void add_fcurves_to_object(Object *ob, std::vector<FCurve*>& curves, char *rna_path, int array_index, Animation *animated)
	{
		bAction *act;
		
		if (!ob->adt || !ob->adt->action) act = verify_adt_action((ID*)&ob->id, 1);
		else act = ob->adt->action;
		
		std::vector<FCurve*>::iterator it;
		int i;

#if 0
		char *p = strstr(rna_path, "rotation_euler");
		bool is_rotation = p && *(p + strlen("rotation_euler")) == '\0';

		// convert degrees to radians for rotation
		if (is_rotation)
			fcurve_deg_to_rad(fcu);
#endif
		
		for (it = curves.begin(), i = 0; it != curves.end(); it++, i++) {
			FCurve *fcu = *it;
			fcu->rna_path = BLI_strdupn(rna_path, strlen(rna_path));
			
			if (array_index == -1) fcu->array_index = i;
			else fcu->array_index = array_index;
		
			if (ob->type == OB_ARMATURE) {
				bActionGroup *grp = NULL;
				const char *bone_name = get_joint_name(animated->node);
				
				if (bone_name) {
					/* try to find group */
					grp = action_groups_find_named(act, bone_name);
					
					/* no matching groups, so add one */
					if (grp == NULL) {
						/* Add a new group, and make it active */
						grp = (bActionGroup*)MEM_callocN(sizeof(bActionGroup), "bActionGroup");
						
						grp->flag = AGRP_SELECTED;
						BLI_strncpy(grp->name, bone_name, sizeof(grp->name));
						
						BLI_addtail(&act->groups, grp);
						BLI_uniquename(&act->groups, grp, "Group", '.', offsetof(bActionGroup, name), 64);
					}
					
					/* add F-Curve to group */
					action_groups_add_channel(act, grp, fcu);
					
				}
#if 0
				if (is_rotation) {
					fcurves_actionGroup_map[grp].push_back(fcu);
				}
#endif
			}
			else {
				BLI_addtail(&act->curves, fcu);
			}

			// curve is used, so remove it from unused_curves
			unused_curves.erase(std::remove(unused_curves.begin(), unused_curves.end(), fcu), unused_curves.end());
		}
	}
public:

	AnimationImporter(UnitConverter *conv, ArmatureImporter *arm, Scene *scene) :
		TransformReader(conv), armature_importer(arm), scene(scene) { }

	~AnimationImporter()
	{
		// free unused FCurves
		for (std::vector<FCurve*>::iterator it = unused_curves.begin(); it != unused_curves.end(); it++)
			free_fcurve(*it);

		if (unused_curves.size())
			fprintf(stderr, "removed %u unused curves\n", unused_curves.size());
	}

	bool write_animation(const COLLADAFW::Animation* anim) 
	{
		if (anim->getAnimationType() == COLLADAFW::Animation::ANIMATION_CURVE) {
			COLLADAFW::AnimationCurve *curve = (COLLADAFW::AnimationCurve*)anim;
			
			// XXX Don't know if it's necessary
			// Should we check outPhysicalDimension?
			if (curve->getInPhysicalDimension() != COLLADAFW::PHYSICAL_DIMENSION_TIME) {
				fprintf(stderr, "Inputs physical dimension is not time. \n");
				return true;
			}

			// a curve can have mixed interpolation type,
			// in this case curve->getInterpolationTypes returns a list of interpolation types per key
			COLLADAFW::AnimationCurve::InterpolationType interp = curve->getInterpolationType();

			if (interp != COLLADAFW::AnimationCurve::INTERPOLATION_MIXED) {
				switch (interp) {
				case COLLADAFW::AnimationCurve::INTERPOLATION_LINEAR:
				case COLLADAFW::AnimationCurve::INTERPOLATION_BEZIER:
					animation_to_fcurves(curve);
					break;
				default:
					// TODO there're also CARDINAL, HERMITE, BSPLINE and STEP types
					fprintf(stderr, "CARDINAL, HERMITE, BSPLINE and STEP anim interpolation types not supported yet.\n");
					break;
				}
			}
			else {
				// not supported yet
				fprintf(stderr, "MIXED anim interpolation type is not supported yet.\n");
			}
		}
		else {
			fprintf(stderr, "FORMULA animation type is not supported yet.\n");
		}
		
		return true;
	}
	
	// called on post-process stage after writeVisualScenes
	bool write_animation_list(const COLLADAFW::AnimationList* animlist) 
	{
		const COLLADAFW::UniqueId& animlist_id = animlist->getUniqueId();

		animlist_map[animlist_id] = animlist;

#if 0
		// should not happen
		if (uid_animated_map.find(animlist_id) == uid_animated_map.end()) {
			return true;
		}

		// for bones rna_path is like: pose.bones["bone-name"].rotation
		
		// what does this AnimationList animate?
		Animation& animated = uid_animated_map[animlist_id];
		Object *ob = animated.ob;

		char rna_path[100];
		char joint_path[100];
		bool is_joint = false;

		// if ob is NULL, it should be a JOINT
		if (!ob) {
			ob = armature_importer->get_armature_for_joint(animated.node);

			if (!ob) {
				fprintf(stderr, "Cannot find armature for node %s\n", get_joint_name(animated.node));
				return true;
			}

			armature_importer->get_rna_path_for_joint(animated.node, joint_path, sizeof(joint_path));

			is_joint = true;
		}
		
		const COLLADAFW::AnimationList::AnimationBindings& bindings = animlist->getAnimationBindings();

		switch (animated.tm->getTransformationType()) {
		case COLLADAFW::Transformation::TRANSLATE:
		case COLLADAFW::Transformation::SCALE:
			{
				bool loc = animated.tm->getTransformationType() == COLLADAFW::Transformation::TRANSLATE;
				if (is_joint)
					BLI_snprintf(rna_path, sizeof(rna_path), "%s.%s", joint_path, loc ? "location" : "scale");
				else
					BLI_strncpy(rna_path, loc ? "location" : "scale", sizeof(rna_path));

				for (int i = 0; i < bindings.getCount(); i++) {
					const COLLADAFW::AnimationList::AnimationBinding& binding = bindings[i];
					COLLADAFW::UniqueId anim_uid = binding.animation;

					if (curve_map.find(anim_uid) == curve_map.end()) {
						fprintf(stderr, "Cannot find FCurve by animation UID.\n");
						continue;
					}

					std::vector<FCurve*>& fcurves = curve_map[anim_uid];
					
					switch (binding.animationClass) {
					case COLLADAFW::AnimationList::POSITION_X:
						add_fcurves_to_object(ob, fcurves, rna_path, 0, &animated);
						break;
					case COLLADAFW::AnimationList::POSITION_Y:
						add_fcurves_to_object(ob, fcurves, rna_path, 1, &animated);
						break;
					case COLLADAFW::AnimationList::POSITION_Z:
						add_fcurves_to_object(ob, fcurves, rna_path, 2, &animated);
						break;
					case COLLADAFW::AnimationList::POSITION_XYZ:
						add_fcurves_to_object(ob, fcurves, rna_path, -1, &animated);
						break;
					default:
						fprintf(stderr, "AnimationClass %d is not supported for %s.\n",
								binding.animationClass, loc ? "TRANSLATE" : "SCALE");
					}
				}
			}
			break;
		case COLLADAFW::Transformation::ROTATE:
			{
				if (is_joint)
					BLI_snprintf(rna_path, sizeof(rna_path), "%s.rotation_euler", joint_path);
				else
					BLI_strncpy(rna_path, "rotation_euler", sizeof(rna_path));

				COLLADAFW::Rotate* rot = (COLLADAFW::Rotate*)animated.tm;
				COLLADABU::Math::Vector3& axis = rot->getRotationAxis();
				
				for (int i = 0; i < bindings.getCount(); i++) {
					const COLLADAFW::AnimationList::AnimationBinding& binding = bindings[i];
					COLLADAFW::UniqueId anim_uid = binding.animation;

					if (curve_map.find(anim_uid) == curve_map.end()) {
						fprintf(stderr, "Cannot find FCurve by animation UID.\n");
						continue;
					}

					std::vector<FCurve*>& fcurves = curve_map[anim_uid];

					switch (binding.animationClass) {
					case COLLADAFW::AnimationList::ANGLE:
						if (COLLADABU::Math::Vector3::UNIT_X == axis) {
							add_fcurves_to_object(ob, fcurves, rna_path, 0, &animated);
						}
						else if (COLLADABU::Math::Vector3::UNIT_Y == axis) {
							add_fcurves_to_object(ob, fcurves, rna_path, 1, &animated);
						}
						else if (COLLADABU::Math::Vector3::UNIT_Z == axis) {
							add_fcurves_to_object(ob, fcurves, rna_path, 2, &animated);
						}
						break;
					case COLLADAFW::AnimationList::AXISANGLE:
						// TODO convert axis-angle to quat? or XYZ?
					default:
						fprintf(stderr, "AnimationClass %d is not supported for ROTATE transformation.\n",
								binding.animationClass);
					}
				}
			}
			break;
		case COLLADAFW::Transformation::MATRIX:
		case COLLADAFW::Transformation::SKEW:
		case COLLADAFW::Transformation::LOOKAT:
			fprintf(stderr, "Animation of MATRIX, SKEW and LOOKAT transformations is not supported yet.\n");
			break;
		}
#endif
		
		return true;
	}

	void read_node_transform(COLLADAFW::Node *node, Object *ob)
	{
		float mat[4][4];
		TransformReader::get_node_mat(mat, node, &uid_animated_map, ob);
		if (ob)
			TransformReader::decompose(mat, ob->loc, ob->rot, NULL, ob->size);
	}
	
#if 0
	virtual void change_eul_to_quat(Object *ob, bAction *act)
	{
		bActionGroup *grp;
		int i;
		
		for (grp = (bActionGroup*)act->groups.first; grp; grp = grp->next) {

			FCurve *eulcu[3] = {NULL, NULL, NULL};
			
			if (fcurves_actionGroup_map.find(grp) == fcurves_actionGroup_map.end())
				continue;

			std::vector<FCurve*> &rot_fcurves = fcurves_actionGroup_map[grp];
			
			if (rot_fcurves.size() > 3) continue;

			for (i = 0; i < rot_fcurves.size(); i++)
				eulcu[rot_fcurves[i]->array_index] = rot_fcurves[i];

			char joint_path[100];
			char rna_path[100];

			BLI_snprintf(joint_path, sizeof(joint_path), "pose.bones[\"%s\"]", grp->name);
			BLI_snprintf(rna_path, sizeof(rna_path), "%s.rotation_quaternion", joint_path);

			FCurve *quatcu[4] = {
				create_fcurve(0, rna_path),
				create_fcurve(1, rna_path),
				create_fcurve(2, rna_path),
				create_fcurve(3, rna_path)
			};

			bPoseChannel *chan = get_pose_channel(ob->pose, grp->name);

			float m4[4][4], irest[3][3];
			invert_m4_m4(m4, chan->bone->arm_mat);
			copy_m3_m4(irest, m4);

			for (i = 0; i < 3; i++) {

				FCurve *cu = eulcu[i];

				if (!cu) continue;

				for (int j = 0; j < cu->totvert; j++) {
					float frame = cu->bezt[j].vec[1][0];

					float eul[3] = {
						eulcu[0] ? evaluate_fcurve(eulcu[0], frame) : 0.0f,
						eulcu[1] ? evaluate_fcurve(eulcu[1], frame) : 0.0f,
						eulcu[2] ? evaluate_fcurve(eulcu[2], frame) : 0.0f
					};

					// make eul relative to bone rest pose
					float rot[3][3], rel[3][3], quat[4];

					/*eul_to_mat3(rot, eul);

					mul_m3_m3m3(rel, irest, rot);

					mat3_to_quat(quat, rel);
					*/

					eul_to_quat(quat, eul);

					for (int k = 0; k < 4; k++)
						create_bezt(quatcu[k], frame, quat[k]);
				}
			}

			// now replace old Euler curves

			for (i = 0; i < 3; i++) {
				if (!eulcu[i]) continue;

				action_groups_remove_channel(act, eulcu[i]);
				free_fcurve(eulcu[i]);
			}

			chan->rotmode = ROT_MODE_QUAT;

			for (i = 0; i < 4; i++)
				action_groups_add_channel(act, grp, quatcu[i]);
		}

		bPoseChannel *pchan;
		for (pchan = (bPoseChannel*)ob->pose->chanbase.first; pchan; pchan = pchan->next) {
			pchan->rotmode = ROT_MODE_QUAT;
		}
	}
#endif

	// prerequisites:
	// animlist_map - map animlist id -> animlist
	// curve_map - map anim id -> curve(s)
	Object *translate_animation(COLLADAFW::Node *node,
								std::map<COLLADAFW::UniqueId, Object*>& object_map,
								std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& root_map,
								COLLADAFW::Transformation::TransformationType tm_type,
								Object *par_job = NULL)
	{
		bool is_rotation = tm_type == COLLADAFW::Transformation::ROTATE;
		bool is_joint = node->getType() == COLLADAFW::Node::JOINT;
		COLLADAFW::Node *root = root_map.find(node->getUniqueId()) == root_map.end() ? node : root_map[node->getUniqueId()];
		Object *ob = is_joint ? armature_importer->get_armature_for_joint(node) : object_map[node->getUniqueId()];
		const char *bone_name = is_joint ? get_joint_name(node) : NULL;

		if (!ob) {
			fprintf(stderr, "cannot find Object for Node with id=\"%s\"\n", node->getOriginalId().c_str());
			return NULL;
		}

		// frames at which to sample
		std::vector<float> frames;

		// for each <rotate>, <translate>, etc. there is a separate Transformation
		const COLLADAFW::TransformationPointerArray& tms = node->getTransformations();

		unsigned int i;

		// find frames at which to sample plus convert all keys to radians
		for (i = 0; i < tms.getCount(); i++) {
			COLLADAFW::Transformation *tm = tms[i];
			COLLADAFW::Transformation::TransformationType type = tm->getTransformationType();

			if (type == tm_type) {
				const COLLADAFW::UniqueId& listid = tm->getAnimationList();

				if (animlist_map.find(listid) != animlist_map.end()) {
					const COLLADAFW::AnimationList *animlist = animlist_map[listid];
					const COLLADAFW::AnimationList::AnimationBindings& bindings = animlist->getAnimationBindings();

					if (bindings.getCount()) {
						for (unsigned int j = 0; j < bindings.getCount(); j++) {
							std::vector<FCurve*>& curves = curve_map[bindings[j].animation];
							bool xyz = ((type == COLLADAFW::Transformation::TRANSLATE || type == COLLADAFW::Transformation::SCALE) && bindings[j].animationClass == COLLADAFW::AnimationList::POSITION_XYZ);

							if ((!xyz && curves.size() == 1) || (xyz && curves.size() == 3)) {
								std::vector<FCurve*>::iterator iter;

								for (iter = curves.begin(); iter != curves.end(); iter++) {
									FCurve *fcu = *iter;

									if (is_rotation)
										fcurve_deg_to_rad(fcu);

									for (unsigned int k = 0; k < fcu->totvert; k++) {
										float fra = fcu->bezt[k].vec[1][0];
										if (std::find(frames.begin(), frames.end(), fra) == frames.end())
											frames.push_back(fra);
									}
								}
							}
							else {
								fprintf(stderr, "expected %d curves, got %u\n", xyz ? 3 : 1, curves.size());
							}
						}
					}
				}
			}
		}

		sort(frames.begin(), frames.end());

		float irest_dae[4][4];
		float rest[4][4], irest[4][4];

		if (is_joint) {
			get_joint_rest_mat(irest_dae, root, node);
			invert_m4(irest_dae);

			Bone *bone = get_named_bone((bArmature*)ob->data, bone_name);
			if (!bone) {
				fprintf(stderr, "cannot find bone \"%s\"\n", bone_name);
				return NULL;
			}

			unit_m4(rest);
			copy_m4_m4(rest, bone->arm_mat);
			invert_m4_m4(irest, rest);
		}

		char rna_path[200];

		Object *job = NULL;

#ifdef ARMATURE_TEST
		FCurve *job_curves[4];
		job = get_joint_object(root, node, par_job);
#endif

		if (frames.size() == 0)
			return job;

		const char *tm_str = NULL;
		switch (tm_type) {
		case COLLADAFW::Transformation::ROTATE:
			tm_str = "rotation_quaternion";
			break;
		case COLLADAFW::Transformation::SCALE:
			tm_str = "scale";
			break;
		case COLLADAFW::Transformation::TRANSLATE:
			tm_str = "location";
			break;
		default:
			return job;
		}

		if (is_joint) {
			char joint_path[200];
			armature_importer->get_rna_path_for_joint(node, joint_path, sizeof(joint_path));
			BLI_snprintf(rna_path, sizeof(rna_path), "%s.%s", joint_path, tm_str);
		}
		else {
			strcpy(rna_path, tm_str);
		}

		// new curves
		FCurve *newcu[4];
		unsigned int totcu = is_rotation ? 4 : 3;

		for (i = 0; i < totcu; i++) {
			newcu[i] = create_fcurve(i, rna_path);

#ifdef ARMATURE_TEST
			if (is_joint)
				job_curves[i] = create_fcurve(i, tm_str);
#endif
		}

		std::vector<float>::iterator it;

		// sample values at each frame
		for (it = frames.begin(); it != frames.end(); it++) {
			float fra = *it;

			float mat[4][4];
			float matfra[4][4];

			unit_m4(matfra);

			// calc object-space mat
			evaluate_transform_at_frame(matfra, node, fra);

			// for joints, we need a special matrix
			if (is_joint) {
				// special matrix: iR * M * iR_dae * R
				// where R, iR are bone rest and inverse rest mats in world space (Blender bones),
				// iR_dae is joint inverse rest matrix (DAE) and M is an evaluated joint world-space matrix (DAE)
				float temp[4][4], par[4][4];

				// calc M
				calc_joint_parent_mat_rest(par, NULL, root, node);
				mul_m4_m4m4(temp, matfra, par);

				// evaluate_joint_world_transform_at_frame(temp, NULL, , node, fra);

				// calc special matrix
				mul_serie_m4(mat, irest, temp, irest_dae, rest, NULL, NULL, NULL, NULL);
			}
			else {
				copy_m4_m4(mat, matfra);
			}

			float val[4];

			switch (tm_type) {
			case COLLADAFW::Transformation::ROTATE:
				mat4_to_quat(val, mat);
				break;
			case COLLADAFW::Transformation::SCALE:
				mat4_to_size(val, mat);
				break;
			case COLLADAFW::Transformation::TRANSLATE:
				copy_v3_v3(val, mat[3]);
				break;
			default:
				break;
			}

			// add 4 or 3 keys
			for (i = 0; i < totcu; i++) {
				add_bezt(newcu[i], fra, val[i]);
			}

#ifdef ARMATURE_TEST
			if (is_joint) {
				switch (tm_type) {
				case COLLADAFW::Transformation::ROTATE:
					mat4_to_quat(val, matfra);
					break;
				case COLLADAFW::Transformation::SCALE:
					mat4_to_size(val, matfra);
					break;
				case COLLADAFW::Transformation::TRANSLATE:
					copy_v3_v3(val, matfra[3]);
					break;
				default:
					break;
				}

				for (i = 0; i < totcu; i++)
					add_bezt(job_curves[i], fra, val[i]);
			}
#endif
		}

		verify_adt_action((ID*)&ob->id, 1);

		ListBase *curves = &ob->adt->action->curves;

		// add curves
		for (i = 0; i < totcu; i++) {
			if (is_joint)
				add_bone_fcurve(ob, node, newcu[i]);
			else
				BLI_addtail(curves, newcu[i]);

#ifdef ARMATURE_TEST
			if (is_joint)
				BLI_addtail(&job->adt->action->curves, job_curves[i]);
#endif
		}

		if (is_rotation) {
			if (is_joint) {
				bPoseChannel *chan = get_pose_channel(ob->pose, bone_name);
				chan->rotmode = ROT_MODE_QUAT;
			}
			else {
				ob->rotmode = ROT_MODE_QUAT;
			}
		}

		return job;
	}

	// internal, better make it private
	// warning: evaluates only rotation
	// prerequisites: animlist_map, curve_map
	void evaluate_transform_at_frame(float mat[4][4], COLLADAFW::Node *node, float fra)
	{
		const COLLADAFW::TransformationPointerArray& tms = node->getTransformations();

		unit_m4(mat);

		for (unsigned int i = 0; i < tms.getCount(); i++) {
			COLLADAFW::Transformation *tm = tms[i];
			COLLADAFW::Transformation::TransformationType type = tm->getTransformationType();
			float m[4][4];

			unit_m4(m);

			if (!evaluate_animation(tm, m, fra)) {
				switch (type) {
				case COLLADAFW::Transformation::ROTATE:
					dae_rotate_to_mat4(tm, m);
					break;
				case COLLADAFW::Transformation::TRANSLATE:
					dae_translate_to_mat4(tm, m);
					break;
				case COLLADAFW::Transformation::SCALE:
					dae_scale_to_mat4(tm, m);
					break;
				case COLLADAFW::Transformation::MATRIX:
					dae_matrix_to_mat4(tm, m);
					break;
				default:
					fprintf(stderr, "unsupported transformation type %d\n", type);
				}
			}

			float temp[4][4];
			copy_m4_m4(temp, mat);

			mul_m4_m4m4(mat, m, temp);
		}
	}

	// return true to indicate that mat contains a sane value
	bool evaluate_animation(COLLADAFW::Transformation *tm, float mat[4][4], float fra)
	{
		const COLLADAFW::UniqueId& listid = tm->getAnimationList();
		COLLADAFW::Transformation::TransformationType type = tm->getTransformationType();

		if (type != COLLADAFW::Transformation::ROTATE && type != COLLADAFW::Transformation::SCALE &&
		    type != COLLADAFW::Transformation::TRANSLATE) {
			fprintf(stderr, "animation of transformation %d is not supported yet\n", type);
			return false;
		}

		if (animlist_map.find(listid) == animlist_map.end())
			return false;

		const COLLADAFW::AnimationList *animlist = animlist_map[listid];
		const COLLADAFW::AnimationList::AnimationBindings& bindings = animlist->getAnimationBindings();

		if (bindings.getCount()) {
			float vec[3];

			bool is_scale = (type == COLLADAFW::Transformation::SCALE);

			if (type == COLLADAFW::Transformation::SCALE)
				dae_scale_to_v3(tm, vec);
			else if (type == COLLADAFW::Transformation::TRANSLATE)
				dae_translate_to_v3(tm, vec);

			for (unsigned int j = 0; j < bindings.getCount(); j++) {
				const COLLADAFW::AnimationList::AnimationBinding& binding = bindings[j];
				std::vector<FCurve*>& curves = curve_map[binding.animation];
				COLLADAFW::AnimationList::AnimationClass animclass = binding.animationClass;

				if (type == COLLADAFW::Transformation::ROTATE) {
					if (curves.size() != 1) {
						fprintf(stderr, "expected 1 curve, got %u\n", curves.size());
						return false;
					}
					else {
						if (animclass == COLLADAFW::AnimationList::ANGLE) {
							COLLADABU::Math::Vector3& axis = ((COLLADAFW::Rotate*)tm)->getRotationAxis();
							float ax[3] = {axis[0], axis[1], axis[2]};
							float angle = evaluate_fcurve(curves[0], fra);
							axis_angle_to_mat4(mat, ax, angle);

							return true;
						}
						else {
							// TODO support other animclasses
							fprintf(stderr, "<rotate> animclass %d is not supported yet\n", animclass);
							return false;
						}
					}
				}
				else {
					bool is_xyz = animclass == COLLADAFW::AnimationList::POSITION_XYZ;

					if ((!is_xyz && curves.size() == 1) || (is_xyz && curves.size() == 3)) {
						switch (animclass) {
						case COLLADAFW::AnimationList::POSITION_X:
							vec[0] = evaluate_fcurve(curves[0], fra);
							break;
						case COLLADAFW::AnimationList::POSITION_Y:
							vec[1] = evaluate_fcurve(curves[0], fra);
							break;
						case COLLADAFW::AnimationList::POSITION_Z:
							vec[2] = evaluate_fcurve(curves[0], fra);
							break;
						case COLLADAFW::AnimationList::POSITION_XYZ:
							vec[0] = evaluate_fcurve(curves[0], fra);
							vec[1] = evaluate_fcurve(curves[1], fra);
							vec[2] = evaluate_fcurve(curves[2], fra);
							break;
						default:
							fprintf(stderr, "<%s> animclass %d is not supported yet\n", is_scale ? "scale" : "translate", animclass);
							break;
						}
					}
					else {
						if (is_xyz)
							fprintf(stderr, "expected 3 curves, got %u, animclass=%d\n", curves.size(), animclass);
						else
							fprintf(stderr, "expected 1 curve, got %u, animclass=%d\n", curves.size(), animclass);
						return false;
					}
				}
			}

			if (is_scale)
				size_to_mat4(mat, vec);
			else
				copy_v3_v3(mat[3], vec);

			return true;
		}

		return false;
	}

	// gives a world-space mat of joint at rest position
	void get_joint_rest_mat(float mat[4][4], COLLADAFW::Node *root, COLLADAFW::Node *node)
	{
		// if bind mat is not available,
		// use "current" node transform, i.e. all those tms listed inside <node>
		if (!armature_importer->get_joint_bind_mat(mat, node)) {
			float par[4][4], m[4][4];

			calc_joint_parent_mat_rest(par, NULL, root, node);
			get_node_mat(m, node, NULL, NULL);
			mul_m4_m4m4(mat, m, par);
		}
	}

	// gives a world-space mat, end's mat not included
	bool calc_joint_parent_mat_rest(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end)
	{
		float m[4][4];

		if (node == end) {
			par ? copy_m4_m4(mat, par) : unit_m4(mat);
			return true;
		}

		// use bind matrix if available or calc "current" world mat
		if (!armature_importer->get_joint_bind_mat(m, node)) {
			if (par) {
				float temp[4][4];
				get_node_mat(temp, node, NULL, NULL);
				mul_m4_m4m4(m, temp, par);
			}
			else {
				get_node_mat(m, node, NULL, NULL);
			}
		}

		COLLADAFW::NodePointerArray& children = node->getChildNodes();
		for (unsigned int i = 0; i < children.getCount(); i++) {
			if (calc_joint_parent_mat_rest(mat, m, children[i], end))
				return true;
		}

		return false;
	}

#ifdef ARMATURE_TEST
	Object *get_joint_object(COLLADAFW::Node *root, COLLADAFW::Node *node, Object *par_job)
	{
		if (joint_objects.find(node->getUniqueId()) == joint_objects.end()) {
			Object *job = add_object(scene, OB_EMPTY);

			rename_id((ID*)&job->id, (char*)get_joint_name(node));

			job->lay = object_in_scene(job, scene)->lay = 2;

			mul_v3_fl(job->size, 0.5f);
			job->recalc |= OB_RECALC_OB;

			verify_adt_action((ID*)&job->id, 1);

			job->rotmode = ROT_MODE_QUAT;

			float mat[4][4];
			get_joint_rest_mat(mat, root, node);

			if (par_job) {
				float temp[4][4], ipar[4][4];
				invert_m4_m4(ipar, par_job->obmat);
				copy_m4_m4(temp, mat);
				mul_m4_m4m4(mat, temp, ipar);
			}

			TransformBase::decompose(mat, job->loc, NULL, job->quat, job->size);

			if (par_job) {
				job->parent = par_job;

				par_job->recalc |= OB_RECALC_OB;
				job->parsubstr[0] = 0;
			}

			where_is_object(scene, job);

			// after parenting and layer change
			DAG_scene_sort(scene);

			joint_objects[node->getUniqueId()] = job;
		}

		return joint_objects[node->getUniqueId()];
	}
#endif

#if 0
	// recursively evaluates joint tree until end is found, mat then is world-space matrix of end
	// mat must be identity on enter, node must be root
	bool evaluate_joint_world_transform_at_frame(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra)
	{
		float m[4][4];
		if (par) {
			float temp[4][4];
			evaluate_transform_at_frame(temp, node, node == end ? fra : 0.0f);
			mul_m4_m4m4(m, temp, par);
		}
		else {
			evaluate_transform_at_frame(m, node, node == end ? fra : 0.0f);
		}

		if (node == end) {
			copy_m4_m4(mat, m);
			return true;
		}
		else {
			COLLADAFW::NodePointerArray& children = node->getChildNodes();
			for (int i = 0; i < children.getCount(); i++) {
				if (evaluate_joint_world_transform_at_frame(mat, m, children[i], end, fra))
					return true;
			}
		}

		return false;
	}
#endif

	void add_bone_fcurve(Object *ob, COLLADAFW::Node *node, FCurve *fcu)
	{
		const char *bone_name = get_joint_name(node);
		bAction *act = ob->adt->action;
				
		/* try to find group */
		bActionGroup *grp = action_groups_find_named(act, bone_name);

		/* no matching groups, so add one */
		if (grp == NULL) {
			/* Add a new group, and make it active */
			grp = (bActionGroup*)MEM_callocN(sizeof(bActionGroup), "bActionGroup");
						
			grp->flag = AGRP_SELECTED;
			BLI_strncpy(grp->name, bone_name, sizeof(grp->name));
						
			BLI_addtail(&act->groups, grp);
			BLI_uniquename(&act->groups, grp, "Group", '.', offsetof(bActionGroup, name), 64);
		}
					
		/* add F-Curve to group */
		action_groups_add_channel(act, grp, fcu);
	}

	void add_bezt(FCurve *fcu, float fra, float value)
	{
		BezTriple bez;
		memset(&bez, 0, sizeof(BezTriple));
		bez.vec[1][0] = fra;
		bez.vec[1][1] = value;
		bez.ipo = U.ipo_new; /* use default interpolation mode here... */
		bez.f1 = bez.f2 = bez.f3 = SELECT;
		bez.h1 = bez.h2 = HD_AUTO;
		insert_bezt_fcurve(fcu, &bez, 0);
		calchandles_fcurve(fcu);
	}
};

/*

  COLLADA Importer limitations:

  - no multiple scene import, all objects are added to active scene

 */
/** Class that needs to be implemented by a writer. 
	IMPORTANT: The write functions are called in arbitrary order.*/
class Writer: public COLLADAFW::IWriter
{
private:
	std::string mFilename;
	
	bContext *mContext;

	UnitConverter unit_converter;
	ArmatureImporter armature_importer;
	MeshImporter mesh_importer;
	AnimationImporter anim_importer;

	std::map<COLLADAFW::UniqueId, Image*> uid_image_map;
	std::map<COLLADAFW::UniqueId, Material*> uid_material_map;
	std::map<COLLADAFW::UniqueId, Material*> uid_effect_map;
	std::map<COLLADAFW::UniqueId, Camera*> uid_camera_map;
	std::map<COLLADAFW::UniqueId, Lamp*> uid_lamp_map;
	std::map<Material*, TexIndexTextureArrayMap> material_texture_mapping_map;
	std::map<COLLADAFW::UniqueId, Object*> object_map;
	std::vector<const COLLADAFW::VisualScene*> vscenes;

	std::map<COLLADAFW::UniqueId, COLLADAFW::Node*> root_map; // find root joint by child joint uid, for bone tree evaluation during resampling

	// animation
	// std::map<COLLADAFW::UniqueId, std::vector<FCurve*> > uid_fcurve_map;
	// Nodes don't share AnimationLists (Arystan)
	// std::map<COLLADAFW::UniqueId, Animation> uid_animated_map; // AnimationList->uniqueId to AnimatedObject map

public:

	/** Constructor. */
	Writer(bContext *C, const char *filename) : mFilename(filename), mContext(C),
												armature_importer(&unit_converter, &mesh_importer, &anim_importer, CTX_data_scene(C)),
												mesh_importer(&armature_importer, CTX_data_scene(C)),
												anim_importer(&unit_converter, &armature_importer, CTX_data_scene(C)) {}

	/** Destructor. */
	~Writer() {}

	bool write()
	{
		COLLADASaxFWL::Loader loader;
		COLLADAFW::Root root(&loader, this);

		// XXX report error
		if (!root.loadDocument(mFilename))
			return false;

		return true;
	}

	/** This method will be called if an error in the loading process occurred and the loader cannot
		continue to to load. The writer should undo all operations that have been performed.
		@param errorMessage A message containing informations about the error that occurred.
	*/
	virtual void cancel(const COLLADAFW::String& errorMessage)
	{
		// TODO: if possible show error info
		//
		// Should we get rid of invisible Meshes that were created so far
		// or maybe create objects at coordinate space origin?
		//
		// The latter sounds better.
	}

	/** This is the method called. The writer hast to prepare to receive data.*/
	virtual void start()
	{
	}

	/** This method is called after the last write* method. No other methods will be called after this.*/
	virtual void finish()
	{
#if 0
		armature_importer.fix_animation();
#endif

		for (std::vector<const COLLADAFW::VisualScene*>::iterator it = vscenes.begin(); it != vscenes.end(); it++) {
			const COLLADAFW::NodePointerArray& roots = (*it)->getRootNodes();

			for (unsigned int i = 0; i < roots.getCount(); i++)
				translate_anim_recursive(roots[i]);
		}

	}


	void translate_anim_recursive(COLLADAFW::Node *node, COLLADAFW::Node *par = NULL, Object *parob = NULL)
	{
		if (par && par->getType() == COLLADAFW::Node::JOINT) {
			// par is root if there's no corresp. key in root_map
			if (root_map.find(par->getUniqueId()) == root_map.end())
				root_map[node->getUniqueId()] = par;
			else
				root_map[node->getUniqueId()] = root_map[par->getUniqueId()];
		}

		COLLADAFW::Transformation::TransformationType types[] = {
			COLLADAFW::Transformation::ROTATE,
			COLLADAFW::Transformation::SCALE,
			COLLADAFW::Transformation::TRANSLATE
		};

		unsigned int i;
		Object *ob;

		for (i = 0; i < 3; i++)
			ob = anim_importer.translate_animation(node, object_map, root_map, types[i]);

		COLLADAFW::NodePointerArray &children = node->getChildNodes();
		for (i = 0; i < children.getCount(); i++) {
			translate_anim_recursive(children[i], node, ob);
		}
	}

	/** When this method is called, the writer must write the global document asset.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeGlobalAsset ( const COLLADAFW::FileInfo* asset ) 
	{
		// XXX take up_axis, unit into account
		// COLLADAFW::FileInfo::Unit unit = asset->getUnit();
		// COLLADAFW::FileInfo::UpAxisType upAxis = asset->getUpAxisType();
		unit_converter.read_asset(asset);

		return true;
	}

	/** When this method is called, the writer must write the scene.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeScene ( const COLLADAFW::Scene* scene ) 
	{
		// XXX could store the scene id, but do nothing for now
		return true;
	}
	Object *create_camera_object(COLLADAFW::InstanceCamera *camera, Object *ob, Scene *sce)
	{
		const COLLADAFW::UniqueId& cam_uid = camera->getInstanciatedObjectId();
		if (uid_camera_map.find(cam_uid) == uid_camera_map.end()) {	
			fprintf(stderr, "Couldn't find camera by UID. \n");
			return NULL;
		}
		ob = add_object(sce, OB_CAMERA);
		Camera *cam = uid_camera_map[cam_uid];
		Camera *old_cam = (Camera*)ob->data;
		old_cam->id.us--;
		ob->data = cam;
		if (old_cam->id.us == 0) free_libblock(&G.main->camera, old_cam);
		return ob;
	}
	
	Object *create_lamp_object(COLLADAFW::InstanceLight *lamp, Object *ob, Scene *sce)
	{
		const COLLADAFW::UniqueId& lamp_uid = lamp->getInstanciatedObjectId();
		if (uid_lamp_map.find(lamp_uid) == uid_lamp_map.end()) {	
			fprintf(stderr, "Couldn't find lamp by UID. \n");
			return NULL;
		}
		ob = add_object(sce, OB_LAMP);
		Lamp *la = uid_lamp_map[lamp_uid];
		Lamp *old_lamp = (Lamp*)ob->data;
		old_lamp->id.us--;
		ob->data = la;
		if (old_lamp->id.us == 0) free_libblock(&G.main->lamp, old_lamp);
		return ob;
	}
	
	void write_node (COLLADAFW::Node *node, COLLADAFW::Node *parent_node, Scene *sce, Object *par)
	{
		Object *ob = NULL;

		if (node->getType() == COLLADAFW::Node::JOINT) {

			if (node->getType() == COLLADAFW::Node::JOINT) {
				armature_importer.add_joint(node, parent_node == NULL || parent_node->getType() != COLLADAFW::Node::JOINT);
			}

		}
		else {
			COLLADAFW::InstanceGeometryPointerArray &geom = node->getInstanceGeometries();
			COLLADAFW::InstanceCameraPointerArray &camera = node->getInstanceCameras();
			COLLADAFW::InstanceLightPointerArray &lamp = node->getInstanceLights();
			COLLADAFW::InstanceControllerPointerArray &controller = node->getInstanceControllers();
			COLLADAFW::InstanceNodePointerArray &inst_node = node->getInstanceNodes();

			// XXX linking object with the first <instance_geometry>, though a node may have more of them...
			// maybe join multiple <instance_...> meshes into 1, and link object with it? not sure...
			// <instance_geometry>
			if (geom.getCount() != 0) {
				ob = mesh_importer.create_mesh_object(node, geom[0], false, uid_material_map,
													  material_texture_mapping_map);
			}
			else if (camera.getCount() != 0) {
				ob = create_camera_object(camera[0], ob, sce);
			}
			else if (lamp.getCount() != 0) {
				ob = create_lamp_object(lamp[0], ob, sce);
			}
			else if (controller.getCount() != 0) {
				COLLADAFW::InstanceGeometry *geom = (COLLADAFW::InstanceGeometry*)controller[0];
				ob = mesh_importer.create_mesh_object(node, geom, true, uid_material_map, material_texture_mapping_map);
			}
			// XXX instance_node is not supported yet
			else if (inst_node.getCount() != 0) {
				return;
			}
			// if node is empty - create empty object
			// XXX empty node may not mean it is empty object, not sure about this
			else {
				ob = add_object(sce, OB_EMPTY);
			}
			
			// check if object is not NULL
			if (!ob) return;

			object_map[node->getUniqueId()] = ob;
			
			// if par was given make this object child of the previous 
			if (par && ob) {
				ob->parent = par;

				// doing what 'set parent' operator does
				par->recalc |= OB_RECALC_OB;
				ob->parsubstr[0] = 0;
			
				DAG_scene_sort(sce);
			}
		}

		anim_importer.read_node_transform(node, ob);

		// if node has child nodes write them
		COLLADAFW::NodePointerArray &child_nodes = node->getChildNodes();
		for (unsigned int i = 0; i < child_nodes.getCount(); i++) {	
			write_node(child_nodes[i], node, sce, ob);
		}
	}

	/** When this method is called, the writer must write the entire visual scene.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeVisualScene ( const COLLADAFW::VisualScene* visualScene ) 
	{
		// this method called on post process after writeGeometry, writeMaterial, etc.

		// for each <node> in <visual_scene>:
		// create an Object
		// if Mesh (previously created in writeGeometry) to which <node> corresponds exists, link Object with that mesh

		// update: since we cannot link a Mesh with Object in
		// writeGeometry because <geometry> does not reference <node>,
		// we link Objects with Meshes here

		vscenes.push_back(visualScene);

		// TODO: create a new scene except the selected <visual_scene> - use current blender
		// scene for it
		Scene *sce = CTX_data_scene(mContext);
		const COLLADAFW::NodePointerArray& roots = visualScene->getRootNodes();

		for (unsigned int i = 0; i < roots.getCount(); i++) {
			write_node(roots[i], NULL, sce, NULL);
		}

		armature_importer.make_armatures(mContext);
		
		return true;
	}

	/** When this method is called, the writer must handle all nodes contained in the 
		library nodes.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeLibraryNodes ( const COLLADAFW::LibraryNodes* libraryNodes ) 
	{
		return true;
	}

	/** When this method is called, the writer must write the geometry.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeGeometry ( const COLLADAFW::Geometry* geom ) 
	{
		return mesh_importer.write_geometry(geom);
	}

	/** When this method is called, the writer must write the material.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeMaterial( const COLLADAFW::Material* cmat ) 
	{
		const std::string& str_mat_id = cmat->getOriginalId();
		Material *ma = add_material((char*)str_mat_id.c_str());
		
		this->uid_effect_map[cmat->getInstantiatedEffect()] = ma;
		this->uid_material_map[cmat->getUniqueId()] = ma;
		
		return true;
	}
	
	// create mtex, create texture, set texture image
	MTex *create_texture(COLLADAFW::EffectCommon *ef, COLLADAFW::Texture &ctex, Material *ma,
						 int i, TexIndexTextureArrayMap &texindex_texarray_map)
	{
		COLLADAFW::SamplerPointerArray& samp_array = ef->getSamplerPointerArray();
		COLLADAFW::Sampler *sampler = samp_array[ctex.getSamplerId()];
			
		const COLLADAFW::UniqueId& ima_uid = sampler->getSourceImage();
		
		if (uid_image_map.find(ima_uid) == uid_image_map.end()) {
			fprintf(stderr, "Couldn't find an image by UID.\n");
			return NULL;
		}
		
		ma->mtex[i] = add_mtex();
		ma->mtex[i]->texco = TEXCO_UV;
		ma->mtex[i]->tex = add_texture("Texture");
		ma->mtex[i]->tex->type = TEX_IMAGE;
		ma->mtex[i]->tex->imaflag &= ~TEX_USEALPHA;
		ma->mtex[i]->tex->ima = uid_image_map[ima_uid];
		
		texindex_texarray_map[ctex.getTextureMapId()].push_back(ma->mtex[i]);
		
		return ma->mtex[i];
	}
	
	void write_profile_COMMON(COLLADAFW::EffectCommon *ef, Material *ma)
	{
		COLLADAFW::EffectCommon::ShaderType shader = ef->getShaderType();
		
		// blinn
		if (shader == COLLADAFW::EffectCommon::SHADER_BLINN) {
			ma->spec_shader = MA_SPEC_BLINN;
			ma->spec = ef->getShininess().getFloatValue();
		}
		// phong
		else if (shader == COLLADAFW::EffectCommon::SHADER_PHONG) {
			ma->spec_shader = MA_SPEC_PHONG;
			// XXX setting specular hardness instead of specularity intensity
			ma->har = ef->getShininess().getFloatValue() * 4;
		}
		// lambert
		else if (shader == COLLADAFW::EffectCommon::SHADER_LAMBERT) {
			ma->diff_shader = MA_DIFF_LAMBERT;
		}
		// default - lambert
		else {
			ma->diff_shader = MA_DIFF_LAMBERT;
			fprintf(stderr, "Current shader type is not supported.\n");
		}
		// reflectivity
		ma->ray_mirror = ef->getReflectivity().getFloatValue();
		// index of refraction
		ma->ang = ef->getIndexOfRefraction().getFloatValue();
		
		int i = 0;
		COLLADAFW::Color col;
		MTex *mtex = NULL;
		TexIndexTextureArrayMap texindex_texarray_map;
		
		// DIFFUSE
		// color
		if (ef->getDiffuse().isColor()) {
			col = ef->getDiffuse().getColor();
			ma->r = col.getRed();
			ma->g = col.getGreen();
			ma->b = col.getBlue();
		}
		// texture
		else if (ef->getDiffuse().isTexture()) {
			COLLADAFW::Texture ctex = ef->getDiffuse().getTexture(); 
			mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
			if (mtex != NULL) {
				mtex->mapto = MAP_COL;
				ma->texact = (int)i;
				i++;
			}
		}
		// AMBIENT
		// color
		if (ef->getAmbient().isColor()) {
			col = ef->getAmbient().getColor();
			ma->ambr = col.getRed();
			ma->ambg = col.getGreen();
			ma->ambb = col.getBlue();
		}
		// texture
		else if (ef->getAmbient().isTexture()) {
			COLLADAFW::Texture ctex = ef->getAmbient().getTexture(); 
			mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
			if (mtex != NULL) {
				mtex->mapto = MAP_AMB; 
				i++;
			}
		}
		// SPECULAR
		// color
		if (ef->getSpecular().isColor()) {
			col = ef->getSpecular().getColor();
			ma->specr = col.getRed();
			ma->specg = col.getGreen();
			ma->specb = col.getBlue();
		}
		// texture
		else if (ef->getSpecular().isTexture()) {
			COLLADAFW::Texture ctex = ef->getSpecular().getTexture(); 
			mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
			if (mtex != NULL) {
				mtex->mapto = MAP_SPEC; 
				i++;
			}
		}
		// REFLECTIVE
		// color
		if (ef->getReflective().isColor()) {
			col = ef->getReflective().getColor();
			ma->mirr = col.getRed();
			ma->mirg = col.getGreen();
			ma->mirb = col.getBlue();
		}
		// texture
		else if (ef->getReflective().isTexture()) {
			COLLADAFW::Texture ctex = ef->getReflective().getTexture(); 
			mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
			if (mtex != NULL) {
				mtex->mapto = MAP_REF; 
				i++;
			}
		}
		// EMISSION
		// color
		if (ef->getEmission().isColor()) {
			// XXX there is no emission color in blender
			// but I am not sure
		}
		// texture
		else if (ef->getEmission().isTexture()) {
			COLLADAFW::Texture ctex = ef->getEmission().getTexture(); 
			mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
			if (mtex != NULL) {
				mtex->mapto = MAP_EMIT; 
				i++;
			}
		}
		// TRANSPARENT
		// color
	// 	if (ef->getOpacity().isColor()) {
// 			// XXX don't know what to do here
// 		}
// 		// texture
// 		else if (ef->getOpacity().isTexture()) {
// 			ctex = ef->getOpacity().getTexture();
// 			if (mtex != NULL) mtex->mapto &= MAP_ALPHA;
// 			else {
// 				mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
// 				if (mtex != NULL) mtex->mapto = MAP_ALPHA;
// 			}
// 		}
		material_texture_mapping_map[ma] = texindex_texarray_map;
	}
	
	/** When this method is called, the writer must write the effect.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	
	virtual bool writeEffect( const COLLADAFW::Effect* effect ) 
	{
		
		const COLLADAFW::UniqueId& uid = effect->getUniqueId();
		if (uid_effect_map.find(uid) == uid_effect_map.end()) {
			fprintf(stderr, "Couldn't find a material by UID.\n");
			return true;
		}
		
		Material *ma = uid_effect_map[uid];
		
		COLLADAFW::CommonEffectPointerArray common_efs = effect->getCommonEffects();
		if (common_efs.getCount() < 1) {
			fprintf(stderr, "Couldn't find <profile_COMMON>.\n");
			return true;
		}
		// XXX TODO: Take all <profile_common>s
		// Currently only first <profile_common> is supported
		COLLADAFW::EffectCommon *ef = common_efs[0];
		write_profile_COMMON(ef, ma);
		
		return true;
	}
	
	
	/** When this method is called, the writer must write the camera.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeCamera( const COLLADAFW::Camera* camera ) 
	{
		Camera *cam = NULL;
		std::string cam_id, cam_name;
		
		cam_id = camera->getOriginalId();
		cam_name = camera->getName();
		if (cam_name.size()) cam = (Camera*)add_camera((char*)cam_name.c_str());
		else cam = (Camera*)add_camera((char*)cam_id.c_str());
		
		if (!cam) {
			fprintf(stderr, "Cannot create camera. \n");
			return true;
		}
		cam->clipsta = camera->getNearClippingPlane().getValue();
		cam->clipend = camera->getFarClippingPlane().getValue();
		
		COLLADAFW::Camera::CameraType type = camera->getCameraType();
		switch(type) {
		case COLLADAFW::Camera::ORTHOGRAPHIC:
			{
				cam->type = CAM_ORTHO;
			}
			break;
		case COLLADAFW::Camera::PERSPECTIVE:
			{
				cam->type = CAM_PERSP;
			}
			break;
		case COLLADAFW::Camera::UNDEFINED_CAMERATYPE:
			{
				fprintf(stderr, "Current camera type is not supported. \n");
				cam->type = CAM_PERSP;
			}
			break;
		}
		this->uid_camera_map[camera->getUniqueId()] = cam;
		// XXX import camera options
		return true;
	}

	/** When this method is called, the writer must write the image.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeImage( const COLLADAFW::Image* image ) 
	{
		// XXX maybe it is necessary to check if the path is absolute or relative
	    const std::string& filepath = image->getImageURI().toNativePath();
		const char *filename = (const char*)mFilename.c_str();
		char dir[FILE_MAX];
		char full_path[FILE_MAX];
		
		BLI_split_dirfile(filename, dir, NULL);
		BLI_join_dirfile(full_path, dir, filepath.c_str());
		Image *ima = BKE_add_image_file(full_path, 0);
		if (!ima) {
			fprintf(stderr, "Cannot create image. \n");
			return true;
		}
		this->uid_image_map[image->getUniqueId()] = ima;
		
		return true;
	}

	/** When this method is called, the writer must write the light.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeLight( const COLLADAFW::Light* light ) 
	{
		Lamp *lamp = NULL;
		std::string la_id, la_name;
		
		la_id = light->getOriginalId();
		la_name = light->getName();
		if (la_name.size()) lamp = (Lamp*)add_lamp((char*)la_name.c_str());
		else lamp = (Lamp*)add_lamp((char*)la_id.c_str());
		
		if (!lamp) {
			fprintf(stderr, "Cannot create lamp. \n");
			return true;
		}
		if (light->getColor().isValid()) {
			COLLADAFW::Color col = light->getColor();
			lamp->r = col.getRed();
			lamp->g = col.getGreen();
			lamp->b = col.getBlue();
		}
		COLLADAFW::Light::LightType type = light->getLightType();
		switch(type) {
		case COLLADAFW::Light::AMBIENT_LIGHT:
			{
				lamp->type = LA_HEMI;
			}
			break;
		case COLLADAFW::Light::SPOT_LIGHT:
			{
				lamp->type = LA_SPOT;
				lamp->falloff_type = LA_FALLOFF_SLIDERS;
				lamp->att1 = light->getLinearAttenuation().getValue();
				lamp->att2 = light->getQuadraticAttenuation().getValue();
				lamp->spotsize = light->getFallOffAngle().getValue();
				lamp->spotblend = light->getFallOffExponent().getValue();
			}
			break;
		case COLLADAFW::Light::DIRECTIONAL_LIGHT:
			{
				lamp->type = LA_SUN;
			}
			break;
		case COLLADAFW::Light::POINT_LIGHT:
			{
				lamp->type = LA_LOCAL;
				lamp->att1 = light->getLinearAttenuation().getValue();
				lamp->att2 = light->getQuadraticAttenuation().getValue();
			}
			break;
		case COLLADAFW::Light::UNDEFINED:
			{
				fprintf(stderr, "Current lamp type is not supported. \n");
				lamp->type = LA_LOCAL;
			}
			break;
		}
			
		this->uid_lamp_map[light->getUniqueId()] = lamp;
		return true;
	}
	
	// this function is called only for animations that pass COLLADAFW::validate
	virtual bool writeAnimation( const COLLADAFW::Animation* anim ) 
	{
		// return true;
		return anim_importer.write_animation(anim);
	}
	
	// called on post-process stage after writeVisualScenes
	virtual bool writeAnimationList( const COLLADAFW::AnimationList* animationList ) 
	{
		// return true;
		return anim_importer.write_animation_list(animationList);
	}
	
	/** When this method is called, the writer must write the skin controller data.
		@return The writer should return true, if writing succeeded, false otherwise.*/
	virtual bool writeSkinControllerData( const COLLADAFW::SkinControllerData* skin ) 
	{
		return armature_importer.write_skin_controller_data(skin);
	}

	// this is called on postprocess, before writeVisualScenes
	virtual bool writeController( const COLLADAFW::Controller* controller ) 
	{
		return armature_importer.write_controller(controller);
	}

	virtual bool writeFormulas( const COLLADAFW::Formulas* formulas )
	{
		return true;
	}

	virtual bool writeKinematicsScene( const COLLADAFW::KinematicsScene* kinematicsScene )
	{
		return true;
	}
};

void DocumentImporter::import(bContext *C, const char *filename)
{
	Writer w(C, filename);
	w.write();
}