MCE::FBX::TimeRange FilmboxNode::GetAnimationTimeRange() const
{
TimeRange animation_range;
if( m_node )
{
KFbxScene* fbx_scene = m_node->GetScene();
FBX_ASSERT( fbx_scene->GetSrcObjectCount( FBX_TYPE( KFbxAnimStack ) ) == 0, "Multiple animation stacks are not supported!" );
KFbxAnimStack* anim_stack = fbx_scene->GetSrcObject( FBX_TYPE( KFbxAnimStack ), 0 );
if( anim_stack )
{
const char* anim_name = anim_stack->GetName();
KTimeSpan anim_timespan = anim_stack->GetLocalTimeSpan();
KTime anim_start = anim_timespan.GetStart();
KTime anim_stop = anim_timespan.GetStop();
animation_range.StartFrame = (int)( anim_start.GetFrame( true ) );
animation_range.EndFrame = (int)( anim_stop.GetFrame( true ) );
}
}
return animation_range;
}
void Model::SetAnimationStack( int index ) {
KFbxAnimStack *current_stack = scene->FindMember( FBX_TYPE(KFbxAnimStack), AnimationStackNames[index]->Buffer() );
CurrentAnimationLayer = current_stack->GetMember( FBX_TYPE(KFbxAnimLayer), 0 );
// set the animation evaluator context (or something)
scene->GetEvaluator()->SetContext( current_stack );
// god knows what this does
KFbxTakeInfo *current_take_info = scene->GetTakeInfo( *(AnimationStackNames[index]) );
if( current_take_info ) {
AnimationStartTime = current_take_info->mLocalTimeSpan.GetStart();
AnimationStopTime = current_take_info->mLocalTimeSpan.GetStop();
} else {
KTimeSpan timespan;
scene->GetGlobalSettings().GetTimelineDefaultTimeSpan( timespan );
AnimationStartTime = timespan.GetStart();
AnimationStopTime = timespan.GetStop();
}
/////////
AnimationStartTime.SetTime(0, 0, 0, 10, 0, scene->GetGlobalSettings().GetTimeMode());
AnimationStopTime.SetTime(0, 0, 0, 50, 0, scene->GetGlobalSettings().GetTimeMode());
//////////////
AnimationCurrentTime = AnimationStartTime;
}
std::string readFbxAnimation(KFbxNode* pNode,
KFbxScene& fbxScene,
osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimManager,
const char* targetName)
{
std::string result;
for (int i = 0; i < fbxScene.GetSrcObjectCount(FBX_TYPE(KFbxAnimStack)); ++i)
{
KFbxAnimStack* pAnimStack = KFbxCast<KFbxAnimStack>(fbxScene.GetSrcObject(FBX_TYPE(KFbxAnimStack), i));
int nbAnimLayers = pAnimStack->GetMemberCount(FBX_TYPE(KFbxAnimLayer));
const char* pTakeName = pAnimStack->GetName();
if (!pTakeName || !*pTakeName)
continue;
for (int j = 0; j < nbAnimLayers; j++)
{
KFbxAnimLayer* pAnimLayer = pAnimStack->GetMember(FBX_TYPE(KFbxAnimLayer), j);
if (osgAnimation::Animation* pAnimation = readFbxAnimation(
pNode, pAnimLayer, pTakeName, targetName, pAnimManager))
{
result = targetName;
}
}
}
return result;
}
void readAnimation(KFbxNode* pNode, KFbxScene& fbxScene, const std::string& targetName,
osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimationManager,
KFbxMesh* pMesh, int nBlendShape, int nBlendShapeChannel, int nShape)
{
for (int i = 0; i < fbxScene.GetSrcObjectCount(FBX_TYPE(KFbxAnimStack)); ++i)
{
KFbxAnimStack* pAnimStack = KFbxCast<KFbxAnimStack>(fbxScene.GetSrcObject(FBX_TYPE(KFbxAnimStack), i));
int nbAnimLayers = pAnimStack->GetMemberCount(FBX_TYPE(KFbxAnimLayer));
const char* pTakeName = pAnimStack->GetName();
if (!pTakeName || !*pTakeName)
continue;
for (int j = 0; j < nbAnimLayers; j++)
{
KFbxAnimLayer* pAnimLayer = pAnimStack->GetMember(FBX_TYPE(KFbxAnimLayer), j);
KFbxAnimCurve* pCurve = pMesh->GetShapeChannel(nBlendShape, nBlendShapeChannel, pAnimLayer, false);
if (!pCurve)
{
continue;
}
int nKeys = pCurve->KeyGetCount();
if (!nKeys)
{
continue;
}
osgAnimation::FloatLinearChannel* pChannel = new osgAnimation::FloatLinearChannel;
std::vector<osgAnimation::TemplateKeyframe<float> >& keyFrameCntr = *pChannel->getOrCreateSampler()->getOrCreateKeyframeContainer();
for (int k = 0; k < nKeys; ++k)
{
KFbxAnimCurveKey key = pCurve->KeyGet(k);
double fTime = key.GetTime().GetSecondDouble();
float fValue = static_cast<float>(key.GetValue() * 0.01);
keyFrameCntr.push_back(osgAnimation::FloatKeyframe(fTime,fValue));
}
pChannel->setTargetName(targetName);
std::stringstream ss;
ss << nShape;
pChannel->setName(ss.str());
addChannel(pChannel, pAnimationManager, pTakeName);
}
}
}
void FBXModel::load(const GraphicsDevice& device, const std::string& filename, unsigned keyframes)
{
if (effect.resource == 0)
effect = Effect::createFromFile<FBXEffect>(device, Config::getValue(ConfigKeys::fbxEffectPath));
defaultTexture = Texture::createFromFile(device, defaultTexturePath);
vertexDeclaration = device.createVertexDeclaration(FBXInstance::vertexElements);
KFbxSdkManager* sdkManager = KFbxSdkManager::Create();
KFbxIOSettings* ios = KFbxIOSettings::Create(sdkManager, IOSROOT);
sdkManager->SetIOSettings(ios);
// Create an importer using our sdk manager.
KFbxImporter* importer = KFbxImporter::Create(sdkManager, "");
importer->Initialize(filename.c_str(), -1, sdkManager->GetIOSettings());
// Create a new scene so it can be populated by the imported file.
KFbxScene* scene = KFbxScene::Create(sdkManager, "");
// Import the contents of the file into the scene.
importer->Import(scene);
KFbxNode* rootBone = 0;
KFbxNode* rootNode = scene->GetRootNode();
KFbxAnimStack* animStack = KFbxCast<KFbxAnimStack>(scene->GetSrcObject(FBX_TYPE(KFbxAnimStack), 0));
KFbxAnimLayer* animLayer = 0;
if (animStack)
{
animLayer = animStack->GetMember(FBX_TYPE(KFbxAnimLayer), 0);
scene->GetEvaluator()->SetContext(animStack);
}
loadBones(rootNode, &rootBone, animLayer);
loadMeshes(rootNode, device, KFbxGeometryConverter(sdkManager));
if (animLayer)
{
for (unsigned i = 0; i <= keyframes; ++i)
boneMatricesMap[i] = traverseBones(i, rootBone, Matrix::identity, MatrixCollection(bones.size()));
}
sdkManager->Destroy();
loaded = true;
}
void fbxLoader2::readAnimationTakeData(FbxNode* node)
{
FbxAnimStack* pAnimStack = FbxCast<FbxAnimStack>(scene->GetSrcObject(FBX_TYPE(FbxAnimStack)));
FbxAnimLayer* pAnimLayer = pAnimStack->GetMember(FBX_TYPE(FbxAnimLayer));
FbxAnimCurve* animCv = node->LclTranslation.GetCurve(pAnimLayer, FBXSDK_CURVENODE_COMPONENT_X);
FbxTimeSpan length = FbxTimeSpan();
int p = animCv->KeyGetCount();
const char* nameAnim = animCv->GetName();
const size_t len = strlen(nameAnim);
char * new_name = new char[len + 1];
strncpy(new_name, nameAnim, len);
animCv->GetTimeInterval(length);
FbxTime duration = length.GetDuration();
FbxTime::EMode mode = duration.GetGlobalTimeMode();
double frameRate = duration.GetFrameRate(mode);
double startt = length.GetStart().GetMilliSeconds();
double endt = length.GetStop().GetMilliSeconds();
int frames = animCv->KeyGetCount();
animationStructure = new AnimationData(new_name, startt, endt, (int)frameRate, frames);
for (int i = 0; i< frames; i++)
{
SkeletalData *sk = new SkeletalData();
for(int j = 0; j<skeleton->GetBonesCount(); j++)
{
BoneData *bonecopy = new BoneData();
bonecopy->SetID(skeleton->GetBone(j)->GetID());
bonecopy->SetName(skeleton->GetBone(j)->GetName());
bonecopy->SetParent(skeleton->GetBone(j)->GetParent());
sk->SetBones(bonecopy);
}
animationStructure->SetSkeleton(sk, i);
}
}
FBXModel::MaterialCollection FBXModel::getMaterials(const GraphicsDevice& device, KFbxNode* node)
{
MaterialCollection materials;
for (int i = 0; i < node->GetMaterialCount(); ++i)
{
FBXMaterial material;
KFbxSurfaceMaterial* surfaceMaterial = node->GetMaterial(i);
KFbxProperty prop = surfaceMaterial->FindProperty(KFbxSurfaceMaterial::sDiffuse);
if (prop.IsValid())
{
int textureCount = prop.GetSrcObjectCount(KFbxFileTexture::ClassId);
if (textureCount)
{
KFbxFileTexture* fbxTexture = prop.GetSrcObject(FBX_TYPE(KFbxFileTexture), 0);
if (fbxTexture)
material.texture = Texture::createFromFile(device, fbxTexture->GetFileName());
}
}
if (!material.texture)
material.texture = defaultTexture;
if (surfaceMaterial->GetClassId().Is(KFbxSurfacePhong::ClassId))
{
Material& mat = material.material;
KFbxSurfacePhong* phong = (KFbxSurfacePhong*)surfaceMaterial;
mat.Ambient = convert(phong->Diffuse.Get());
mat.Diffuse = mat.Ambient;
mat.Specular = convert(phong->Specular.Get());
mat.Emissive = convert(phong->Emissive.Get());
mat.Power = (float)phong->SpecularFactor.Get();
}
materials.push_back(material);
}
return materials;
}
void ShadingManager::Initialize(const KFbxNode* pNode)
{
if (!pNode)
return;
if (pNode->GetNodeAttribute())
{
const int lMaterialCount = pNode->GetMaterialCount();
for (int lMaterialIndex = 0; lMaterialIndex < lMaterialCount; ++lMaterialIndex)
{
const KFbxSurfaceMaterial * lMaterial = pNode->GetMaterial(lMaterialIndex);
if (lMaterial)
{
const KFbxProperty lProperty = lMaterial->FindProperty(KFbxSurfaceMaterial::sDiffuse);
if (lProperty.IsValid())
{
const int lTextureCount = lProperty.GetSrcObjectCount(KFbxFileTexture::ClassId);
if (lTextureCount)
{
const KFbxFileTexture* lTexture = lProperty.GetSrcObject(FBX_TYPE(KFbxFileTexture), 0);
if (lTexture)
{
unsigned int lTextureObject;
mTextureManager->LoadTexture(lTexture, &lTextureObject);
mTextureObjectsForMaterial.Insert(lMaterial, lTextureObject);
}
}
}
}
}
}
const int lChildCount = pNode->GetChildCount();
for (int lChildIndex = 0; lChildIndex < lChildCount; ++lChildIndex)
{
Initialize(pNode->GetChild(lChildIndex));
}
}
void fbxLoader2::processMesh(FbxNode* node)
{
FbxMesh* mesh = node->GetMesh();
this->readAnimationWeigths(mesh);
if(mesh!=NULL && mesh->IsTriangleMesh())
{
for (int i = 0; i<mesh->GetControlPointsCount(); i++)
{
readVertex(mesh, i, &vertex[i]);
vertexArray[i].position = D3DXVECTOR3(vertex[i]);
}
int a = mesh->GetPolygonVertexCount();
for (int i = 0; i<mesh->GetPolygonVertexCount(); i++)
{
readUV(mesh, i, 0, &uv[i]);
readNormal(mesh, i, &normal[i]);
indices[i].indice = mesh->GetPolygonVertices()[i];
indices[i].normal1 = normal[i];
indices[i].uv1 = uv[i];
indicesMeshCount++;
}
}
//vertexLists.push_back(vertexArray);
indiceLists.push_back(indices);
FbxAnimStack* pAnimStack = FbxCast<FbxAnimStack>(scene->GetSrcObject(FBX_TYPE(FbxAnimStack)));
int numAnimLayers = pAnimStack->GetMemberCount(FBX_TYPE(FbxAnimLayer));
this->setBindPoseCluster(node);
for (int i = 0; i < numAnimLayers; i++)
{
FbxAnimLayer* pAnimLayer = pAnimStack->GetMember(FBX_TYPE(FbxAnimLayer), i);
FbxAnimCurve* animCv = this->findSkeletonRootBone(scene->GetRootNode())->GetChild(0)->LclTranslation.GetCurve(pAnimLayer, FBXSDK_CURVENODE_COMPONENT_X);
if (animCv)
{
FbxTimeSpan animationLength;
int p = animCv->KeyGetCount();
animCv->GetTimeInterval(animationLength);
for(int j = 0; j<animationStructure->GetFramesNumber();j++)
{
FbxTime timeKey = animCv->KeyGet(j).mTime;
//FbxTime interval = (duration/p)*j + animationLength.GetStart();
//int intervalVal = (duration.GetSecondCount()/p)*j + animationLength.GetStart().GetSecondCount();
const FbxTime pTime = animCv->KeyGet(j).mTime;
FbxAMatrix pGlobalPos = GetGlobalPosition(node, pTime, scene->GetPose(j));
ComputeSkinDeformation(pGlobalPos, mesh, timeKey, scene->GetPose(j), j);
}
}
}
for(int i = 0; i<node->GetChildCount(); i++)
{
processMesh(node->GetChild(i));
}
}
