importing and loading animations and skeletons from file, saving into…

… prefab as well

Engine/Animation.cpp

@@ -1,39 +1,5 @@
 #include "Animation.h"
 
-void Animation::AnimationClip::AnimationSample::Draw(const GLfloat* opengl_view_matrix) const
-{
-	float4x4 transform;
-
-	glBegin(GL_LINES);
-
-	for (int i = 0; i < joint_poses.size(); i++)
-	{
-		glPushMatrix();
-		glLoadMatrixf(opengl_view_matrix);
-
-		transform = global_joint_poses[i];
-		glMultMatrixf(&transform.At(0, 0));
-
-		//X
-		glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
-		glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(1.0f, 0.0f, 0.0f);
-
-		//Y
-		glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
-		glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f);
-
-		//Z
-		glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
-		glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(0.0f, 0.0f, 1.0f);
-
-		glPopMatrix();
-	}
-
-	glEnd();
-
-	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-}
-
 Animation::AnimationClip::AnimationClip()
 {
 }
@@ -53,3 +19,18 @@ Animation::~Animation()
 	if (source != nullptr)
 		delete source;
 }
+
+void Animation::SetAnimationClip(AnimationClip * new_clip)
+{
+	source = new_clip;
+}
+
+bool Animation::Inspector()
+{
+	return false;
+}
+
+bool Animation::IsLoaded() const
+{
+	return source != nullptr;
+}

Engine/Animation.h

@@ -16,24 +16,35 @@ class Animation : public Resource
 private:
 	struct AnimationClip
 	{	
-		struct JointPose
+		struct SamplePos
 		{
 			float3 position;
+			double time;
+		};
+
+		struct SampleRot
+		{
 			Quat rotation;
-			float scale;
+			double time;
 		};
 
-		struct AnimationSample
+		struct SampleScale
 		{
-			std::vector<JointPose> joint_poses; //maybe useless
-			std::vector<float4x4> global_joint_poses;
+			float3 scale;
+			double time;
+		};
 
-			void Draw(const GLfloat* opengl_view_matrix) const;
+		struct Channel
+		{
+			std::string joint_name;
+			std::vector<SamplePos*> position_samples;
+			std::vector<SampleRot*> rotation_samples;
+			std::vector<SampleScale*> scale_samples;
 		};
 
-		float fps;
+		double fps;
 		uint frame_count;
-		std::vector<AnimationSample*> samples;
+		std::vector<Channel*> chanels;
 		bool loop;
 
 		AnimationClip();
@@ -52,7 +63,11 @@ class Animation : public Resource
 private:
 
 public:
-
+	void SetAnimationClip(AnimationClip* new_clip);
+
+	bool Inspector();
+
+	bool IsLoaded() const;
 };
 
 #endif // !ANIMATION

Engine/AnimationAsset.h

@@ -29,10 +29,10 @@ struct AnimationImportConfiguration: public ImportConfiguration
 	AnimationImportConfiguration();
 	~AnimationImportConfiguration();
 
-	virtual bool Config();
-	virtual void MetaSave(char** iterator) const;
-	virtual void MetaLoad(char** iterator);
-	virtual unsigned int GetMetaSize() const;
+	bool Config();
+	void MetaSave(char** iterator) const;
+	void MetaLoad(char** iterator);
+	unsigned int GetMetaSize() const;
 };
 
 struct AnimationLoadConfiguration: public LoadConfiguration
@@ -41,10 +41,10 @@ struct AnimationLoadConfiguration: public LoadConfiguration
 	AnimationLoadConfiguration();
 	~AnimationLoadConfiguration();
 
-	virtual bool Config();
-	virtual void MetaSave(char** iterator) const;
-	virtual void MetaLoad(char** iterator);
-	virtual unsigned int GetMetaSize() const;
+	bool Config();
+	void MetaSave(char** iterator) const;
+	void MetaLoad(char** iterator);
+	unsigned int GetMetaSize() const;
 };
 
 #endif // !ANIMATION_ASSET

Engine/AnimationImporter.cpp

@@ -1,7 +1,10 @@
 #include "Globals.h"
 #include "UID.h"
+#include "Animation.h"
 #include "AnimationAsset.h"
 #include "AssetDirectory.h"
+#include "FileSystem.h"
+#include "Application.h"
 #include "AnimationImporter.h"
 
 AnimationImporter::AnimationImporter()
@@ -12,10 +15,23 @@ AnimationImporter::~AnimationImporter()
 
 unsigned int AnimationImporter::GetTotalSize(const aiAnimation * animation) const
 {
-	return 0;
+	unsigned int size = FORMAT_SIZE;
+	size += sizeof(unsigned int);
+	size += sizeof(double);
+
+	for (unsigned int i = 0; i < animation->mNumChannels; i++)
+	{
+		size += animation->mChannels[i]->mNodeName.length + 1;
+		size += sizeof(unsigned int) * 3;
+		size += animation->mChannels[i]->mNumPositionKeys * (sizeof(double) + sizeof(float) * 3);
+		size += animation->mChannels[i]->mNumRotationKeys * (sizeof(double) + sizeof(float) * 4);
+		size += animation->mChannels[i]->mNumScalingKeys * (sizeof(double) + sizeof(float) * 3);
+	}
+
+	return size;
 }
 
-const UID AnimationImporter::Import(const std::string & scene_path, const aiAnimation * animation, const AnimationImportConfiguration * config, AssetDirectory * dir) const
+const UID AnimationImporter::Import(const aiAnimation * animation, const AnimationImportConfiguration * config) const
 {
 	char* buffer = new char[GetTotalSize(animation)];
 	char* iterator = buffer;
@@ -24,15 +40,122 @@ const UID AnimationImporter::Import(const std::string & scene_path, const aiAnim
 	memcpy(iterator, format, FORMAT_SIZE);
 	iterator += FORMAT_SIZE;
 
-	memcpy(iterator, animation->mName.C_Str(), strlen(animation->mName.C_Str()) + 1);
-	iterator += strlen(animation->mName.C_Str()) + 1;
+	memcpy(iterator, &animation->mNumChannels, sizeof(unsigned int));
+	iterator += sizeof(unsigned int);
+
+	memcpy(iterator, &animation->mTicksPerSecond, sizeof(double));
+	iterator += sizeof(double);
+
+	for (unsigned int i = 0; i < animation->mNumChannels; i++)
+	{
+		memcpy(iterator, animation->mChannels[i]->mNodeName.C_Str(), animation->mChannels[i]->mNodeName.length + 1);
+		iterator += animation->mChannels[i]->mNodeName.length + 1;
+
+		memcpy(iterator, &animation->mChannels[i]->mNumPositionKeys, sizeof(unsigned int) * 3);
+		iterator += sizeof(unsigned int) * 3;
+
+		//Positions
+		for (int j = 0; j < animation->mChannels[i]->mNumPositionKeys; j++)
+		{
+			memcpy(iterator, &animation->mChannels[i]->mPositionKeys[j].mTime, sizeof(double));
+			iterator += sizeof(double);
+
+			memcpy(iterator, &animation->mChannels[i]->mPositionKeys[j].mValue.x, sizeof(float) * 3);
+			iterator += sizeof(float) * 3;
+		}
+
+		//Rotations
+		for (int j = 0; j < animation->mChannels[i]->mNumRotationKeys; j++)
+		{
+			memcpy(iterator, &animation->mChannels[i]->mRotationKeys[j].mTime, sizeof(double));
+			iterator += sizeof(double);
+
+			memcpy(iterator, &animation->mChannels[i]->mRotationKeys[j].mValue.w, sizeof(float) * 3);
+			iterator += sizeof(float) * 3;
+		}
+
+		//Scaling
+		for (int j = 0; j < animation->mChannels[i]->mNumScalingKeys; j++)
+		{
+			memcpy(iterator, &animation->mChannels[i]->mScalingKeys[j].mTime, sizeof(double));
+			iterator += sizeof(double);
+
+			memcpy(iterator, &animation->mChannels[i]->mScalingKeys[j].mValue.x, sizeof(float) * 3);
+			iterator += sizeof(float) * 3;
+		}
+	}
+
+	uint length = iterator - buffer;
+
+	UID id(buffer, length);
 
-	//ImportSkeleton(animation->);
+	if (App->file_system->SaveFile(buffer, length, App->file_system->GetAnimations().c_str(), id.GetAsName(), "mm") == false)
+	{
+		LOG("Could not save animation correctlly");
+		return UID();
+	}
 
-	return UID();
+	delete[] buffer;
+
+	return id;
 }
 
 bool AnimationImporter::Load(Animation * to_load, unsigned int priority, const AnimationLoadConfiguration * config) const
 {
+	char* buffer = nullptr;
+	char* iterator = nullptr;
+	uint length = 0;
+
+	std::string path(App->file_system->GetSkeletons());
+	path += "\\";
+	path += to_load->GetUID().GetAsName();
+	path += ".mm";
+	length = App->file_system->LoadFileBinary(path, &buffer);
+
+	if (buffer != nullptr && length != 0)
+	{
+		iterator = buffer;
+		iterator += FORMAT_SIZE;
+
+		Animation::AnimationClip* new_clip = new Animation::AnimationClip;
+
+		unsigned int num_channels;
+		memcpy(&num_channels, iterator, sizeof(unsigned int));
+		iterator += sizeof(unsigned int);
+
+		memcpy(&new_clip->fps, iterator, sizeof(double));
+		iterator += sizeof(double);
+
+		for (unsigned int i = 0; i < num_channels; i++)
+		{
+			Animation::AnimationClip::Channel* new_channel = new Animation::AnimationClip::Channel;
+
+			new_channel->joint_name = iterator;
+			iterator += new_channel->joint_name.length() + 1;
+
+			unsigned int num_keys[3];
+			memcpy(num_keys, iterator, sizeof(unsigned int) * 3);
+			iterator += sizeof(unsigned int) * 3;
+
+			//Positions
+			new_channel->position_samples.resize(num_keys[0]);
+			memcpy(new_channel->position_samples[0], iterator, (sizeof(double) + sizeof(float) * 3) * num_keys[0]);
+			iterator += (sizeof(double) + sizeof(float) * 3) * num_keys[0];
+
+			//Rotations
+			new_channel->position_samples.resize(num_keys[1]);
+			memcpy(new_channel->position_samples[0], iterator, (sizeof(double) + sizeof(float) * 4) * num_keys[1]);
+			iterator += (sizeof(double) + sizeof(float) * 4) * num_keys[1];
+
+			//Scaling
+			new_channel->position_samples.resize(num_keys[2]);
+			memcpy(new_channel->position_samples[0], iterator, (sizeof(double) + sizeof(float) * 3) * num_keys[2]);
+			iterator += (sizeof(double) + sizeof(float) * 3) * num_keys[2];
+		}
+
+		to_load->SetAnimationClip(new_clip);
+		return true;
+	}
+	LOG("Could not read %s", path.c_str());
 	return false;
 }

Engine/AnimationImporter.h

@@ -25,7 +25,7 @@ class AnimationImporter
 	unsigned int GetTotalSize(const aiAnimation * animation) const;
 
 public:
-	const UID Import(const std::string& scene_path, const aiAnimation* animation, const AnimationImportConfiguration* config, AssetDirectory* dir = nullptr) const;
+	const UID Import(const aiAnimation* animation, const AnimationImportConfiguration* config) const;
 	bool Load(Animation* to_load, unsigned int priority, const AnimationLoadConfiguration* config) const;
 };
 

Engine/Asset.cpp

@@ -61,10 +61,10 @@ const std::string & Asset::GetName() const
 	return resource->GetName();
 }
 
-SceneImportConfiguration::SceneImportConfiguration(): include_meshes(true), include_materials(true), include_prefabs(true), include_animations(false), include_lights(false), include_cameras(false), include_bones(true), material_import_config(new MaterialImportConfiguration), mesh_import_config (new MeshImportConfiguration), prefab_import_config(new PrefabImportConfiguration), anim_import_config(new AnimationImportConfiguration), skeleton_import_config(new SkeletonImportConfiguration), material_load_config(new MaterialLoadConfiguration), mesh_load_config(new MeshLoadConfiguration), prefab_load_config(new PrefabLoadConfiguration), anim_load_config(new AnimationLoadConfiguration), skeleton_load_config(new SkeletonLoadConfiguration)
+SceneImportConfiguration::SceneImportConfiguration(): include_meshes(true), include_materials(true), include_prefabs(true), include_animations(true), include_lights(false), include_cameras(false), include_bones(true), material_import_config(new MaterialImportConfiguration), mesh_import_config (new MeshImportConfiguration), prefab_import_config(new PrefabImportConfiguration), anim_import_config(new AnimationImportConfiguration), skeleton_import_config(new SkeletonImportConfiguration), material_load_config(new MaterialLoadConfiguration), mesh_load_config(new MeshLoadConfiguration), prefab_load_config(new PrefabLoadConfiguration), anim_load_config(new AnimationLoadConfiguration), skeleton_load_config(new SkeletonLoadConfiguration)
 {}
 
-SceneImportConfiguration::SceneImportConfiguration(const SceneImportConfiguration & copy) : include_meshes(copy.include_meshes), include_materials(copy.include_materials), include_prefabs(copy.include_prefabs), include_animations(copy.include_animations), include_lights(copy.include_lights), include_cameras(copy.include_cameras), material_import_config(copy.material_import_config), mesh_import_config(copy.mesh_import_config), prefab_import_config(copy.prefab_import_config), anim_import_config(copy.anim_import_config), skeleton_import_config(copy.skeleton_import_config), material_load_config(copy.material_load_config), mesh_load_config(copy.mesh_load_config), prefab_load_config(copy.prefab_load_config), anim_load_config(copy.anim_load_config), skeleton_load_config(copy.skeleton_load_config)
+SceneImportConfiguration::SceneImportConfiguration(const SceneImportConfiguration & copy) : include_meshes(copy.include_meshes), include_materials(copy.include_materials), include_prefabs(copy.include_prefabs), include_animations(copy.include_animations), include_lights(copy.include_lights), include_cameras(copy.include_cameras), include_bones(copy.include_bones), material_import_config(copy.material_import_config), mesh_import_config(copy.mesh_import_config), prefab_import_config(copy.prefab_import_config), anim_import_config(copy.anim_import_config), skeleton_import_config(copy.skeleton_import_config), material_load_config(copy.material_load_config), mesh_load_config(copy.mesh_load_config), prefab_load_config(copy.prefab_load_config), anim_load_config(copy.anim_load_config), skeleton_load_config(copy.skeleton_load_config)
 {}
 
 SceneImportConfiguration::~SceneImportConfiguration()
@@ -97,6 +97,9 @@ bool SceneImportConfiguration::Config()
 	if (ImGui::Checkbox("Include Animations", &include_animations))
 		ret = true;
 
+	if (ImGui::Checkbox("Include Riggs", &include_bones))
+		ret = true;
+
 	if (ImGui::Checkbox("Include Lights", &include_lights))
 		ret = true;
 	ImGui::SameLine();
@@ -159,19 +162,6 @@ bool SceneImportConfiguration::Config()
 		}
 	}
 
-	if (include_bones)
-	{
-		if (ImGui::TreeNodeEx("Animations' Configuration", ImGuiTreeNodeFlags_Framed))
-		{
-			if (anim_import_config->Config())
-				ret = true;
-			if (anim_load_config->Config())
-				ret = true;
-
-			ImGui::TreePop();
-		}
-	}
-
 	if (include_bones)
 	{
 		if (ImGui::TreeNodeEx("Riggs' Configuration", ImGuiTreeNodeFlags_Framed))

Engine/AssetDirectory.cpp

@@ -11,13 +11,17 @@
 #include "Material.h"
 #include "Mesh.h"
 #include "PreFab.h"
+#include "Skeleton.h"
+#include "Animation.h"
 
 //Assets
 #include "Asset.h"
 #include "TextureAsset.h"
 #include "MaterialAsset.h"
 #include "MeshAsset.h"
 #include "PrefabAsset.h"
+#include "SkeletonAsset.h"
+#include "AnimationAsset.h"
 
 #include "ImportManager.h"
 #include "ResourceManager.h"
@@ -94,6 +98,14 @@ void AssetDirectory::AddAsset(const std::string& name, const UID& uid, RESOURCE_
 		new_resource = new Material(name, uid);
 		new_asset = new MaterialAsset(new_resource, new MaterialImportConfiguration(*(MaterialImportConfiguration*)import_config), new MaterialLoadConfiguration(*(MaterialLoadConfiguration*)load_config));
 		break;
+	case RT_SKELETON:
+		new_resource = new Skeleton(name, uid);
+		new_asset = new SkeletonAsset((Skeleton*)new_resource, new SkeletonImportConfiguration(*(SkeletonImportConfiguration*)import_config), new SkeletonLoadConfiguration(*(SkeletonLoadConfiguration*)load_config));
+		break;
+	case RT_ANIMATION:
+		new_resource = new Animation(name, uid);
+		new_asset = new AnimationAsset((Animation*)new_resource, new AnimationImportConfiguration(*(AnimationImportConfiguration*)import_config), new AnimationLoadConfiguration(*(AnimationLoadConfiguration*)load_config));
+		break;
 	default:
 		LOG("Non standard import type");
 		break;