UObject* UFbxFactory::ImportANode(void* VoidFbxImporter, void* VoidNode, UObject* InParent, FName InName, EObjectFlags Flags, int32& NodeIndex, int32 Total, UObject* InMesh, int LODIndex) { UnFbx::FFbxImporter* FFbxImporter = (UnFbx::FFbxImporter*)VoidFbxImporter; FbxNode* Node = (FbxNode*)VoidNode; UObject* NewObject = NULL; FName OutputName = FFbxImporter->MakeNameForMesh(InName.ToString(), Node); { // skip collision models FbxString NodeName(Node->GetName()); if ( NodeName.Find("UCX") != -1 || NodeName.Find("MCDCX") != -1 || NodeName.Find("UBX") != -1 || NodeName.Find("USP") != -1 ) { return NULL; } NewObject = FFbxImporter->ImportStaticMesh( InParent, Node, OutputName, Flags, ImportUI->StaticMeshImportData, Cast<UStaticMesh>(InMesh), LODIndex ); } if (NewObject) { NodeIndex++; FFormatNamedArguments Args; Args.Add( TEXT("NodeIndex"), NodeIndex ); Args.Add( TEXT("ArrayLength"), Total ); GWarn->StatusUpdate( NodeIndex, Total, FText::Format( NSLOCTEXT("UnrealEd", "Importingf", "Importing ({NodeIndex} of {ArrayLength})"), Args ) ); } return NewObject; }
void fbxLoader2::buildSkeletonCycle(FbxNode* boneNode, int parentBoneIndex) { BoneData* bone1 = new BoneData(); FbxNodeAttribute * attrib = boneNode->GetNodeAttribute(); if(((FbxSkeleton*) attrib)->GetSkeletonType() == FbxSkeleton::eLimbNode) { bone1->SetName(boneNode->GetName()); bone1->SetID(skeleton->GetBonesCount()); bone1->SetParent(parentBoneIndex); skeleton->SetBones(bone1); } int childCount = boneNode->GetChildCount(); for( int childIndex = 0; childIndex < childCount; ++childIndex ) { FbxNode* childNode = boneNode->GetChild( childIndex ); std::string s2("Nub"); std::string s3 ("Footsteps"); std::string s1(childNode->GetName()); int found = s1.find(s2); int found2 = s1.find(s3); if (found == std::string::npos && found2 == std::string::npos) { buildSkeletonCycle(childNode, bone1->GetID()); } } }
void FBXSceneEncoder::loadBindShapes(FbxScene* fbxScene) { float m[16]; const int poseCount = fbxScene->GetPoseCount(); for (int i = 0; i < poseCount; ++i) { FbxPose* pose = fbxScene->GetPose(i); assert(pose); if (pose->IsBindPose() && pose->GetCount() > 0) { FbxNode* fbxNode = pose->GetNode(0); if (fbxNode->GetMesh() != NULL) { Node* node = _gamePlayFile.getNode(fbxNode->GetName()); assert(node && node->getModel()); Model* model = node->getModel(); if (model && model->getSkin()) { MeshSkin* skin = model->getSkin(); copyMatrix(pose->GetMatrix(0), m); skin->setBindShape(m); } } } } }
void fbxLoader2::setBindPoseCluster(FbxNode *node) { if( node->GetNodeAttribute()) { switch(node->GetNodeAttribute()->GetAttributeType()) { case FbxNodeAttribute::eMesh: FbxMesh *mesh = node->GetMesh(); for (int j = 0; j<mesh->GetDeformerCount(); j++) { FbxSkin *skin = (FbxSkin*) mesh->GetDeformer(j,FbxDeformer::eSkin); int clusters = skin->GetClusterCount(); for(int k = 0; k<clusters; k++) { FbxCluster* cluster = skin->GetCluster(k); FbxNode* boneLink = cluster->GetLink(); if(boneLink) { std::string nameLink = boneLink->GetName(); FbxAMatrix translationM; FbxAMatrix invert; cluster->GetTransformLinkMatrix(translationM); cluster->GetTransformMatrix(invert); translationM = translationM * invert.Inverse(); D3DXMATRIX mat = D3DXMATRIX((float)translationM.mData[0].mData[0], (float)translationM.mData[0].mData[1], (float)translationM.mData[0].mData[2], (float)translationM.mData[3].mData[0], (float)translationM.mData[1].mData[0], (float)translationM.mData[1].mData[1], (float)translationM.mData[1].mData[2], (float)translationM.mData[3].mData[1], (float)translationM.mData[2].mData[0], (float)translationM.mData[2].mData[1], (float)translationM.mData[2].mData[2], (float)translationM.mData[3].mData[2], 0,0,0,1); skeleton->GetBone(skeleton->GetBoneByName(nameLink))->SetTransformation(mat); } } } break; } } for (int i = 0; i<node->GetChildCount(); i++) { FbxNode* child = node->GetChild(i); setBindPoseCluster(child); } }
void FBXSceneEncoder::loadSkin(FbxMesh* fbxMesh, Model* model) { const int deformerCount = fbxMesh->GetDeformerCount(); for (int i = 0; i < deformerCount; ++i) { FbxDeformer* deformer = fbxMesh->GetDeformer(i); if (deformer->GetDeformerType() == FbxDeformer::eSkin) { FbxSkin* fbxSkin = FbxCast<FbxSkin>(deformer); MeshSkin* skin = new MeshSkin(); vector<string> jointNames; vector<Node*> joints; vector<Matrix> bindPoses; const int clusterCount = fbxSkin->GetClusterCount(); for (int j = 0; j < clusterCount; ++j) { FbxCluster* cluster = fbxSkin->GetCluster(j); assert(cluster); FbxNode* linkedNode = cluster->GetLink(); if (linkedNode && linkedNode->GetSkeleton()) { const char* jointName = linkedNode->GetName(); assert(jointName); jointNames.push_back(jointName); Node* joint = loadNode(linkedNode); assert(joint); joints.push_back(joint); FbxAMatrix matrix; cluster->GetTransformLinkMatrix(matrix); Matrix m; copyMatrix(matrix.Inverse(), m); bindPoses.push_back(m); } } skin->setJointNames(jointNames); skin->setJoints(joints); skin->setBindPoses(bindPoses); model->setSkin(skin); break; } } }
Model::Model(char* name) { FbxManager* lSdkManager = FbxManager::Create(); FbxIOSettings * ios = FbxIOSettings::Create(lSdkManager, IOSROOT); this->modelName = name; lSdkManager->SetIOSettings(ios); FbxImporter* lImporter = FbxImporter::Create(lSdkManager, ""); std::string path = MODELS_SUBDIR + std::string(name); if (!lImporter->Initialize(path.c_str(), -1, lSdkManager->GetIOSettings())) TriggerCrash("Nie mo¿na znaleœæ modelu!"); FbxScene* lScene = FbxScene::Create(lSdkManager, "myScene"); //pobranie calego fbx'a lImporter->Import(lScene); for (int i = 0; i < lScene->GetRootNode()->GetChildCount(); i++){ //leci po wszystkich modelach w fbx FbxNode* node = lScene->GetRootNode()->GetChild(i); char* texBaseName = (char*) node->GetName(); this->objects.push_back(new ModelObject(node)); } Models.push_back(this); }
Model::Model(const std::string &filename) { key = filename; if (ResourceManager::access<Data *>(key)) return; int level = 0; // Initialize the SDK manager. This object handles memory management. FbxManager* lSdkManager = FbxManager::Create(); // Create the IO settings object. FbxIOSettings *ios = FbxIOSettings::Create(lSdkManager, IOSROOT); lSdkManager->SetIOSettings(ios); // Create an importer using the SDK manager. FbxImporter* lImporter = FbxImporter::Create(lSdkManager, ""); Data *model = new Data(); // Create a new scene so that it can be populated by the imported file. if (!lImporter->Initialize(filename.c_str(), -1, lSdkManager->GetIOSettings())) { LOG(FATAL) << "Failed to load model " << filename; } // Create a new scene so that it can be populated by the imported file. FbxScene* lScene = FbxScene::Create(lSdkManager, "myScene"); // Import the contents of the file into the scene. lImporter->Import(lScene); // Print the nodes of the scene and their attributes recursively. // Note that we are not printing the root node because it should // not contain any attributes. FbxNode* lRootNode = lScene->GetRootNode(); if (lRootNode) { LOG(INFO) << "Root Node " << lRootNode->GetName(); for (int i = 0; i < lRootNode->GetChildCount(); i++) { level = processNode(lRootNode->GetChild(i), level, *model); } } ResourceManager::store(filename, Resource::Type::Model, model); }
GameObject * loadFBXFromFile(const std::string& filename) { GameObject *rootGo = NULL; level = 0; // Initialize the SDK manager. This object handles memory management. FbxManager* lSdkManager = FbxManager::Create(); // Create the IO settings object. FbxIOSettings *ios = FbxIOSettings::Create(lSdkManager, IOSROOT); lSdkManager->SetIOSettings(ios); // Create an importer using the SDK manager. FbxImporter* lImporter = FbxImporter::Create(lSdkManager, ""); // Create a new scene so that it can be populated by the imported file. if (!lImporter->Initialize(filename.c_str(), -1, lSdkManager->GetIOSettings())) { return rootGo; } // Create a new scene so that it can be populated by the imported file. FbxScene* lScene = FbxScene::Create(lSdkManager, "myScene"); // Import the contents of the file into the scene. lImporter->Import(lScene); // Print the nodes of the scene and their attributes recursively. // Note that we are not printing the root node because it should // not contain any attributes. FbxNode* lRootNode = lScene->GetRootNode(); if (lRootNode) { rootGo = new GameObject(); rootGo->setTransform(new Transform()); std::cout << "Root Node " << lRootNode->GetName() << std::endl; for (int i = 0; i < lRootNode->GetChildCount(); i++) { processNode(lRootNode->GetChild(i), rootGo); } } return rootGo; }
Bone::Bone(FbxNode& node) : index ( -1 ) , name ( node.GetName() ) , parentName ( node.GetParent() != nullptr ? node.GetParent()->GetName() : "none" ) , numChildren ( unsigned(node.GetChildCount()) ) , transformation ( to_gua::mat4f(node.EvaluateLocalTransform()) ) , offsetMatrix ( scm::math::mat4f::identity() ) { for (int i = 0; i < node.GetChildCount(); ++i) { FbxSkeleton const* skelnode { node.GetChild(i)->GetSkeleton() }; if (skelnode && skelnode->GetSkeletonType() == FbxSkeleton::eEffector && node.GetChild(i)->GetChildCount() == 0) { Logger::LOG_DEBUG << node.GetChild(i)->GetName() << " is effector, ignoring it" << std::endl; } else { auto child = std::make_shared<Bone>(*(node.GetChild(i))); children.push_back(child); } } }
FBX::FBX(FbxScene* lScene) { material_library = new MaterialLibrary(""); // This function show how to cycle through scene elements in a linear way. const int lNodeCount = lScene->GetSrcObjectCount<FbxNode>(); FbxStatus lStatus; for (int lIndex=0; lIndex<lNodeCount; lIndex++) { FbxNode *lNode = lScene->GetSrcObject<FbxNode>(lIndex); printf("Node found: %s\n", lNode->GetName()); FbxMesh *lMesh=lNode->GetMesh(); if (lMesh) { TerrainInstance *terrain_instance=buildTerrainInstanceFromFBX(lNode); instances.push_back(terrain_instance); models.push_back(terrain_instance->getModel()); } } scene = lScene; }
void FBXSceneInstance::ProcessSkeleton(FbxNode* pNode) { FbxSkeleton* pFBXSkeleton = pNode->GetSkeleton(); if( !pFBXSkeleton ) return; if( !m_pSkeleton ) { m_pSkeleton = new Skeleton(); } int nParentBoneIndex = -1; FbxNode* pParentNode = pNode->GetParent(); if( pParentNode ) nParentBoneIndex = m_pSkeleton->FindBoneIndex(pParentNode->GetName()); SkeletonBone* pSkeletonBone = new SkeletonBone( pNode->GetName(), nParentBoneIndex, m_pSkeleton ); m_pSkeleton->AddSkeletonBone(pSkeletonBone); int boneIndex = m_pSkeleton->FindBoneIndex(pNode->GetName()); pSkeletonBone->SetBoneIndex(boneIndex); }
Node::Node( FbxNode& _Node, Node* _pParent ) : m_Node( _Node ), m_pParent( _pParent ) { FBXSDK_printf( "Node Name: %s\n", _Node.GetName() ); // DisplayUserProperties(&_Node); // DisplayTarget(&_Node); // DisplayPivotsAndLimits(&_Node); // DisplayTransformPropagation(&_Node); // DisplayGeometricTransform(&_Node); FbxVector4 T = _Node.GetGeometricTranslation( FbxNode::eSourcePivot ); FbxVector4 R = _Node.GetGeometricRotation( FbxNode::eSourcePivot ); FbxVector4 S = _Node.GetGeometricScaling( FbxNode::eSourcePivot ); m_Local2Parent.SetTRS( T, R, S ); if ( m_pParent != NULL ) { m_Local2World = m_Local2Parent * m_pParent->m_Local2World; } else m_Local2World = m_Local2Parent; }
//-------------------------------------------------------------------------------------- void FBXScene::ProcessBoneWeights(FbxSkin* pFBXSkin, std::vector<BoneWeights>& meshBoneWeights) { FbxCluster::ELinkMode linkMode = FbxCluster::eNormalize; //Default link mode std::vector<BoneWeights> skinBoneWeights(meshBoneWeights.size(), BoneWeights()); unsigned int nClusterCount = pFBXSkin->GetClusterCount(); for( unsigned int i = 0; i < nClusterCount; ++i ) { FbxCluster* pFBXCluster = pFBXSkin->GetCluster(i); if( !pFBXCluster ) continue; linkMode = pFBXCluster->GetLinkMode(); FbxNode* pLinkNode = pFBXCluster->GetLink(); if( !pLinkNode ) continue; int nBoneIndex = m_pSkeleton->FindBoneIndex(pLinkNode->GetName()); if( nBoneIndex < 0 ) continue; SkeletonBone* pSkeletonBone = m_pSkeleton->GetSkeletonBone(nBoneIndex); FbxAMatrix matClusterTransformMatrix; FbxAMatrix matClusterLinkTransformMatrix; pFBXCluster->GetTransformMatrix(matClusterTransformMatrix); pFBXCluster->GetTransformLinkMatrix(matClusterLinkTransformMatrix); pSkeletonBone->SetBindPoseTransform2(matClusterLinkTransformMatrix); pSkeletonBone->SetBoneReferenceTransform2(matClusterTransformMatrix); int* indices = pFBXCluster->GetControlPointIndices(); double* weights = pFBXCluster->GetControlPointWeights(); for( int j = 0; j < pFBXCluster->GetControlPointIndicesCount(); ++j ) { skinBoneWeights[indices[j]].AddBoneWeight(nBoneIndex, (float)weights[j]); } } switch(linkMode) { case FbxCluster::eNormalize: //Normalize so weight sum is 1.0. for( unsigned int i = 0; i < skinBoneWeights.size(); ++i ) { skinBoneWeights[i].Normalize(); } break; case FbxCluster::eAdditive: //Not supported yet. Do nothing break; case FbxCluster::eTotalOne: //The weight sum should already be 1.0. Do nothing. break; } for( unsigned int i = 0; i < meshBoneWeights.size(); ++i ) { meshBoneWeights[i].AddBoneWeights(skinBoneWeights[i]); } }
Bone::Bone(FbxScene& scene) { //construct hierarchy *this = Bone { *(scene.GetRootNode()) }; std::map<std::string, std::pair<unsigned int, scm::math::mat4f> > bone_info{} ; unsigned num_bones = 0; for (unsigned int i = 0; i < scene.GetGeometryCount(); i++) { FbxGeometry* geo = scene.GetGeometry(i); if (geo->GetAttributeType() == FbxNodeAttribute::eMesh) { //check for skinning, use first skin deformer FbxSkin* skin; for (unsigned i = 0; i < geo->GetDeformerCount(); ++i) { FbxDeformer* defPtr = { geo->GetDeformer(i) }; if (defPtr->GetDeformerType() == FbxDeformer::eSkin) { skin = static_cast<FbxSkin*>(defPtr); break; } } if (!skin) { Logger::LOG_ERROR << "Mesh does not contain skin deformer" << std::endl; assert(false); } //one cluster corresponds to one bone for (unsigned i = 0; i < skin->GetClusterCount(); ++i) { FbxCluster* cluster = skin->GetCluster(i); FbxNode* node = cluster->GetLink(); if (!node) { Logger::LOG_ERROR << "associated node does not exist!" << std::endl; assert(false); } std::string bone_name(node->GetName()); //helper to check for matrix magnitude auto magnitude = [](scm::math::mat4f const & mat)->float { float mag = 0.0f; for (unsigned i = 0; i < 16; ++i) { mag += mat[i] * mat[i]; } return mag; } ; //reference pose of bone FbxAMatrix bind_transform; cluster->GetTransformLinkMatrix(bind_transform); //check if the clusters have an extra transformation FbxAMatrix cluster_transform; cluster->GetTransformMatrix(cluster_transform); if (magnitude(to_gua::mat4f(cluster_transform) - scm::math::mat4f::identity()) > 0.000000001f) { Logger::LOG_WARNING << "weight cluster of bone '" << bone_name << "' has transformation, animation will be skewed" << std::endl; } //add bone to list if it is not already included if (bone_info.find(bone_name) == bone_info.end()) { bone_info[bone_name] = std::make_pair( num_bones, to_gua::mat4f(bind_transform.Inverse() * cluster_transform)); ++num_bones; } } // traverse hierarchy and set accumulated values in the bone this->set_properties(bone_info); } } }
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; }
CC_FILE_ERROR FBXFilter::loadFile(const char* filename, ccHObject& container, bool alwaysDisplayLoadDialog/*=true*/, bool* coordinatesShiftEnabled/*=0*/, CCVector3d* coordinatesShift/*=0*/) { // Initialize the SDK manager. This object handles memory management. FbxManager* lSdkManager = FbxManager::Create(); // Create the IO settings object. FbxIOSettings *ios = FbxIOSettings::Create(lSdkManager, IOSROOT); lSdkManager->SetIOSettings(ios); // Import options determine what kind of data is to be imported. // True is the default, but here we’ll set some to true explicitly, and others to false. //(*(lSdkManager->GetIOSettings())).SetBoolProp(IMP_FBX_MATERIAL, true); //(*(lSdkManager->GetIOSettings())).SetBoolProp(IMP_FBX_TEXTURE, true); // Create an importer using the SDK manager. FbxImporter* lImporter = FbxImporter::Create(lSdkManager,""); CC_FILE_ERROR result = CC_FERR_NO_ERROR; // Use the first argument as the filename for the importer. if (!lImporter->Initialize(filename, -1, lSdkManager->GetIOSettings())) { ccLog::Warning(QString("[FBX] Error: %1").arg(lImporter->GetStatus().GetErrorString())); result = CC_FERR_READING; } else { // Create a new scene so that it can be populated by the imported file. FbxScene* lScene = FbxScene::Create(lSdkManager,"myScene"); // Import the contents of the file into the scene. if (lImporter->Import(lScene)) { // Print the nodes of the scene and their attributes recursively. // Note that we are not printing the root node because it should // not contain any attributes. FbxNode* lRootNode = lScene->GetRootNode(); std::vector<FbxNode*> nodes; nodes.push_back(lRootNode); while (!nodes.empty()) { FbxNode* lNode = nodes.back(); nodes.pop_back(); const char* nodeName = lNode->GetName(); #ifdef _DEBUG ccLog::Print(QString("Node: %1 - %2 properties").arg(nodeName).arg(lNode->GetNodeAttributeCount())); #endif // scan the node's attributes. for(int i=0; i<lNode->GetNodeAttributeCount(); i++) { FbxNodeAttribute* pAttribute = lNode->GetNodeAttributeByIndex(i); FbxNodeAttribute::EType type = pAttribute->GetAttributeType(); #ifdef _DEBUG ccLog::Print(QString("\tProp. #%1").arg(GetAttributeTypeName(type))); #endif switch(type) { case FbxNodeAttribute::eMesh: { ccMesh* mesh = FromFbxMesh(static_cast<FbxMesh*>(pAttribute),alwaysDisplayLoadDialog,coordinatesShiftEnabled,coordinatesShift); if (mesh) { //apply transformation FbxAMatrix& transform = lNode->EvaluateGlobalTransform(); ccGLMatrix mat; float* data = mat.data(); for (int c=0; c<4; ++c) { FbxVector4 C = transform.GetColumn(c); *data++ = static_cast<float>(C[0]); *data++ = static_cast<float>(C[1]); *data++ = static_cast<float>(C[2]); *data++ = static_cast<float>(C[3]); } mesh->applyGLTransformation_recursive(&mat); if (mesh->getName().isEmpty()) mesh->setName(nodeName); container.addChild(mesh); } } break; case FbxNodeAttribute::eUnknown: case FbxNodeAttribute::eNull: case FbxNodeAttribute::eMarker: case FbxNodeAttribute::eSkeleton: case FbxNodeAttribute::eNurbs: case FbxNodeAttribute::ePatch: case FbxNodeAttribute::eCamera: case FbxNodeAttribute::eCameraStereo: case FbxNodeAttribute::eCameraSwitcher: case FbxNodeAttribute::eLight: case FbxNodeAttribute::eOpticalReference: case FbxNodeAttribute::eOpticalMarker: case FbxNodeAttribute::eNurbsCurve: case FbxNodeAttribute::eTrimNurbsSurface: case FbxNodeAttribute::eBoundary: case FbxNodeAttribute::eNurbsSurface: case FbxNodeAttribute::eShape: case FbxNodeAttribute::eLODGroup: case FbxNodeAttribute::eSubDiv: default: //not handled yet break; } } // Recursively add the children. for(int j=0; j<lNode->GetChildCount(); j++) { nodes.push_back(lNode->GetChild(j)); } } } } // The file is imported, so get rid of the importer. lImporter->Destroy(); // Destroy the SDK manager and all the other objects it was handling. lSdkManager->Destroy(); return container.getChildrenNumber() == 0 ? CC_FERR_NO_LOAD : CC_FERR_NO_ERROR; }
// This method is templated on the implementation of hctMayaSceneExporter::createHkxNodes() void FbxToHkxConverter::addNodesRecursive(hkxScene *scene, FbxNode* fbxNode, hkxNode* node, int animStackIndex) { for (int childIndex = 0; childIndex < fbxNode->GetChildCount(); childIndex++) { FbxNode* fbxChildNode = fbxNode->GetChild(childIndex); FbxNodeAttribute* fbxNodeAtttrib = fbxChildNode->GetNodeAttribute(); bool selected = fbxChildNode->GetSelected(); // Ignore nodes(and their descendants) if they're invisible and we ignore invisible objects if ( !(!m_options.m_visibleOnly || fbxNode->GetVisibility()) ) continue; // Ignore nodes(and their descendants) if they're not selected and we ignore deselected objects if ( !(!m_options.m_selectedOnly || selected) ) continue; hkxNode* newChildNode = new hkxNode(); { newChildNode->m_name = fbxChildNode->GetName(); node->m_children.pushBack(newChildNode); } newChildNode->m_selected = selected; // Extract the following types of data from this node (taken from hkxScene.h): if (fbxNodeAtttrib != NULL) { switch (fbxNodeAtttrib->GetAttributeType()) { case FbxNodeAttribute::eMesh: { // Generate hkxMesh and all its dependent data (ie: hkxSkinBinding, hkxMeshSection, hkxMaterial) if (m_options.m_exportMeshes) { addMesh(scene, fbxChildNode, newChildNode); } break; } case FbxNodeAttribute::eNurbsCurve: { if (m_options.m_exportSplines) { addSpline(scene, fbxChildNode, newChildNode); } break; } case FbxNodeAttribute::eCamera: { // Generate hkxCamera if (m_options.m_exportCameras) { addCamera(scene, fbxChildNode, newChildNode); } break; } case FbxNodeAttribute::eLight: { // Generate hkxLight if (m_options.m_exportLights) { addLight(scene, fbxChildNode, newChildNode); } break; } case FbxNodeAttribute::eSkeleton: { // Flag this node as a bone if it's associated with a skeleton attribute newChildNode->m_bone = true; break; } default: break; } } // Extract this node's animation data and bind transform extractKeyFramesAndAnnotations(scene, fbxChildNode, newChildNode, animStackIndex); if (m_options.m_exportAttributes) { addSampledNodeAttributeGroups(scene, animStackIndex, fbxChildNode, newChildNode); } GetCustomVisionData(fbxChildNode, newChildNode->m_userProperties); addNodesRecursive(scene, fbxChildNode, newChildNode, animStackIndex); newChildNode->removeReference(); } }
void fbxLoader2::readAnimationWeigths(FbxMesh* mesh) { if(!animationStructure) { animationStructure = new AnimationData(); } int numSkins = mesh->GetDeformerCount(FbxDeformer::eSkin); weightsNumber = 0; for (int l = 0; l<this->vertexMaxCount; l++) { for(int p = 0; p<4; p++) { this->vertexArray[l].weights[p].boneID = 0; this->vertexArray[l].weights[p].weight = 0.0f; } } int next = 0; int numindicestest = 0; for(int i = 0; i < numSkins; i++) { FbxSkin* skin = (FbxSkin*) mesh->GetDeformer(i, FbxDeformer::eSkin); int clusterCount = skin->GetClusterCount(); if( clusterCount == 0 ) continue; for (int j = 0; j < clusterCount; j++) { FbxCluster* cluster = skin->GetCluster(j);///trzeba jakoś zrobić wszystkie linki... edit, have no idea what i meant xD FbxNode* bone = cluster->GetLink(); if( !bone ) { continue; } int numInfluencedVertices = cluster->GetControlPointIndicesCount(); int* pIndexArray = cluster->GetControlPointIndices(); numindicestest += cluster->GetControlPointIndicesCount(); double *pWeightArray = cluster->GetControlPointWeights(); for(int iControlPoint = 0; iControlPoint < numInfluencedVertices; iControlPoint++) { /*int iControlPointIndex = pIndexArray[iControlPoint]; ////////////muszę poprawić indeksy wierzchołków. teraz odwoluje sie do vertow afaik int boneIndex = skeleton->GetBoneByName(bone->GetName()); int boneI = skeleton->GetBoneIndex(boneIndex); //boneIndices[iControlPointIndex] = iCluster; double weightAdd = pWeightArray[iControlPoint]; weightsStructure* added = new weightsStructure(boneI, iControlPointIndex, weightAdd); this->weights[next] = added; next++;*/ int iControlPointIndex = pIndexArray[iControlPoint]; int boneIndex = skeleton->GetBoneByName(bone->GetName()); int k = 0; if(vertexArray[iControlPointIndex].weights[0].weight == 0.0f) { vertexArray[iControlPointIndex].weights[0].boneID = skeleton->GetBoneIndex(boneIndex); vertexArray[iControlPointIndex].weights[0].weight = pWeightArray[iControlPoint]; vertexArray[iControlPointIndex].weightsNum = 1; } else { while (k < 3 && vertexArray[iControlPointIndex].weights[k].weight != 0.0f) { k++; } vertexArray[iControlPointIndex].weights[k].boneID = skeleton->GetBoneIndex(boneIndex); vertexArray[iControlPointIndex].weights[k].weight = pWeightArray[iControlPoint]; vertexArray[iControlPointIndex].weightsNum++; } } } } }