v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

OgreImporter: Cleanup skeleton related code and code that populates the assimp scene. Tested skeleton/animation imports and it seems to work correctly now.

pull/266/head
Jonne Nauha 2014-05-02 00:19:57 +03:00
parent f5c7b283bc
commit 283394d695
5 changed files with 225 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
code/OgreImporter.cpp
View File

@ -69,6 +69,18 @@ namespace Assimp
namespace Ogre namespace Ogre
{ {
const aiImporterDesc* OgreImporter::GetInfo() const
{
return &desc;
}
void OgreImporter::SetupProperties(const Importer* pImp)
{
m_userDefinedMaterialLibFile = pImp->GetPropertyString(AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE, "Scene.material");
m_detectTextureTypeFromFilename = pImp->GetPropertyBool(AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME, false);
}
bool OgreImporter::CanRead(const std::string &pFile, Assimp::IOSystem *pIOHandler, bool checkSig) const bool OgreImporter::CanRead(const std::string &pFile, Assimp::IOSystem *pIOHandler, bool checkSig) const
{ {
if (!checkSig) if (!checkSig)
@ -127,7 +139,7 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass
if (!CurrentNodeNameEquals(reader, nnSubMeshes)) if (!CurrentNodeNameEquals(reader, nnSubMeshes))
throw DeadlyImportError("Could not find <submeshes> node inside root <mesh> node"); throw DeadlyImportError("Could not find <submeshes> node inside root <mesh> node");
list<boost::shared_ptr<SubMesh> > subMeshes; vector<boost::shared_ptr<SubMesh> > subMeshes;
vector<aiMaterial*> materials; vector<aiMaterial*> materials;
NextNode(reader.get()); NextNode(reader.get());
@ -195,48 +207,33 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass
// -------------------- Apply to aiScene -------------------- // -------------------- Apply to aiScene --------------------
//put the aiMaterials in the scene: // Materials
pScene->mMaterials=new aiMaterial*[materials.size()]; pScene->mMaterials = new aiMaterial*[materials.size()];
pScene->mNumMaterials=materials.size(); pScene->mNumMaterials = materials.size();
for(unsigned int i=0; i<materials.size(); ++i)
pScene->mMaterials[i]=materials[i];
//create the aiMehs... for(size_t i=0, len=materials.size(); i<len; ++i)
vector<aiMesh*> aiMeshes; pScene->mMaterials[i] = materials[i];
BOOST_FOREACH(boost::shared_ptr<SubMesh> theSubMesh, subMeshes)
// Meshes
pScene->mMeshes = new aiMesh*[subMeshes.size()];
pScene->mNumMeshes = subMeshes.size();
for(size_t i=0, len=subMeshes.size(); i<len; ++i)
{ {
aiMeshes.push_back(CreateAssimpSubMesh(pScene, *theSubMesh, Bones)); boost::shared_ptr<SubMesh> submesh = subMeshes[i];
pScene->mMeshes[i] = CreateAssimpSubMesh(pScene, *(submesh.get()), Bones);
} }
//... and put them in the scene:
pScene->mNumMeshes=aiMeshes.size();
pScene->mMeshes=new aiMesh*[aiMeshes.size()];
memcpy(pScene->mMeshes, &(aiMeshes[0]), sizeof(aiMeshes[0])*aiMeshes.size());
//Create the root node // Create the root node
pScene->mRootNode=new aiNode("root"); pScene->mRootNode = new aiNode();
pScene->mRootNode->mMeshes = new unsigned int[subMeshes.size()];
//link the meshs with the root node: pScene->mRootNode->mNumMeshes = subMeshes.size();
pScene->mRootNode->mMeshes=new unsigned int[subMeshes.size()];
pScene->mRootNode->mNumMeshes=subMeshes.size();
for(unsigned int i=0; i<subMeshes.size(); ++i) for(size_t i=0, len=subMeshes.size(); i<len; ++i)
pScene->mRootNode->mMeshes[i]=i; pScene->mRootNode->mMeshes[i] = static_cast<unsigned int>(i);
// Skeleton and animations
CreateAssimpSkeleton(pScene, Bones, Animations); CreateAssimpSkeleton(pScene, Bones, Animations);
PutAnimationsInScene(pScene, Bones, Animations);
}
const aiImporterDesc* OgreImporter::GetInfo () const
{
return &desc;
}
void OgreImporter::SetupProperties(const Importer* pImp)
{
m_userDefinedMaterialLibFile = pImp->GetPropertyString(AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE, "Scene.material");
m_detectTextureTypeFromFilename = pImp->GetPropertyBool(AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME, false);
} }
} // Ogre } // Ogre

19
code/OgreImporter.h
View File

@ -71,16 +71,16 @@ class OgreImporter : public BaseImporter
{ {
public: public:
/// BaseImporter override. /// BaseImporter override.
virtual bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const; virtual bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const;
/// BaseImporter override. /// BaseImporter override.
virtual void InternReadFile(const std::string &pFile, aiScene* pScene, IOSystem* pIOHandler); virtual void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
/// BaseImporter override. /// BaseImporter override.
virtual const aiImporterDesc* GetInfo () const; virtual const aiImporterDesc *GetInfo() const;
/// BaseImporter override. /// BaseImporter override.
virtual void SetupProperties(const Importer* pImp); virtual void SetupProperties(const Importer *pImp);
private: private:
//-------------------------------- OgreMesh.cpp ------------------------------- //-------------------------------- OgreMesh.cpp -------------------------------
@ -98,7 +98,7 @@ private:
static void ProcessSubMesh(SubMesh &submesh, SubMesh &sharedGeometry); static void ProcessSubMesh(SubMesh &submesh, SubMesh &sharedGeometry);
/// Uses the bone data to convert a SubMesh into a aiMesh which will be created and returned. /// Uses the bone data to convert a SubMesh into a aiMesh which will be created and returned.
aiMesh* CreateAssimpSubMesh(aiScene *pScene, const SubMesh &submesh, const std::vector<Bone>& bones) const; aiMesh *CreateAssimpSubMesh(aiScene *pScene, const SubMesh &submesh, const std::vector<Bone> &bones) const;
//-------------------------------- OgreSkeleton.cpp ------------------------------- //-------------------------------- OgreSkeleton.cpp -------------------------------
@ -110,10 +110,10 @@ private:
void PutAnimationsInScene(aiScene *pScene, const std::vector<Bone> &Bones, const std::vector<Animation> &Animations); void PutAnimationsInScene(aiScene *pScene, const std::vector<Bone> &Bones, const std::vector<Animation> &Animations);
/// Creates the aiSkeleton in current scene. /// Creates the aiSkeleton in current scene.
void CreateAssimpSkeleton(aiScene *pScene, const std::vector<Bone> &Bones, const std::vector<Animation> &Animations); void CreateAssimpSkeleton(aiScene *pScene, const std::vector<Bone> &bones, const std::vector<Animation> &animations);
/// Recursivly creates a filled aiNode from a given root bone. /// Recursively creates a filled aiNode from a given root bone.
static aiNode* CreateAiNodeFromBone(int BoneId, const std::vector<Bone> &Bones, aiNode* ParentNode); static aiNode* CreateNodeFromBone(int boneId, const std::vector<Bone> &bones, aiNode *parent);
//-------------------------------- OgreMaterial.cpp ------------------------------- //-------------------------------- OgreMaterial.cpp -------------------------------
@ -131,7 +131,8 @@ private:
std::string m_userDefinedMaterialLibFile; std::string m_userDefinedMaterialLibFile;
bool m_detectTextureTypeFromFilename; bool m_detectTextureTypeFromFilename;
SubMesh m_SharedGeometry;///< we will just use the vertexbuffers of the submesh /// VertexBuffer for the sub meshes that use shader geometry.
SubMesh m_SharedGeometry;
std::map<aiTextureType, unsigned int> m_textures; std::map<aiTextureType, unsigned int> m_textures;
}; };

151
code/OgreMesh.cpp
View File

@ -442,110 +442,103 @@ void OgreImporter::ProcessSubMesh(SubMesh &submesh, SubMesh &sharedGeometry)
//_________________________________________________________ //_________________________________________________________
} }
aiMesh* OgreImporter::CreateAssimpSubMesh(aiScene *pScene, const SubMesh& submesh, const vector<Bone>& bones) const aiMesh *OgreImporter::CreateAssimpSubMesh(aiScene *pScene, const SubMesh& submesh, const vector<Bone>& bones) const
{ {
aiMesh* NewAiMesh = new aiMesh(); const size_t sizeVector3D = sizeof(aiVector3D);
//Positions
NewAiMesh->mVertices=new aiVector3D[submesh.Positions.size()];
memcpy(NewAiMesh->mVertices, &submesh.Positions[0], submesh.Positions.size()*sizeof(aiVector3D));
NewAiMesh->mNumVertices=submesh.Positions.size();
//Normals aiMesh *dest = new aiMesh();
if(submesh.HasNormals)
// Material
dest->mMaterialIndex = submesh.MaterialIndex;
// Positions
dest->mVertices = new aiVector3D[submesh.Positions.size()];
dest->mNumVertices = submesh.Positions.size();
memcpy(dest->mVertices, &submesh.Positions[0], submesh.Positions.size() * sizeVector3D);
// Normals
if (submesh.HasNormals)
{ {
NewAiMesh->mNormals=new aiVector3D[submesh.Normals.size()]; dest->mNormals = new aiVector3D[submesh.Normals.size()];
memcpy(NewAiMesh->mNormals, &submesh.Normals[0], submesh.Normals.size()*sizeof(aiVector3D)); memcpy(dest->mNormals, &submesh.Normals[0], submesh.Normals.size() * sizeVector3D);
}
// Tangents
// Until we have support for bitangents, no tangents will be written
/// @todo Investigate why the above?
if (submesh.HasTangents)
{
DefaultLogger::get()->warn("Tangents found from Ogre mesh but writing to Assimp mesh not yet supported!");
//dest->mTangents = new aiVector3D[submesh.Tangents.size()];
//memcpy(dest->mTangents, &submesh.Tangents[0], submesh.Tangents.size() * sizeVector3D);
} }
// UVs
//until we have support for bitangents, no tangents will be written for (size_t i=0, len=submesh.Uvs.size(); i<len; ++i)
/*
//Tangents
if(submesh.HasTangents)
{ {
NewAiMesh->mTangents=new aiVector3D[submesh.Tangents.size()]; dest->mNumUVComponents[i] = 2;
memcpy(NewAiMesh->mTangents, &submesh.Tangents[0], submesh.Tangents.size()*sizeof(aiVector3D)); dest->mTextureCoords[i] = new aiVector3D[submesh.Uvs[i].size()];
memcpy(dest->mTextureCoords[i], &(submesh.Uvs[i][0]), submesh.Uvs[i].size() * sizeVector3D);
} }
*/
//Uvs // Bone weights. Convert internal vertex-to-bone mapping to bone-to-vertex.
if(submesh.Uvs.size()>0) vector<vector<aiVertexWeight> > assimpWeights(submesh.BonesUsed);
for(size_t vertexId=0, len=submesh.Weights.size(); vertexId<len; ++vertexId)
{ {
for(unsigned int i=0; i<submesh.Uvs.size(); ++i) const vector<BoneWeight> &vertexWeights = submesh.Weights[vertexId];
for (size_t boneId=0, len=vertexWeights.size(); boneId<len; ++boneId)
{ {
NewAiMesh->mNumUVComponents[i]=2; const BoneWeight &ogreWeight = vertexWeights[boneId];
NewAiMesh->mTextureCoords[i]=new aiVector3D[submesh.Uvs[i].size()]; assimpWeights[ogreWeight.Id].push_back(aiVertexWeight(vertexId, ogreWeight.Value));
memcpy(NewAiMesh->mTextureCoords[i], &(submesh.Uvs[i][0]), submesh.Uvs[i].size()*sizeof(aiVector3D));
} }
} }
// Bones.
vector<aiBone*> assimpBones;
assimpBones.reserve(submesh.BonesUsed);
//---------------------------------------- bones -------------------------------------------- for(size_t boneId=0, len=submesh.BonesUsed; boneId<len; ++boneId)
//Copy the weights in in Bone-Vertices Struktur
//(we have them in a Vertex-bones Structur, this is much easier for making them unique, which is required by assimp
vector< vector<aiVertexWeight> > aiWeights(submesh.BonesUsed);//now the outer list are the bones, and the inner vector the vertices
for(unsigned int VertexId=0; VertexId<submesh.Weights.size(); ++VertexId)//iterate over all vertices
{ {
for(unsigned int BoneId=0; BoneId<submesh.Weights[VertexId].size(); ++BoneId)//iterate over all bones const vector<aiVertexWeight> &boneWeights = assimpWeights[boneId];
{ if (boneWeights.size() == 0)
aiVertexWeight NewWeight; continue;
NewWeight.mVertexId=VertexId;//the current Vertex, we can't use the Id form the submehs weights, because they are bone id's
NewWeight.mWeight=submesh.Weights[VertexId][BoneId].Value; // @note The bones list is sorted by id's, this was done in LoadSkeleton.
aiWeights[submesh.Weights[VertexId][BoneId].Id].push_back(NewWeight); aiBone *assimpBone = new aiBone();
} assimpBone->mName = bones[boneId].Name;
assimpBone->mOffsetMatrix = bones[boneId].BoneToWorldSpace;
assimpBone->mNumWeights = boneWeights.size();
assimpBone->mWeights = new aiVertexWeight[boneWeights.size()];
memcpy(assimpBone->mWeights, &boneWeights[0], boneWeights.size() * sizeof(aiVertexWeight));
assimpBones.push_back(assimpBone);
} }
if (!assimpBones.empty())
vector<aiBone*> aiBones;
aiBones.reserve(submesh.BonesUsed);//the vector might be smaller, because there might be empty bones (bones that are not attached to any vertex)
//create all the bones and fill them with informations
for(unsigned int i=0; i<submesh.BonesUsed; ++i)
{ {
if(aiWeights[i].size()>0) dest->mBones = new aiBone*[assimpBones.size()];
{ dest->mNumBones = assimpBones.size();
aiBone* NewBone=new aiBone();
NewBone->mNumWeights=aiWeights[i].size(); for(size_t i=0, len=assimpBones.size(); i<len; ++i)
NewBone->mWeights=new aiVertexWeight[aiWeights[i].size()]; dest->mBones[i] = assimpBones[i];
memcpy(NewBone->mWeights, &(aiWeights[i][0]), sizeof(aiVertexWeight)*aiWeights[i].size());
NewBone->mName=bones[i].Name;//The bone list should be sorted after its id's, this was done in LoadSkeleton
NewBone->mOffsetMatrix=bones[i].BoneToWorldSpace;
aiBones.push_back(NewBone);
}
}
NewAiMesh->mNumBones=aiBones.size();
// mBones must be NULL if mNumBones is non 0 or the validation fails.
if (aiBones.size()) {
NewAiMesh->mBones=new aiBone* [aiBones.size()];
memcpy(NewAiMesh->mBones, &(aiBones[0]), aiBones.size()*sizeof(aiBone*));
} }
//______________________________________________________________________________________________________ // Faces
dest->mFaces = new aiFace[submesh.Faces.size()];
dest->mNumFaces = submesh.Faces.size();
for(size_t i=0, len=submesh.Faces.size(); i<len; ++i)
//Faces
NewAiMesh->mFaces=new aiFace[submesh.Faces.size()];
for(unsigned int i=0; i<submesh.Faces.size(); ++i)
{ {
NewAiMesh->mFaces[i].mNumIndices=3; dest->mFaces[i].mNumIndices = 3;
NewAiMesh->mFaces[i].mIndices=new unsigned int[3]; dest->mFaces[i].mIndices = new unsigned int[3];
NewAiMesh->mFaces[i].mIndices[0]=submesh.Faces[i].VertexIndices[0]; const Face &f = submesh.Faces[i];
NewAiMesh->mFaces[i].mIndices[1]=submesh.Faces[i].VertexIndices[1]; dest->mFaces[i].mIndices[0] = f.VertexIndices[0];
NewAiMesh->mFaces[i].mIndices[2]=submesh.Faces[i].VertexIndices[2]; dest->mFaces[i].mIndices[1] = f.VertexIndices[1];
dest->mFaces[i].mIndices[2] = f.VertexIndices[2];
} }
NewAiMesh->mNumFaces=submesh.Faces.size();
//Link the material: return dest;
NewAiMesh->mMaterialIndex=submesh.MaterialIndex;//the index is set by the function who called ReadSubMesh
return NewAiMesh;
} }
} // Ogre } // Ogre

215
code/OgreSkeleton.cpp
View File

@ -5,11 +5,11 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2012, assimp team Copyright (c) 2006-2012, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in aSource and binary forms,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of aSource code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
@ -254,143 +254,146 @@ void OgreImporter::ReadSkeleton(const std::string &pFile, Assimp::IOSystem *pIOH
} }
} }
void OgreImporter::CreateAssimpSkeleton(aiScene *pScene, const std::vector<Bone> &Bones, const std::vector<Animation> &/*Animations*/) void OgreImporter::CreateAssimpSkeleton(aiScene *pScene, const std::vector<Bone> &bones, const std::vector<Animation> &animations)
{ {
if(!pScene->mRootNode) if (bones.empty())
throw DeadlyImportError("No root node exists!!"); return;
if(0!=pScene->mRootNode->mNumChildren)
throw DeadlyImportError("Root Node already has childnodes!");
if (!pScene->mRootNode)
throw DeadlyImportError("Creating Assimp skeleton: No root node created!");
if (pScene->mRootNode->mNumChildren > 0)
throw DeadlyImportError("Creating Assimp skeleton: Root node already has children!");
//Createt the assimp bone hierarchy // Bones
vector<aiNode*> RootBoneNodes; vector<aiNode*> rootBones;
BOOST_FOREACH(const Bone &theBone, Bones) BOOST_FOREACH(const Bone &bone, bones)
{ {
if(-1==theBone.ParentId) //the bone is a root bone if (!bone.IsParented())
{ rootBones.push_back(CreateNodeFromBone(bone.Id, bones, pScene->mRootNode));
//which will recursily add all other nodes
RootBoneNodes.push_back(CreateAiNodeFromBone(theBone.Id, Bones, pScene->mRootNode));
}
} }
if(RootBoneNodes.size() > 0) if (!rootBones.empty())
{ {
pScene->mRootNode->mNumChildren=RootBoneNodes.size(); pScene->mRootNode->mChildren = new aiNode*[rootBones.size()];
pScene->mRootNode->mChildren=new aiNode*[RootBoneNodes.size()]; pScene->mRootNode->mNumChildren = rootBones.size();
memcpy(pScene->mRootNode->mChildren, &RootBoneNodes[0], sizeof(aiNode*)*RootBoneNodes.size());
} for(size_t i=0, len=rootBones.size(); i<len; ++i)
} pScene->mRootNode->mChildren[i] = rootBones[i];
}
void OgreImporter::PutAnimationsInScene(aiScene *pScene, const std::vector<Bone> &Bones, const std::vector<Animation> &Animations)
{
// TODO: Auf nicht vorhandene Animationskeys achten! // TODO: Auf nicht vorhandene Animationskeys achten!
// @todo Pay attention to non-existing animation Keys (google translated from above german comment) // @todo Pay attention to non-existing animation Keys (google translated from above german comment)
if(Animations.size()>0)//Maybe the model had only a skeleton and no animations. (If it also has no skeleton, this function would'nt have been called // Animations
if (!animations.empty())
{ {
pScene->mNumAnimations=Animations.size(); pScene->mAnimations = new aiAnimation*[animations.size()];
pScene->mAnimations=new aiAnimation*[Animations.size()]; pScene->mNumAnimations = animations.size();
for(unsigned int i=0; i<Animations.size(); ++i)//create all animations
for(size_t ai=0, alen=animations.size(); ai<alen; ++ai)
{ {
aiAnimation* NewAnimation=new aiAnimation(); const Animation &aSource = animations[ai];
NewAnimation->mName=Animations[i].Name;
NewAnimation->mDuration=Animations[i].Length;
NewAnimation->mTicksPerSecond=1.0f;
//Create all tracks in this animation aiAnimation *animation = new aiAnimation();
NewAnimation->mNumChannels=Animations[i].Tracks.size(); animation->mName = aSource.Name;
NewAnimation->mChannels=new aiNodeAnim*[Animations[i].Tracks.size()]; animation->mDuration = aSource.Length;
for(unsigned int j=0; j<Animations[i].Tracks.size(); ++j) animation->mTicksPerSecond = 1.0f;
// Tracks
animation->mChannels = new aiNodeAnim*[aSource.Tracks.size()];
animation->mNumChannels = aSource.Tracks.size();
for(size_t ti=0, tlen=aSource.Tracks.size(); ti<tlen; ++ti)
{ {
aiNodeAnim* NewNodeAnim=new aiNodeAnim(); const Track &tSource = aSource.Tracks[ti];
NewNodeAnim->mNodeName=Animations[i].Tracks[j].BoneName;
//we need this, to acces the bones default pose, which we need to make keys absolute to the default bone pose aiNodeAnim *animationNode = new aiNodeAnim();
vector<Bone>::const_iterator CurBone=find(Bones.begin(), Bones.end(), NewNodeAnim->mNodeName); animationNode->mNodeName = tSource.BoneName;
aiMatrix4x4 t0, t1;
aiMatrix4x4 DefBonePose=aiMatrix4x4::Translation(CurBone->Position, t1)
* aiMatrix4x4::Rotation(CurBone->RotationAngle, CurBone->RotationAxis, t0);
//Create the keyframe arrays... // We need this, to access the bones default pose.
unsigned int KeyframeCount=Animations[i].Tracks[j].Keyframes.size(); // Which we need to make keys absolute to the default bone pose.
NewNodeAnim->mNumPositionKeys=KeyframeCount; vector<Bone>::const_iterator boneIter = find(bones.begin(), bones.end(), tSource.BoneName);
NewNodeAnim->mNumRotationKeys=KeyframeCount; if (boneIter == bones.end())
NewNodeAnim->mNumScalingKeys =KeyframeCount;
NewNodeAnim->mPositionKeys=new aiVectorKey[KeyframeCount];
NewNodeAnim->mRotationKeys=new aiQuatKey[KeyframeCount];
NewNodeAnim->mScalingKeys =new aiVectorKey[KeyframeCount];
//...and fill them
for(unsigned int k=0; k<KeyframeCount; ++k)
{ {
aiMatrix4x4 t2, t3; for(unsigned int a=0; a<ai; a++)
delete pScene->mAnimations[a];
//Create a matrix to transfrom a vector from the bones default pose to the bone bones in this animation key delete [] pScene->mAnimations;
aiMatrix4x4 PoseToKey= pScene->mAnimations = NULL;
aiMatrix4x4::Translation(Animations[i].Tracks[j].Keyframes[k].Position, t3) //pos pScene->mNumAnimations = 0;
* aiMatrix4x4(Animations[i].Tracks[j].Keyframes[k].Rotation.GetMatrix()) //rot
* aiMatrix4x4::Scaling(Animations[i].Tracks[j].Keyframes[k].Scaling, t2); //scale
//calculate the complete transformation from world space to bone space
aiMatrix4x4 CompleteTransform=DefBonePose * PoseToKey;
aiVector3D Pos; DefaultLogger::get()->error("Failed to find bone for name " + tSource.BoneName + " when creating animation " + aSource.Name +
aiQuaternion Rot; ". This is a serious error, animations wont be imported.");
aiVector3D Scale; return;
CompleteTransform.Decompose(Scale, Rot, Pos);
double Time=Animations[i].Tracks[j].Keyframes[k].Time;
NewNodeAnim->mPositionKeys[k].mTime=Time;
NewNodeAnim->mPositionKeys[k].mValue=Pos;
NewNodeAnim->mRotationKeys[k].mTime=Time;
NewNodeAnim->mRotationKeys[k].mValue=Rot;
NewNodeAnim->mScalingKeys[k].mTime=Time;
NewNodeAnim->mScalingKeys[k].mValue=Scale;
} }
NewAnimation->mChannels[j]=NewNodeAnim;
}
pScene->mAnimations[i]=NewAnimation; aiMatrix4x4 t0, t1;
aiMatrix4x4 defaultBonePose = aiMatrix4x4::Translation(boneIter->Position, t1) * aiMatrix4x4::Rotation(boneIter->RotationAngle, boneIter->RotationAxis, t0);
// Keyframes
unsigned int numKeyframes = tSource.Keyframes.size();
animationNode->mPositionKeys = new aiVectorKey[numKeyframes];
animationNode->mRotationKeys = new aiQuatKey[numKeyframes];
animationNode->mScalingKeys = new aiVectorKey[numKeyframes];
animationNode->mNumPositionKeys = numKeyframes;
animationNode->mNumRotationKeys = numKeyframes;
animationNode->mNumScalingKeys = numKeyframes;
//...and fill them
for(size_t kfi=0; kfi<numKeyframes; ++kfi)
{
const KeyFrame &kfSource = tSource.Keyframes[kfi];
// Create a matrix to transform a vector from the bones
// default pose to the bone bones in this animation key
aiMatrix4x4 t2, t3;
aiMatrix4x4 keyBonePose =
aiMatrix4x4::Translation(kfSource.Position, t3) *
aiMatrix4x4(kfSource.Rotation.GetMatrix()) *
aiMatrix4x4::Scaling(kfSource.Scaling, t2);
// Calculate the complete transformation from world space to bone space
aiMatrix4x4 CompleteTransform = defaultBonePose * keyBonePose;
aiVector3D kfPos; aiQuaternion kfRot; aiVector3D kfScale;
CompleteTransform.Decompose(kfScale, kfRot, kfPos);
animationNode->mPositionKeys[kfi].mTime = static_cast<double>(kfSource.Time);
animationNode->mRotationKeys[kfi].mTime = static_cast<double>(kfSource.Time);
animationNode->mScalingKeys[kfi].mTime = static_cast<double>(kfSource.Time);
animationNode->mPositionKeys[kfi].mValue = kfPos;
animationNode->mRotationKeys[kfi].mValue = kfRot;
animationNode->mScalingKeys[kfi].mValue = kfScale;
}
animation->mChannels[ti] = animationNode;
}
pScene->mAnimations[ai] = animation;
} }
} }
} }
aiNode* OgreImporter::CreateNodeFromBone(int boneId, const std::vector<Bone> &bones, aiNode* parent)
aiNode* OgreImporter::CreateAiNodeFromBone(int BoneId, const std::vector<Bone> &Bones, aiNode* ParentNode)
{ {
//----Create the node for this bone and set its values-----
aiNode* NewNode=new aiNode(Bones[BoneId].Name);
NewNode->mParent=ParentNode;
aiMatrix4x4 t0,t1; aiMatrix4x4 t0,t1;
NewNode->mTransformation= const Bone &source = bones[boneId];
aiMatrix4x4::Translation(Bones[BoneId].Position, t0)
*aiMatrix4x4::Rotation(Bones[BoneId].RotationAngle, Bones[BoneId].RotationAxis, t1)
;
//__________________________________________________________
aiNode* boneNode = new aiNode(source.Name);
boneNode->mParent = parent;
boneNode->mTransformation = aiMatrix4x4::Translation(source.Position, t0) * aiMatrix4x4::Rotation(source.RotationAngle, source.RotationAxis, t1);
//---------- recursivly create all children Nodes: ---------- if (!source.Children.empty())
NewNode->mNumChildren=Bones[BoneId].Children.size();
NewNode->mChildren=new aiNode*[Bones[BoneId].Children.size()];
for(unsigned int i=0; i<Bones[BoneId].Children.size(); ++i)
{ {
NewNode->mChildren[i]=CreateAiNodeFromBone(Bones[BoneId].Children[i], Bones, NewNode); boneNode->mChildren = new aiNode*[source.Children.size()];
boneNode->mNumChildren = source.Children.size();
for(size_t i=0, len=source.Children.size(); i<len; ++i)
boneNode->mChildren[i] = CreateNodeFromBone(source.Children[i], bones, boneNode);
} }
//____________________________________________________
return boneNode;
return NewNode;
} }
void Bone::CalculateBoneToWorldSpaceMatrix(vector<Bone> &Bones) void Bone::CalculateBoneToWorldSpaceMatrix(vector<Bone> &Bones)
{ {
aiMatrix4x4 t0, t1; aiMatrix4x4 t0, t1;

2
include/assimp/config.h
View File

@ -809,7 +809,7 @@ enum aiComponent
* order: <material-name>.material, <mesh-filename-base>.material and * order: <material-name>.material, <mesh-filename-base>.material and
* lastly the material name defined by this config property. * lastly the material name defined by this config property.
* <br> * <br>
* Property type: String. Default value: n/a. * Property type: String. Default value: Scene.material.
*/ */
#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \ #define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \
"IMPORT_OGRE_MATERIAL_FILE" "IMPORT_OGRE_MATERIAL_FILE"