void readKeys(FbxAnimCurve* curveX, FbxAnimCurve* curveY, FbxAnimCurve* curveZ,
const FbxDouble3& defaultValue,
std::vector<osgAnimation::TemplateKeyframe<osg::Vec3> >& keyFrameCntr, float scalar = 1.0f)
{
FbxAnimCurve* curves[3] = {curveX, curveY, curveZ};
typedef std::set<double> TimeSet;
typedef std::map<double, float> TimeFloatMap;
TimeSet times;
TimeFloatMap curveTimeMap[3];
for (int nCurve = 0; nCurve < 3; ++nCurve)
{
FbxAnimCurve* pCurve = curves[nCurve];
int nKeys = pCurve ? pCurve->KeyGetCount() : 0;
if (!nKeys)
{
times.insert(0.0);
curveTimeMap[nCurve][0.0] = defaultValue[nCurve] * scalar;
}
for (int i = 0; i < nKeys; ++i)
{
FbxAnimCurveKey key = pCurve->KeyGet(i);
double fTime = key.GetTime().GetSecondDouble();
times.insert(fTime);
curveTimeMap[nCurve][fTime] = static_cast<float>(key.GetValue()) * scalar;
}
}
for (TimeSet::iterator it = times.begin(); it != times.end(); ++it)
{
double fTime = *it;
osg::Vec3 val;
for (int i = 0; i < 3; ++i)
{
if (curveTimeMap[i].empty()) continue;
TimeFloatMap::iterator lb = curveTimeMap[i].lower_bound(fTime);
if (lb == curveTimeMap[i].end()) --lb;
val[i] = lb->second;
}
keyFrameCntr.push_back(osgAnimation::Vec3Keyframe(fTime, val));
}
}
void FBXConverter::processAnimations( FbxNode* node , std::vector<JointData> &skeleton , std::vector<VertexData> &verts , std::vector<IndexData> &indices )
{
FbxMesh* theMesh = node->GetMesh();
FbxAnimStack* animationStack = node->GetScene()->GetSrcObject<FbxAnimStack>();
FbxAnimLayer* animationLayer = animationStack->GetMember<FbxAnimLayer>();
std::vector<FbxTime> frames;
for ( int curveNodeIndex = 0; curveNodeIndex < animationLayer->GetMemberCount(); ++curveNodeIndex )
{
FbxAnimCurveNode* currentCurve = animationLayer->GetMember<FbxAnimCurveNode>( curveNodeIndex );
for ( unsigned int channelIndex = 0; channelIndex < currentCurve->GetChannelsCount(); ++channelIndex )
{
for ( int curve = 0; curve < currentCurve->GetCurveCount( channelIndex ); ++curve )
{
FbxAnimCurve* theCurveVictim = currentCurve->GetCurve( channelIndex , curve );
for ( int keyIndex = 0; keyIndex < theCurveVictim->KeyGetCount(); ++keyIndex )
{
bool alreadyIn = false;
for ( unsigned int frameIndex = 0; frameIndex < frames.size(); ++frameIndex )
{
if ( ( unsigned int ) frames[frameIndex].GetFrameCount() == ( unsigned int ) theCurveVictim->KeyGet( keyIndex ).GetTime().GetFrameCount() )
{
alreadyIn = true;
//std::cout << frames[frameIndex].GetFrameCount() << " " << theCurveVictim->KeyGet( keyIndex ).GetTime().GetFrameCount() << " " << alreadyIn << std::endl;
break;
}
}
std::cout << theCurveVictim->KeyGet( keyIndex ).GetTime().GetFrameCount() << " " << alreadyIn << std::endl;
if(!alreadyIn) frames.push_back(theCurveVictim->KeyGet( keyIndex ).GetTime());
}
}
}
}
std::sort( frames.begin() , frames.end() , frameCompare );
FbxAMatrix geoTransform( node->GetGeometricTranslation( FbxNode::eSourcePivot ) , node->GetGeometricRotation( FbxNode::eSourcePivot ) , node->GetGeometricScaling( FbxNode::eSourcePivot ) );
for ( int i = 0; i < theMesh->GetDeformerCount(); ++i )
{
FbxSkin* theSkin = reinterpret_cast< FbxSkin* >( theMesh->GetDeformer( i , FbxDeformer::eSkin ) );
if ( !theSkin ) continue;
for ( int j = 0; j < theSkin->GetClusterCount(); ++j )
{
FbxCluster* cluster = theSkin->GetCluster( j );
std::string jointName = cluster->GetLink()->GetName();
int currentJointIndex = -1;
for ( unsigned int k = 0; k < skeleton.size(); ++k )
{
if ( !skeleton[k].name.compare( jointName ) )
{
currentJointIndex = k;
break;
}
}
if ( currentJointIndex < 0 )
{
std::cout << "wrong bone" << std::endl;
continue;
}
FbxAMatrix transformMatrix, transformLinkMatrix, offsetMatrix;
cluster->GetTransformMatrix( transformMatrix );
cluster->GetTransformLinkMatrix( transformLinkMatrix );
//offsetMatrix = transformLinkMatrix.Inverse() * transformMatrix * geoTransform;
FbxMatrix realMatrix( transformLinkMatrix.Inverse() * transformMatrix );
for ( unsigned int row = 0; row < 4; ++row )
{
for ( unsigned int column = 0; column < 4; ++column )
{
skeleton[currentJointIndex].offsetMatrix[row][column] = (float)realMatrix.Get( row , column );
}
}
for ( int k = 0; k < cluster->GetControlPointIndicesCount(); ++k )
{
BlendingIndexWeightPair weightPair;
weightPair.blendingIndex = currentJointIndex;
weightPair.blendingWeight = (float)cluster->GetControlPointWeights()[k];
unsigned int controlPoint = cluster->GetControlPointIndices()[k];
for ( unsigned int z = 0; z < indices.size(); ++z )
{
if ( indices[z].oldControlPoint == controlPoint )
{
if ( verts[indices[z].index].blendingInfo.size() > 4 )
{
std::cout << "Warning: vert has more than 4 bones connected, ignoring additional bone." << std::endl;
}
//else verts[indices[z].index].blendingInfo.push_back( weightPair );
bool found = false;
for ( unsigned int omg = 0; omg < verts[indices[z].index].blendingInfo.size(); ++omg )
{
if ( verts[indices[z].index].blendingInfo[omg].blendingIndex == weightPair.blendingIndex )
{
found = true;
break;
}
}
if ( !found ) verts[indices[z].index].blendingInfo.push_back( weightPair );
}
}
}
for ( unsigned int frameIndex = 0; frameIndex < frames.size(); ++frameIndex )
{
FbxVector4 translation = cluster->GetLink()->EvaluateLocalTranslation( frames[frameIndex] );
FbxVector4 rotation = cluster->GetLink()->EvaluateLocalRotation( frames[frameIndex] );
FbxVector4 scale = cluster->GetLink()->EvaluateLocalScaling( frames[frameIndex] );
AnimationData animData;
animData.frame = (int)frames[frameIndex].GetFrameCount();
animData.translation = glm::vec3(translation[0],translation[1],translation[2]);
animData.rotation = glm::angleAxis( glm::radians( (float)rotation[2] ), glm::vec3(0,0,1)) * glm::angleAxis(glm::radians((float) rotation[1]), glm::vec3(0,1,0)) * glm::angleAxis(glm::radians((float)rotation[0]), glm::vec3(1,0,0));
animData.scale = glm::vec3(scale[0],scale[1],scale[2]);
skeleton[currentJointIndex].animation.push_back( animData );
}
}
}
}
int main(int argc, char **argv)
{
#ifndef _DEBUG
if (argc != 2)
{
printf("invalid arg");
return 0;
}
const char* filename = argv[1];
#else
const char* filename = "*****@*****.**";
#endif
output.open("output.txt", ios::out | ios::trunc);
output2.open("output2.txt", ios::out | ios::trunc);
output3.open("output3.txt", ios::out | ios::trunc);
if (!output.is_open())
{
exit(1);
}
FbxManager* fm = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create(fm, IOSROOT);
//ios->SetBoolProp(EXP_FBX_ANIMATION, false);
ios->SetIntProp(EXP_FBX_COMPRESS_LEVEL, 9);
ios->SetAllObjectFlags(true);
fm->SetIOSettings(ios);
FbxImporter* importer = FbxImporter::Create(fm, "");
if (!importer->Initialize(filename, -1, fm->GetIOSettings()))
{
printf("error returned : %s\n", importer->GetStatus().GetErrorString());
exit(-1);
}
FbxScene* scene = FbxScene::Create(fm, "myscene");
importer->Import(scene);
importer->Destroy();
output << "some\n";
output << "charcnt : " << scene->GetCharacterCount() << endl << "node cnt : " << scene->GetNodeCount() << endl;
int animstackcnt = scene->GetSrcObjectCount<FbxAnimStack>();
output << "animstackcnt : " << animstackcnt << endl;
output << "------------" << endl;
vector<FbxNode*> removableNodes;
for (int i = 0; i < scene->GetNodeCount(); i++)
{
FbxNode* node = scene->GetNode(i);
output << "scene's node " << i << " : " << node->GetName() << ", childcnt : " << node->GetChildCount();
if (node->GetNodeAttribute())
{
output <<", att type : " << node->GetNodeAttribute()->GetAttributeType();
if (node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::EType::eMesh)
{
FbxMesh* mesh = node->GetMesh();
output << ", mem usage : " << mesh->MemoryUsage() << ", deformer cnt : " << mesh->GetDeformerCount(FbxDeformer::EDeformerType::eSkin) << endl;
collapseMesh(mesh);
FbxSkin* skin = (FbxSkin*) (mesh->GetDeformer(0, FbxDeformer::EDeformerType::eSkin));
if (skin)
{
for (int cli = 0; cli < skin->GetClusterCount(); cli++)
{
FbxCluster* cluster = skin->GetCluster(cli);
output << "\tcluster no." << cli << " has " << cluster->GetControlPointIndicesCount() << " connected verts" << endl;
if (cluster->GetControlPointIndicesCount() == 0)
removableNodes.push_back( cluster->GetLink() );
//cluster->
//skin->RemoveCluster(cluster);효과없음
}
}
if (mesh->IsTriangleMesh())
{
output << "\tit's triangle mesh" << endl;
}
//mesh->RemoveDeformer(0);효과없음
}
else
output << endl;
}
else
{
output << ", att type : none" << endl;
}
}
for (int rni = 0; rni < removableNodes.size(); rni++)
{
FbxNode* rnd = removableNodes[rni];
if (rnd && rnd->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::EType::eSkeleton)
{
output3 << rnd->GetName() << " node with no vert attached's curve : " << rnd->GetSrcObjectCount<FbxAnimCurve>() << "," << rnd->GetSrcObjectCount<FbxAnimCurveNode>() << endl;
}
}
output << "-----------animinfo" << endl;
int cubic = 0, linear = 0, cons = 0;
for (int si = 0; si < animstackcnt; si++)
{
FbxAnimStack* stack = scene->GetSrcObject<FbxAnimStack>(si);
for (int i = 0; i < stack->GetMemberCount<FbxAnimLayer>(); i++)
{
FbxAnimLayer* layer = stack->GetMember<FbxAnimLayer>(i);
int curvenodecnt = layer->GetMemberCount<FbxAnimCurveNode>();
int compositcnt = 0;
for (int j = 0; j < curvenodecnt; j++)
{
FbxAnimCurveNode* cnode = layer->GetMember<FbxAnimCurveNode>(j);
compositcnt += (cnode->IsComposite() ? 1 : 0);
}
output << "\tanimstack's layer " << i << " : " << layer->GetName() << ", curve node cnt : " << curvenodecnt << ", composit node cnt : " << compositcnt << endl;
vector<FbxAnimCurveNode*> nodes2del;
for (int j = 0; j < curvenodecnt; j++)
{
FbxAnimCurveNode* cnode = layer->GetMember<FbxAnimCurveNode>(j);
output << "\t\tcurvenode " << j << " channel cnt : " << cnode->GetChannelsCount() << ", dst obj cnt " << cnode->GetDstObjectCount() << "(";
for (int dsti = 0; dsti < cnode->GetDstObjectCount(); dsti++)
{
output << "," << cnode->GetDstObject(dsti)->GetName();
if (cnode->GetDstObject(dsti)->GetSrcObjectCount() > 0)
output << "<" << cnode->GetDstObject(dsti)->GetSrcObjectCount<FbxSkeleton>() << ">";
}
output << ")";
FbxTimeSpan interval;
if (cnode->GetAnimationInterval(interval))
{
output << ", start : " << interval.GetStart().GetTimeString() << ", end : " << interval.GetStop().GetTimeString() << endl;
}
else
{
nodes2del.push_back(cnode);
output << ", no interval" << endl;
}
for (int chi = 0; chi < cnode->GetChannelsCount(); chi++)
{
int curvecnt = cnode->GetCurveCount(chi);
output << "\t\t\tchannel." << chi << " curvecnt : " << curvecnt << endl;
for (int ci = 0; ci < curvecnt; ci++)
{
FbxAnimCurve* curve = cnode->GetCurve(chi, ci);
int keycnt = curve->KeyGetCount();
output << "\t\t\t\tcurve no." << ci << " : key count : " << keycnt;
output2 << "curve " << ci << endl;
vector<int> keys2Remove;
for (int cki = 0; cki < keycnt; cki++)
{
FbxAnimCurveKey prevkey, currkey, nextkey;
if (cki == 0 || cki == keycnt - 1)
continue;
currkey = curve->KeyGet(cki);
prevkey = curve->KeyGet(cki-1);
nextkey = curve->KeyGet(cki + 1);
bool keepit = true;
output2 << ci << "-" << cki;
// keepit = keepTestHorizon(curve, prevkey, currkey, nextkey);
// if (keepit)
// keepit = slopkeepTest(curve, prevkey, currkey, nextkey);
if (!keepit)
{
if (!(currkey.GetInterpolation() == FbxAnimCurveDef::EInterpolationType::eInterpolationConstant && nextkey.GetInterpolation() != FbxAnimCurveDef::EInterpolationType::eInterpolationConstant))
keys2Remove.push_back(cki);
}
}
for (int kri = keys2Remove.size() - 1; kri >= 0; kri--)
{
//curve->KeyRemove(keys2Remove[kri]);
}
output2 << endl;
//output << ", cubic:linear:const : " << cubic << ":" << linear << ":" << cons << endl;
if (keys2Remove.size() > 0)
output << ", " << keys2Remove.size() << " keys removed";
keycnt = curve->KeyGetCount();
}
}
}
//이부분은 별로 효과없음
/*
for (int di = 0; di < nodes2del.size(); di++)
{
layer->RemoveMember(nodes2del[di]);
}
*/
}
}
output << "cubic:linear:const " << cubic << ":" << linear << ":" << cons << endl;
FbxExporter* exporter = FbxExporter::Create(fm, "");
const char* outFBXName = "after.fbx";
bool exportstatus = exporter->Initialize(outFBXName, -1, fm->GetIOSettings());
if (exportstatus == false)
{
puts("err export fail");
}
exporter->Export(scene);
exporter->Destroy();
scene->Destroy();
ios->Destroy();
fm->Destroy();
output.close();
output2.close();
output3.close();
return 0;
}
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));
}
}
void readFbxRotationAnimation(osgAnimation::Channel* channels[3],
FbxNode* pNode,
FbxAnimLayer* pAnimLayer, const char* targetName)
{
if (!pNode->LclRotation.IsValid())
{
return;
}
EFbxRotationOrder rotOrder = pNode->RotationOrder.IsValid() ? pNode->RotationOrder.Get() : eEulerXYZ;
if (pNode->QuaternionInterpolate.IsValid() && pNode->QuaternionInterpolate.Get())
{
channels[0] = readFbxChannelsQuat(
pNode->LclRotation.GetCurve(pAnimLayer, FBXSDK_CURVENODE_COMPONENT_X),
pNode->LclRotation.GetCurve(pAnimLayer, FBXSDK_CURVENODE_COMPONENT_Y),
pNode->LclRotation.GetCurve(pAnimLayer, FBXSDK_CURVENODE_COMPONENT_Z),
pNode->LclRotation.Get(),
targetName, rotOrder);
}
else
{
const char* curveNames[3] = {FBXSDK_CURVENODE_COMPONENT_X, FBXSDK_CURVENODE_COMPONENT_Y, FBXSDK_CURVENODE_COMPONENT_Z};
FbxDouble3 fbxPropValue = pNode->LclRotation.Get();
fbxPropValue[0] = osg::DegreesToRadians(fbxPropValue[0]);
fbxPropValue[1] = osg::DegreesToRadians(fbxPropValue[1]);
fbxPropValue[2] = osg::DegreesToRadians(fbxPropValue[2]);
for (int i = 0; i < 3; ++i)
{
FbxAnimCurve* curve = pNode->LclRotation.GetCurve(pAnimLayer, curveNames[i]);
if (!curve)
{
continue;
}
FbxAnimCurveDef::EInterpolationType interpolationType = FbxAnimCurveDef::eInterpolationConstant;
if (curve && curve->KeyGetCount()) interpolationType = curve->KeyGetInterpolation(0);
if (interpolationType == FbxAnimCurveDef::eInterpolationCubic)
{
osgAnimation::FloatCubicBezierKeyframeContainer* pKeyFrameCntr = new osgAnimation::FloatCubicBezierKeyframeContainer;
for (int j = 0; j < curve->KeyGetCount(); ++j)
{
double fTime = curve->KeyGetTime(j).GetSecondDouble();
float angle = curve->KeyGetValue(j);
//FbxAnimCurveDef::EWeightedMode tangentWeightMode = curve->KeyGet(j).GetTangentWeightMode();
FbxAnimCurveTangentInfo leftTangent = curve->KeyGetLeftDerivativeInfo(j);
FbxAnimCurveTangentInfo rightTangent = curve->KeyGetRightDerivativeInfo(j);
if (j > 0)
{
leftTangent.mDerivative *= fTime - curve->KeyGetTime(j - 1).GetSecondDouble();
}
if (j + 1 < curve->KeyGetCount())
{
rightTangent.mDerivative *= curve->KeyGetTime(j + 1).GetSecondDouble() - fTime;
}
osgAnimation::FloatCubicBezier key(
osg::DegreesToRadians(angle),
osg::DegreesToRadians(angle - leftTangent.mDerivative / 3.0),
osg::DegreesToRadians(angle + rightTangent.mDerivative / 3.0));
pKeyFrameCntr->push_back(osgAnimation::FloatCubicBezierKeyframe(
fTime,
key));
}
reorderControlPoints(*pKeyFrameCntr);
osgAnimation::FloatCubicBezierChannel* pCubicChannel = new osgAnimation::FloatCubicBezierChannel;
pCubicChannel->getOrCreateSampler()->setKeyframeContainer(pKeyFrameCntr);
channels[i] = pCubicChannel;
}
else
{
osgAnimation::FloatKeyframeContainer* keys = new osgAnimation::FloatKeyframeContainer;
for (int j = 0; j < curve->KeyGetCount(); ++j)
{
FbxAnimCurveKey key = curve->KeyGet(j);
keys->push_back(osgAnimation::FloatKeyframe(
key.GetTime().GetSecondDouble(),
static_cast<float>(osg::DegreesToRadians(key.GetValue()))));
}
if (interpolationType == FbxAnimCurveDef::eInterpolationConstant)
{
osgAnimation::FloatStepChannel* pStepChannel = new osgAnimation::FloatStepChannel();
pStepChannel->getOrCreateSampler()->setKeyframeContainer(keys);
channels[i] = pStepChannel;
}
else
{
osgAnimation::FloatLinearChannel* pLinearChannel = new osgAnimation::FloatLinearChannel();
pLinearChannel->getOrCreateSampler()->setKeyframeContainer(keys);
channels[i] = pLinearChannel;
}
}
channels[i]->setTargetName(targetName);
channels[i]->setName(std::string("rotate") + curveNames[i]);
}
}
}
