2. 程式人生 > >基於FBX SDK的FBX模型解析與載入

基於FBX SDK的FBX模型解析與載入

阿新 • • 發佈：2019-02-09

1. 簡介

FBX是Autodesk的一個用於跨平臺的免費三維資料交換的格式（最早不是由Autodesk開發，但後來被其收購），目前被 眾多的標準建模軟體所支援，在遊戲開發領域也常用來作為各種建模工具的標準匯出格式。Autodesk提供了基於C++（還有Python）的SDK來實現對FBX格式的各種讀寫、修改以及轉換等操作，之所以如此是因為FBX的格式不是公開的，這也是FBX的詬病之一。與FBX相對的則是格式開源的Collada，它的應用也很廣泛。總體來說這兩種格式還是各有優劣不相上下，關於兩種格式在遊戲開發中使用的對比與討論也比較多，可見GameDev中的帖子：http://www.gamedev.net/topic/467753-collada-vs-autodesk-fbx

, 這裡就不再論述了。大多數情況下我們是需要解析模型在程式中渲染使用，因此這裡主要討論使用FBX SDK來對FBX模型進行解析與載入（主要包括幾何網格、材質、Light與Camera、Skeleton動畫等），而對於在建模工具中可能涉及到的FBX寫出等則沒有涉及。

2. FBX SDK的配置

首先，在使用前需要下載安裝FBX的SDK，可以從Autodesk的網站上進行獲得最新的版本安裝之後在VS裡邊的配置就跟D3D類似。其中的Samples基本上涵蓋了FBX相關的應用，可以在使用之前好好研究一下。最新的SDK版本（2012版）與之前的版本會在細節上有所不同（有些較大的改動是實現某些功能 的API介面的修改，具體細節可以用2012的Programmer's guide中找到），而且支援最新的FBX格式，因此最好就直接用最新的版本。

3. FBX模型的組織結構

FBX是以scene graph的結構來儲存模型的所有資訊（也可以認為是一個多叉樹），類似於OSG中的組織方式，這一點可以從SDK所帶的Sample裡邊很清楚的看出來。一個較為典型的模型的組織結構與下圖所示：

整個Scene是從一個空屬性的根結點開始，其中每個結點均是一個KFbxNode的物件，所有物件之間的關聯均是雙向的，比如從子結點可以索引到父結點，從父結點也可以索引到子結點；從單個結點可以索引到整個Scene，從Scene也可以索引到該結點。每個結點都會有一個標記屬性的Enum值，比如eMesh、eLight、eCamera或eSkeleton等，分別用來標記當前結點是Mesh、Light、Camera或Skeleton。在整個結構的遍歷過程中可以通過判斷不同的結點屬性而進行不同的處理操作。

在進行使用SDK進行FBX的處理操作之前需要先初始化兩個必須的FBX物件：KFbxSdkManager和KFbxScene。前者用來對所有的FBX物件進行內在管理，所有使用SDK載入的資源均在此物件的管控之下，最終的資源釋放也由其來完成。有了記憶體管理器之後再在其上建立一個相關的KFbxScene物件之後即可以進行模型的加截與處理了。KFbxScene其實相當於Manager提供的整個場景物件的一個入口。兩個物件的初始化與配置程式碼如下所述：

初始化SDKManager

  1. bool FBXImporter::Initialize() 
  2. { 
  3.     // Create the FBX SDK Manager, destroy the old manager at first
  4.     if(mpFBXSDKManager) 
  5.     { 
  6.        mpFBXSDKManager->Destroy(); 
  7.     } 
  8.     mpFBXSDKManager = KFbxSdkManager::Create(); 
  9.     if(mpFBXSDKManager == NULL) 
  10.     { 
  11.        returnfalse; 
  12.     } 
  13.     // Create an IOSettings object
  14.     KFbxIOSettings* ios = KFbxIOSettings::Create(mpFBXSDKManager , IOSROOT); 
  15.     mpFBXSDKManager->SetIOSettings(ios); 
  16.     // Load plug-ins from the executable directory
  17.     KString lExtension = "dll"; 
  18.     KString lPath = KFbxGetApplicationDirectory(); 
  19.     mpFBXSDKManager->LoadPluginsDirectory(lPath.Buffer() , lExtension.Buffer()); 
  20.     // Create the entity that hold the whole Scene
  21.     mpFBXSDKScene = KFbxScene::Create(mpFBXSDKManager , ""); 
  22.     returntrue; 
  23. } 

FbxScene的初始化

  1. bool FBXImporter::LoadScene(constchar* pSeneName) 
  2. { 
  3.     if(mpFBXSDKManager == NULL) 
  4.     { 
  5.        returnfalse; 
  6.     } 
  7.     // Get the file version number generate by the FBX SDK.
  8.     KFbxSdkManager::GetFileFormatVersion(mSDKVersion.mMajor , mSDKVersion.mMinor , mSDKVersion.mRevision); 
  9.     // Create an importer.
  10.     KFbxImporter* pKFBXImporter = KFbxImporter::Create(mpFBXSDKManager ,""); 
  11.     // Initialize the importer by providing a filename
  12.     FBXFileVersion fileVersion; 
  13.     bool importStatus = pKFBXImporter->Initialize(fileName , -1 , mpFBXSDKManager->GetIOSettings()); 
  14.     lImporter->GetFileVersion(fileVersion.mMajor , fileVersion.mMinor , fileVersion.mRevision); 
  15.     if(!importStatus) 
  16.     { 
  17.         returnfalse; 
  18.     } 
  19.     // Import the scene
  20.     mpFBXScene->Clear(); 
  21.     importStatus = pKFBXImporter->Import(m_mpFBXScene); 
  22.     // Destroy the importer.
  23.     pKFBXImporter->Destroy(); 
  24.     return importStatus; 
  25. } 

在完成了對KFbxScene的初始化操作之後即可以從其中得到整個模型的所有資訊。由於FBX的是採用了類似於樹的結構來進行儲存，因而就很容易使用類似於樹的遞迴方法來遍歷其中的每個結點，並根據結點的屬性選擇合適的處理操作，下述程式碼就完成了從根結點開始的全域性遍歷：

  1. void ProcessNode(KFbxNode* pNode) 
  2. { 
  3.     KFbxNodeAttribute::EAttributeType attributeType; 
  4.     if(pNode->GetNodeAttribute()) 
  5.     { 
  6.         switch(pNode->GetNodeAttribute()->GetAttributeType()) 
  7.         { 
  8.         case KFbxNodeAttribute::eMESH: 
  9.             ProcessMesh(pNode); 
  10.             break; 
  11.         case KFbxNodeAttribute::eSKELETON: 
  12.             ProcessSkeleton(pNode); 
  13.             break; 
  14.         case KFbxNodeAttribute::eLIGHT: 
  15.             ProcessLight(pNode); 
  16.             break; 
  17.         case KFbxNodeAttribute::eCAMERA: 
  18.             ProcessCamera(); 
  19.             break; 
  20.         } 
  21.     } 
  22.     for(int i = 0 ; i < pNode->GetChildCount() ; ++i) 
  23.     { 
  24.         ProcessNode(pNode->GetChild(i)); 
  25.     } 
  26. } 

上述程式碼比較簡單，直接傳入由KFbxScene中獲得的根結點之後即可遍歷到每一個子結點。在FBX的儲存中，每個父結點可以包含多個子結點，但每個子結點只有一個根結點，而且這其中的聯絡是雙向的，這樣很方便，比如在處理Skeleton時就常常需要從子結點中得到父結點的matrix等資訊，而這種雙向關係使得這些操作很容易實現。注意，上述程式碼中有pNode->GetNodeAttribute()檢查操作是必須的，因為並不是所有的結點都有相應的屬性（Attribute也是以子結點的方式關聯到當前的結點上的，因而可能為空）。

4. 載入幾何網格

FBX對幾何網格支援得還是很好的，Nurbes、Polygon、Triangle等均可以儲存。不過為了簡化載入和處理時的操作，最好直接在FBX匯出外掛中選擇一種統一的模式。比如可以在匯出生成FBX時選中Triangluation的屬性，那麼FBX匯出外掛會自動把所有的Nurbes、Polygon三角化為三角形進行儲存。當然，這個過程也可以在模型進行載入時來進行。這樣在得到的FBX中就只有三角形這樣一種網格模型，方便了載入的操作。模型的幾何資料主要包括以下部分：

  • Vertex       組成網格的頂點資訊，這一部分是必須的。
  • Color         每個頂點的顏色，一般不需要。
  • Normal     每個頂點所對應的法向，是由FBX匯出外掛計算生成，可以是逐面片或逐頂點。
  • UV             每個頂點所對應的法向，是由FBX匯出外掛計算生成，可以是逐面片或逐頂點。
  • Tangent   每個頂點所對應的貼圖UV值，一般來說，每個UV對應一個Layer，一個頂點可以有多個UV通道，這在讀入的時間需要進行判斷

幾何網格的載入比較簡單，直接遞迴地從根結點來遍歷整個graph，檢測當前的結點是否為eMESH的屬性，若是即處理其中的幾何資料，主要程式碼如下所示：

  1. void ProcessMesh(KFbxNode* pNode) 
  2. { 
  3.     KFbxMesh* pMesh = pNode->GetMesh(); 
  4.     if(pMesh == NULL) 
  5.     { 
  6.         return; 
  7.     } 
  8.     D3DXVECTOR3 vertex[3]; 
  9.     D3DXVECTOR4 color[3]; 
  10.     D3DXVECTOR3 normal[3]; 
  11.     D3DXVECTOR3 tangent[3]; 
  12.     D3DXVECTOR2 uv[3][2]; 
  13.     int triangleCount = pMesh->GetPolygonCount(); 
  14.     int vertexCounter = 0; 
  15.     for(int i = 0 ; i < triangleCount ; ++i) 
  16.     { 
  17.         for(int j = 0 ; j < 3 ; j++) 
  18.         { 
  19.             int ctrlPointIndex = pMesh->GetPolygonVertex(i , j); 
  20.             // Read the vertex
  21.             ReadVertex(pMesh , ctrlPointIndex , &vertex[j]); 
  22.             // Read the color of each vertex
  23.             ReadColor(pMesh , ctrlPointIndex , vertexCounter , &color[j]); 
  24.             // Read the UV of each vertex
  25.             for(int k = 0 ; k < 2 ; ++k) 
  26.             { 
  27.                 ReadUV(pMesh , ctrlPointIndex , pMesh->GetTextureUVIndex(i, j) , k , &(uv[j][k])); 
  28.             } 
  29.             // Read the normal of each vertex
  30.             ReadNormal(pMesh , ctrlPointIndex , vertexCounter , &normal[j]); 
  31.             // Read the tangent of each vertex
  32.             ReadTangent(pMesh , ctrlPointIndex , vertexCounter , &tangent[j]); 
  33.             vertexCounter++; 
  34.         } 
  35.         // 根據讀入的資訊組裝三角形，並以某種方式使用即可，比如存入到列表中、儲存到檔案等...
  36.     } 
  37. } 

上述程式碼完成了從一個Node裡邊讀出相應的網格資訊。首先，從Node裡邊得到相應KFbxMesh指標，可知，如果該Node不是eMESH屬性的話那麼該指標就為空，後繼操作不能再進行。注意其中用triangleCount變數來儲存pMesh->GetPolygonCount()的值，這主要是在前面也提到過了，假定對於所有的FBX模型在儲存時均選定了Triangulation的操作，因而其中儲存的Polygon是三角形，如此一來每個裡邊一定只包含3個頂點，依次讀入這3個頂點所對應的各屬性資訊即可。在FBX中對於每個頂點所對應的各種額外屬性，比如Normal、Tangent、UV等均可對應多個通道，這可以通過在每個Mesh裡邊增加相應屬性的一個Layer即可實現，在使用FBX SDK寫出FBX檔案時很容易做到。比如上述程式碼中就從FBX中讀出4個UV通道中的值（第一個是正常的貼圖通道，第二層是LightMap的通道）。vertexCounter是記錄已經處理過的頂點的數目，這主要是頂點資訊讀取在某些對映模式下（比如下述使用到vertexCounter的eBY_POLYGON_VERTEX等）需要知道其在全域性頂ControlPoints中的資訊，因而增加這樣的一個變數來進行記錄。

讀入頂點：

  1. void ReadVertex(KFbxMesh* pMesh ,int ctrlPointIndex , D3DXVECTOR3* pVertex) 
  2. { 
  3.     KFbxVector4* pCtrlPoint = pMesh->GetControlPoints(); 
  4.     pVertex->x = pCtrlPoint[ctrlPointIndex].GetAt(0); 
  5.     pVertex->y = pCtrlPoint[ctrlPointIndex].GetAt(1); 
  6.     pVertex->z = pCtrlPoint[ctrlPointIndex].GetAt(2); 
  7. } 

讀入Color:

  1. void ReadColor(KFbxMesh* pMesh ,int ctrlPointIndex ,int vertexCounter , D3DXVECTOR4* pColor) 
  2. { 
  3.     if(pMesh->GetElementVertexColorCount < 1) 
  4.     { 
  5.         return; 
  6.     } 
  7.     KFbxGeometryElementVertexColor* pVertexColor = pMesh->GetElementVertexColor(0); 
  8.     switch(pVertexColor->GetMappingMode()) 
  9.     { 
  10.     case KFbxGeometryElement::eBY_CONTROL_POINT: 
  11.         { 
  12.             switch(pVertexColor->GetReferenceMode()) 
  13.             { 
  14.             case KFbxGeometryElement::eDIRECT: 
  15.                 { 
  16.                     pColor->x = pVertexColor->GetDirectArray().GetAt(ctrlPointIndex).mRed; 
  17.                     pColor->y = pVertexColor->GetDirectArray().GetAt(ctrlPointIndex).mGreen; 
  18.                     pColor->z = pVertexColor->GetDirectArray().GetAt(ctrlPointIndex).mBlue; 
  19.                     pColor->w = pVertexColor->GetDirectArray().GetAt(ctrlPointIndex).mAlpha; 
  20.                 } 
  21.                 break; 
  22.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  23.                 { 
  24.                     int id = pVertexColor->GetIndexArray().GetAt(ctrlPointIndex); 
  25.                     pColor->x = pVertexColor->GetDirectArray().GetAt(id).mRed; 
  26.                     pColor->y = pVertexColor->GetDirectArray().GetAt(id).mGreen; 
  27.                     pColor->z = pVertexColor->GetDirectArray().GetAt(id).mBlue; 
  28.                     pColor->w = pVertexColor->GetDirectArray().GetAt(id).mAlpha; 
  29.                 } 
  30.                 break; 
  31.             default: 
  32.                 break; 
  33.             } 
  34.         } 
  35.         break; 
  36.     case KFbxGeometryElement::eBY_POLYGON_VERTEX: 
  37.         { 
  38.             switch (pVertexColor->GetReferenceMode()) 
  39.             { 
  40.             case KFbxGeometryElement::eDIRECT: 
  41.                 { 
  42.                     pColor->x = pVertexColor->GetDirectArray().GetAt(vertexCounter).mRed; 
  43.                     pColor->y = pVertexColor->GetDirectArray().GetAt(vertexCounter).mGreen; 
  44.                     pColor->z = pVertexColor->GetDirectArray().GetAt(vertexCounter).mBlue; 
  45.                     pColor->w = pVertexColor->GetDirectArray().GetAt(vertexCounter).mAlpha; 
  46.                 } 
  47.                 break; 
  48.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  49.                 { 
  50.                     int id = pVertexColor->GetIndexArray().GetAt(vertexCounter); 
  51.                     pColor->x = pVertexColor->GetDirectArray().GetAt(id).mRed; 
  52.                     pColor->y = pVertexColor->GetDirectArray().GetAt(id).mGreen; 
  53.                     pColor->z = pVertexColor->GetDirectArray().GetAt(id).mBlue; 
  54.                     pColor->w = pVertexColor->GetDirectArray().GetAt(id).mAlpha; 
  55.                 } 
  56.                 break; 
  57.             default: 
  58.                 break; 
  59.             } 
  60.         } 
  61.         break; 
  62.     } 
  63. } 

讀入UV:

  1. void ReadUV(KFbxMesh* pMesh ,int ctrlPointIndex ,int textureUVIndex ,int uvLayer , D3DXVECTOR2* pUV) 
  2. { 
  3.     if(uvLayer >= 2 || pMesh->GetElementUVCount() <= uvLayer) 
  4.     { 
  5.         returnfalse; 
  6.     } 
  7.     KFbxGeometryElementUV* pVertexUV = pMesh->GetElementUV(uvLayer); 
  8.     switch(pVertexUV->GetMappingMode()) 
  9.     { 
  10.     case KFbxGeometryElement::eBY_CONTROL_POINT: 
  11.         { 
  12.             switch(pVertexUV->GetReferenceMode()) 
  13.             { 
  14.             case KFbxGeometryElement::eDIRECT: 
  15.                 { 
  16.                     pUV->x = pVertexUV->GetDirectArray().GetAt(ctrlPointIndex).GetAt(0); 
  17.                     pUV->y = pVertexUV->GetDirectArray().GetAt(ctrlPointIndex).GetAt(1); 
  18.                 } 
  19.                 break; 
  20.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  21.                 { 
  22.                     int id = pVertexUV->GetIndexArray().GetAt(ctrlPointIndex); 
  23.                     pUV->x = pVertexUV->GetDirectArray().GetAt(id).GetAt(0); 
  24.                     pUV->y = pVertexUV->GetDirectArray().GetAt(id).GetAt(1); 
  25.                 } 
  26.                 break; 
  27.             default: 
  28.                 break; 
  29.             } 
  30.         } 
  31.         break; 
  32.     case KFbxGeometryElement::eBY_POLYGON_VERTEX: 
  33.         { 
  34.             switch (pVertexUV->GetReferenceMode()) 
  35.             { 
  36.             case KFbxGeometryElement::eDIRECT: 
  37.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  38.                 { 
  39.                     pUV->x = pVertexUV->GetDirectArray().GetAt(textureUVIndex).GetAt(0); 
  40.                     pUV->y = pVertexUV->GetDirectArray().GetAt(textureUVIndex).GetAt(1); 
  41.                 } 
  42.                 break; 
  43.             default: 
  44.                 break; 
  45.             } 
  46.         } 
  47.         break; 
  48.     } 
  49. } 

讀入Normal:

  1. void ReadNormal(KFbxMesh* pMesh ,int ctrlPointIndex ,int vertexCounter , D3DXVECTOR3* pNormal) 
  2. { 
  3.     if(pMesh->GetElementNormalCount() < 1) 
  4.     { 
  5.         return; 
  6.     } 
  7.     KFbxGeometryElementNormal* leNormal = pMesh->GetElementNormal(0); 
  8.     switch(leNormal->GetMappingMode()) 
  9.     { 
  10.     case KFbxGeometryElement::eBY_CONTROL_POINT: 
  11.         { 
  12.             switch(leNormal->GetReferenceMode()) 
  13.             { 
  14.             case KFbxGeometryElement::eDIRECT: 
  15.                 { 
  16.                     pNormal->x = leNormal->GetDirectArray().GetAt(ctrlPointIndex).GetAt(0); 
  17.                     pNormal->y = leNormal->GetDirectArray().GetAt(ctrlPointIndex).GetAt(1); 
  18.                     pNormal->z = leNormal->GetDirectArray().GetAt(ctrlPointIndex).GetAt(2); 
  19.                 } 
  20.                 break; 
  21.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  22.                 { 
  23.                     int id = leNormal->GetIndexArray().GetAt(ctrlPointIndex); 
  24.                     pNormal->x = leNormal->GetDirectArray().GetAt(id).GetAt(0); 
  25.                     pNormal->y = leNormal->GetDirectArray().GetAt(id).GetAt(1); 
  26.                     pNormal->z = leNormal->GetDirectArray().GetAt(id).GetAt(2); 
  27.                 } 
  28.                 break; 
  29.             default: 
  30.                 break; 
  31.             } 
  32.         } 
  33.         break; 
  34.     case KFbxGeometryElement::eBY_POLYGON_VERTEX: 
  35.         { 
  36.             switch(leNormal->GetReferenceMode()) 
  37.             { 
  38.             case KFbxGeometryElement::eDIRECT: 
  39.                 { 
  40.                     pNormal->x = leNormal->GetDirectArray().GetAt(vertexCounter).GetAt(0); 
  41.                     pNormal->y = leNormal->GetDirectArray().GetAt(vertexCounter).GetAt(1); 
  42.                     pNormal->z = leNormal->GetDirectArray().GetAt(vertexCounter).GetAt(2); 
  43.                 } 
  44.                 break; 
  45.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  46.                 { 
  47.                     int id = leNormal->GetIndexArray().GetAt(vertexCounter); 
  48.                     pNormal->x = leNormal->GetDirectArray().GetAt(id).GetAt(0); 
  49.                     pNormal->y = leNormal->GetDirectArray().GetAt(id).GetAt(1); 
  50.                     pNormal->z = leNormal->GetDirectArray().GetAt(id).GetAt(2); 
  51.                 } 
  52.                 break; 
  53.             default: 
  54.                 break; 
  55.             } 
  56.         } 
  57.         break; 
  58.     } 
  59. } 

讀入Tangent:

  1. void ReadTangent(KFbxMesh* pMesh ,int ctrlPointIndex ,int vertecCounter , D3DXVECTOR3* pTangent) 
  2. { 
  3.     if(pMesh->GetElementTangentCount() < 1) 
  4.     { 
  5.         return; 
  6.     } 
  7.     KFbxGeometryElementTangent* leTangent = pMesh->GetElementTangent(0); 
  8.     switch(leTangent->GetMappingMode()) 
  9.     { 
  10.     case KFbxGeometryElement::eBY_CONTROL_POINT: 
  11.         { 
  12.             switch(leTangent->GetReferenceMode()) 
  13.             { 
  14.             case KFbxGeometryElement::eDIRECT: 
  15.                 { 
  16.                     pTangent->x = leTangent->GetDirectArray().GetAt(ctrlPointIndex).GetAt(0); 
  17.                     pTangent->y = leTangent->GetDirectArray().GetAt(ctrlPointIndex).GetAt(1); 
  18.                     pTangent->z = leTangent->GetDirectArray().GetAt(ctrlPointIndex).GetAt(2); 
  19.                 } 
  20.                 break; 
  21.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  22.                 { 
  23.                     int id = leTangent->GetIndexArray().GetAt(ctrlPointIndex); 
  24.                     pTangent->x = leTangent->GetDirectArray().GetAt(id).GetAt(0); 
  25.                     pTangent->y = leTangent->GetDirectArray().GetAt(id).GetAt(1); 
  26.                     pTangent->z = leTangent->GetDirectArray().GetAt(id).GetAt(2); 
  27.                 } 
  28.                 break; 
  29.             default: 
  30.                 break; 
  31.             } 
  32.         } 
  33.         break; 
  34.     case KFbxGeometryElement::eBY_POLYGON_VERTEX: 
  35.         { 
  36.             switch(leTangent->GetReferenceMode()) 
  37.             { 
  38.             case KFbxGeometryElement::eDIRECT: 
  39.                 { 
  40.                     pTangent->x = leTangent->GetDirectArray().GetAt(vertecCounter).GetAt(0); 
  41.                     pTangent->y = leTangent->GetDirectArray().GetAt(vertecCounter).GetAt(1); 
  42.                     pTangent->z = leTangent->GetDirectArray().GetAt(vertecCounter).GetAt(2); 
  43.                 } 
  44.                 break; 
  45.             case KFbxGeometryElement::eINDEX_TO_DIRECT: 
  46.                 { 
  47.                     int id = leTangent->GetIndexArray().GetAt(vertecCounter); 
  48.                     pTangent->x = leTangent->GetDirectArray().GetAt(id).GetAt(0); 
  49.                     pTangent->y = leTangent->GetDirectArray().GetAt(id).GetAt(1); 
  50.                     pTangent->z = leTangent->GetDirectArray().GetAt(id).GetAt(2); 
  51.                 } 
  52.                 break; 
  53.             default: 
  54.                 break; 
  55.             } 
  56.         } 
  57.         break; 
  58.     } 
  59. } 

上述幾個Normal、Tangent、UV等資訊讀取的函式的實現其實都差不多，首先需要判斷有沒有相應的Layer關聯在當前的Mesh中，若有則獲取其地址，然後根據不同的對映方式使用不同的方法從記憶體中讀取相應的值即可。

完成了這些基本幾何資訊的讀取之後即可以使用其進行渲染了：

5. 載入材質

Material是一個模型渲染時必不可少的部分，當然，這些資訊也被存到了FBX之中（甚至各種貼圖等也可以直接內嵌到FBX內部），就需要從FBX中載入這些資訊以完成帶有材質的渲染。材質的載入可以與Mesh的載入相結合來完成，但更好的方法是獨立進行，這樣各模組間的關係更清晰，但這就需要一個額外的操作，那就是關聯Mesh與Material。FBX中的材質物件包含了豐富的資訊，比如最常規的從Max中可以看到那些材質屬性，如ambient、diffuse、specular的color和texture；shininess、opacity值等，更高階一點的屬性諸如Effect的引數、原始檔等都可以儲存。它是儘可能保證從建模工具中匯出時不丟失地儲存材質資訊，但我們在使用時卻可以有選擇地讀取。

5.1 關聯Mesh與材質

對於Material與Mesh獨立載入的系統而言，首先需要讀取相關的資訊將兩者關聯起來，這些資訊其實對也都儲存在KFbxMesh之內（屬於幾何資訊的一部分吧）。每個帶有材質的Mesh結點上都會包含有一個型別為KFbxGeometryElementMaterial的結點（若不含有材質則該結點為空），該結點中記錄了Mesh中的多邊形（這裡全部為三角形）與每個材質的對應關係，讀取該結點中的資訊建立Mesh與Material之間的連線關係，程式碼如下：

  1. void ConnectMaterialToMesh(KFbxMesh* pMesh ,int triangleCount ,int* pTriangleMtlIndex) 
  2. { 
  3.     // Get the material index list of current mesh
  4.     KFbxLayerElementArrayTemplate<int>* pMaterialIndices; 
  5.     KFbxGeometryElement::EMappingMode   materialMappingMode = KFbxGeometryElement::eNONE; 
  6.     if(pMesh->GetElementMaterial()) 
  7.     { 
  8.         pMaterialIndices    = &pMesh->GetElementMaterial()->GetIndexArray(); 
  9.         materialMappingMode = pMesh->GetElementMaterial()->GetMappingMode(); 
  10.         if(pMaterialIndices) 
  11.         { 
  12.             switch(materialMappingMode) 
  13.             { 
  14.             case KFbxGeometryElement::eBY_POLYGON: 
  15.                 { 
  16.                     if(pMaterialIndices->GetCount() == triangleCount) 
  17.                     { 
  18.                         for(int triangleIndex = 0 ; triangleIndex < triangleCount ; ++triangleIndex) 
  19.                         { 
  20.                             int materialIndex = pMaterialIndices->GetAt(triangleIndex); 
  21.                             pTriangleMtlIndex[triangleIndex] = materialIndex; 
  22.                         } 
  23.                     } 
  24.                 } 
  25.                 break; 
  26.             case KFbxGeometryElement::eALL_SAME: 
  27.                 { 
  28.                     int lMaterialIndex = pMaterialIndices->GetAt(0); 
  29.                     for(int triangleIndex = 0 ; triangleIndex < triangleCount ; ++triangleIndex) 
  30.                     { 
  31.                         int materialIndex = pMaterialIndices->GetAt(triangleIndex); 
  32.                         pTriangleMtlIndex[triangleIndex] = materialIndex; 
  33.                     } 
  34.                 } 
  35.             } 
  36.         } 
  37.     } 
  38. } 

其中上triangleCount即為從pMesh中讀取得到的三角形的數量，pTriangleMtlIndex是一個長度為triangleCount的陣列，主要用來儲存讀取到的三角形對應的材質索引。注意：這裡考慮的情況是對於一個三角形只對應一個材質，而一般情況下也是這樣（如果是對應多個材質的話需要些許修改此處的程式碼）。完成Mesh的索引讀取之後即可以將pTriangleMtlIndex中的值以合適的方式轉儲到對應的三角形列表中（或以其它的方式對應）以便在渲染時使用。

5.2 普通材質

FBX中實際儲存材質資訊的位置是每個Mesh中對應的一個型別為KFbxSurfaceMaterial的結點，其裡邊儲存了普通材質的典型資訊，主要包括以下屬性（有一些沒有列出）：

  •   ShadingModel                 材質的光照模型，一般為兩種典型的區域性光照模型：Phong、Lambert
  •   Emissive                          Emissive屬性
  •   EmissiveFactor
  •   Ambient                           Ambient屬性
  •   AmbientFactor
  •   Diffuse                             Diffuse屬性
  •   DiffuseFactor
  •   Specular                           Specular屬性
  •   SpecularFactor
  •   Shininess                         Sepcular的Shininess屬性
  •   Bump                               Normal Map相關的屬性
  •   NormalMap
  •   BumpFactor
  •   TransparentColor             Transparent屬性
  •   TransparencyFactor
  •   Reflection                        Reflection屬性
  •   ReflectionFactor

當然，在實際應用中這些屬性並不一定需要全部讀取，可以根據情況選擇讀取即可。材質的讀取程式碼如下所述（簡略版）：

  1. void LoadMaterial(KFbxMesh* pMesh) 
  2. { 
  3.     int materialCount; 
  4.     KFbxNode* pNode; 
  5.     if(pMesh && pMesh->GetNode()) 
  6.     { 
  7.         pNode         = pMesh->GetNode(); 
  8.         materialCount = pNode->GetMaterialCount(); 
  9.     } 
  10.     if(materialCount > 0) 
  11.     { 
  12.         for(int materialIndex = 0 ; materialIndex < materialCount ; materialIndex++) 
  13.         { 
  14.             KFbxSurfaceMaterial* pSurfaceMaterial = pNode->GetMaterial(materialIndex); 
  15.             LoadMaterialAttribute(pSurfaceMaterial); 
  16.         } 
  17.     } 
  18. } 
  1. void LoadMaterialAttribute(KFbxSurfaceMaterial* pSurfaceMaterial) 
  2. { 
  3.     // Get the name of material
  4.     pSurfaceMaterial->GetName(); 
  5.     // Phong material
  6.     if(pSurfaceMaterial->GetClassId().Is(KFbxSurfacePhong::ClassId)) 
  7.     { 
  8.         // Ambient Color
  9.         fbxDouble3 = ((KFbxSurfacePhong*)pSurfaceMaterial)->Ambient; 
  10.         // ...
  11.         // Diffuse Color
  12.         fbxDouble3 =((KFbxSurfacePhong*)pSurfaceMaterial)->Diffuse; 
  13.         // ...
  14.         // Specular Color
  15.         fbxDouble3 =((KFbxSurfacePhong*)pSurfaceMaterial)->Specular; 
  16.         // ...
  17.         // Emissive Color
  18.         fbxDouble3 =((KFbxSurfacePhong*)pSurfaceMaterial)->Emissive; 
  19.         // ...
  20.         // Opacity
  21.         fbxDouble1 =((KFbxSurfacePhong*)pSurfaceMaterial)->TransparencyFactor; 
  22.         // ...
  23.         // Shininess
  24.         fbxDouble1 =((KFbxSurfacePhong*)pSurfaceMaterial)->Shininess; 
  25.         // ...
  26.         // Reflectivity
  27.         fbxDouble1 =((KFbxSurfacePhong*)pSurfaceMaterial)->ReflectionFactor; 
  28.         // ...
  29.         return; 
  30.     } 
  31.     // Lambert material
  32.     if(pSurfaceMaterial->GetClassId().Is(KFbxSurfaceLambert::ClassId)) 
  33.     { 
  34.         // Ambient Color
  35.         fbxDouble3=((KFbxSurfaceLambert*)pSurfaceMaterial)->Ambient; 
  36.         // ...
  37.         // Diffuse Color
  38.         fbxDouble3 =((KFbxSurfaceLambert*)pSurfaceMaterial)->Diffuse; 
  39.         // ...
  40.         // Emissive Color
  41.         fbxDouble3 =((KFbxSurfaceLambert*)pSurfaceMaterial)->Emissive; 
  42.         // ...
  43.         // Opacity
  44.         fbxDouble1 =((KFbxSurfaceLambert*)pSurfaceMaterial)->TransparencyFactor; 
  45.         // ...
  46.         return; 
  47.     } 
  48. } 

上述程式碼就可以完成對普通屬性載入。另外，材質中關聯的Texture也需要進行載入，這個操作一般與一個紋理管理器結合起來進行，以便對所有的Texture與Material之間形成合理的關聯，這一步的操作一般如下程式碼所述：

  1. void LoadMaterialTexture(KFbxSurfaceMaterial* pSurfaceMaterial) 
  2. { 
  3.     int textureLayerIndex; 
  4.     KFbxProperty pProperty; 
  5.     int texID; 
  6.     MaterialTextureDesc::MtlTexTypeEnum texType; 
  7.     for(textureLayerIndex = 0 ; textureLayerIndex < KFbxLayerElement::LAYERELEMENT_TYPE_TEXTURE_COUNT ; ++textureLayerIndex) 
  8.     { 
  9.         pProperty = pSurfaceMaterial->FindProperty(KFbxLayerElement::TEXTURE_CHANNEL_NAMES[textureLayerIndex]); 
  10.         if(pProperty.IsValid()) 
  11.         { 
  12.             int textureCount = pProperty.GetSrcObjectCount(KFbxTexture::ClassId); 
  13.             for(int j = 0 ; j < textureCount ; ++j) 
  14.             { 
  15.                 KFbxTexture* pTexture = KFbxCast<KFbxTexture>(pProperty.GetSrcObject(KFbxTexture::ClassId,j)); 
  16.                 if(pTexture) 
  17.                 { 
  18.                     // Use pTexture to load the attribute of current texture...
  19.                 } 
  20.             } 
  21.         } 
  22.     } 
  23. } 

5.3 硬體相關的材質與Effect

有過建模經驗的童鞋都知道，在3D Max或Maya中可以為某些材質指定特定的Shader來完成特定的效果，這些模型在儲存時也會儲存相應的硬體相關的Shader到FBX模型中，因而針對這樣屬性的材質也需要特別的程式碼來進行載入。FBX裡邊支援嵌入CG、HLSL、GLSL等主流著色語言，而著色語言的型別在解析時也很容易得到。

  1. void LoadMaterialAttribute(KFbxSurfaceMaterial* pSurfaceMaterial) 
  2. { 
  3.     KFbxImplementation* pImplementation; 
  4.     KString implemenationType; 
  5.     pImplementation = GetImplementation(pSurfaceMaterial , ImplementationHLSL); 
  6.     KString implemenationType = "HLSL"; 
  7.     if(pImplementation) 
  8.     { 
  9.         LoadMaterialEffect(pSurfaceMaterial , pImplementation , &implemenationType); 
  10.     } 
  11. } 

上述程式碼可以與前面的Material屬性讀取的程式碼合併。FBX一般通過一個型別為KFbxImplementation的物件將硬體相關的Shader與Material進行關聯，可以使用如上的程式碼實現兩者之間關聯的情況的獲取，其中ImplementationHLSL為一個標識HLSL型別Shader的巨集，若是CG則用ImplementationCGFX。如果當前Material中包含了HLSL型別Shader之後，那麼就可以得到一個不為空的KFbxImplementation型別的指標，在其中就可以解析該Shader的屬性，否則，則該指標為空，說明些材質關聯了其它類似的Shader或是不包含Shader。通過KFbxImplementation來獲取Effect對應的屬性的程式碼如下所示：

  1. void LoadMaterialEffect(KFbxSurfaceMaterial* pSurfaceMaterial ,const KFbxImplementation* pImplementation , KString* pImplemenationType) 
  2. { 
  3.     KFbxBindingTable const* lRootTable = pImplementation->GetRootTable(); 
  4.     fbxString lFileName                = lRootTable->DescAbsoluteURL.Get(); 
  5.     fbxString lTechniqueName           = lRootTable->DescTAG.Get(); 
  6.     // Name of the effect file
  7.     lFileName.Buffer(); 
  8.     KFbxBindingTable const* pBTable = pImplementation->GetRootTable(); 
  9.     size_t entryCount = pBTable->GetEntryCount(); 
  10.     for(size_t

    相關推薦

    基於FBX SDK的FBX模型解析與載入 -（三）

    6. 載入Camera和Light 在FBX模型中除了幾何資料外較為常用的資訊可能就是Camera和Light，雖然在遊戲中一般不直接從模型中得到這兩部分資訊，而是由引擎來提供，但是FBX中提供了對這些資訊儲存的支援。其實單純載入這兩部分的資訊很簡單，就像之前介紹的在整

    基於FBX SDK的FBX模型解析與載入 -（二）

    5. 載入材質  Material是一個模型渲染時必不可少的部分，當然，這些資訊也被存到了FBX之中（甚至各種貼圖等也可以直接內嵌到FBX內部），就需要從FBX中載入這些資訊以完成帶有材質的渲染。材質的載入可以與Mesh的載入相結合來完成，但更好的方法是獨立進行，這樣各模組

    基於FBX SDK的FBX模型解析與載入

    1. 簡介 FBX是Autodesk的一個用於跨平臺的免費三維資料交換的格式（最早不是由Autodesk開發，但後來被其收購），目前被 眾多的標準建模軟體所支援，在遊戲開發領域也常用來作為各種建模工具的標準匯出格式。Autodesk提供了基於C++（還有Python）的SDK來實現對FBX格式的各種讀寫、

    TensorFlow實現Softmax迴歸（模型儲存與載入）

    1 # -*- coding: utf-8 -*- 2 """ 3 Created on Thu Oct 18 18:02:26 2018 4 5 @author: zhen 6 """ 7 8 from tensorflow.examples.tutorials.mnist imp

    python opencv3.x中支援向量機（svm）模型儲存與載入問題

    親自驗證，可以解決svm的模型載入問題:     import numpy as np     from sklearn import datasets         &nb

    keras中訓練好的模型儲存與載入

    keras中的採用Sequential模式建立DNN並持久化保持、重新載入 def DNN_base_v1(X_train, y_train): model = models.Sequential() model.add(layers.Dense(96,

    XML筆記-xml解析與載入

    解析器把 XML 讀入記憶體，並把它轉換為可被 JavaScript 訪問的 XML DOM 物件。 微軟的 XML 解析器與其他瀏覽器中的解析器是有差異的。微軟的解析器支援對 XML 檔案和 XML 字串（文字）的載入，而其他瀏覽器使用單獨的解析器。不過，所有的解析器

    Keras 深度學習程式碼筆記——模型儲存與載入

    你可以使用model.save(filepath)將Keras模型和權重儲存在一個HDF5檔案中，該檔案將包含： 模型的結構，以便重構該模型 模型的權重 訓練配置（損失函式，優化器等） 優化器的狀態，以便於從上次訓練中斷的地方開始 使用keras.mod

    tensorflow 模型儲存與載入

    在訓練一個神經網路模型後，你會儲存這個模型未來使用或部署到產品中。所以，什麼是TF模型？TF模型基本包含網路設計或圖，與訓練得到的網路引數和變數。因此，TF模型具有兩個主要檔案： a)meta圖 這是一個擬定的快取，包含了這個TF圖完整資訊；如所有變數等

    Keras中的模型儲存與載入

    from keras.models import Sequential from keras.layers import Dense from keras.models import load_model model = Sequential() model.add(Dens

    [PyTorch 學習筆記] 7.1 模型儲存與載入

    > 本章程式碼： > > - [https://github.com/zhangxiann/PyTorch_Practice/blob/master/lesson7/model_save.py](https://github.com/zhangxiann/PyTorch_Practice/b

    第一次作業：基於Orange's OS系統的進程模型分析與心得體會

    直接 lld turn AR 信息保存 一次 tin 怎麽 ret 1一. 操作系統進程概念模型與進程控制塊概念淺析 1. 什麽是進程？ 　　 　　　　　　圖 1 - 1 （WIN10系統任務管理器對進程管理的圖形化界面） 計算機中的程序關於某數據集合上的一次運

    TensorFlow(十三)：模型的保存與載入

    定義 pla () feed variable ble cti 使用 pre 一：保存 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data #載入數據集 m

    tensorflow模型的儲存與載入

    1.儲存：(儲存的變數都是停放，tf.Variable()中的變數，變數一定要有名字) saver = tf.train.Saver() saver.run(sess,"./model4/line_model.ckpt")   2.檢視儲存的變數資訊：（將儲存的資訊打印

    Keras儲存與載入模型（JSON+HDF5）

    在Keras中，有時候需要對模型進行序列化與反序列化。進行模型序列化時，會將模型結果與模型權重儲存在不同的檔案中，模型權重通常儲存在HDF5檔案中，模型的結構可以儲存在JSON或者YAML檔案中。後二者方法大同小異，這裡以JSON為例說明一下Keras模型的儲存與載入。 from sklearn

    [Pytorch]Pytorch 儲存模型與載入模型(轉)

    轉自：知乎 目錄： 儲存模型與載入模型 凍結一部分引數，訓練另一部分引數 採用不同的學習率進行訓練 1.儲存模型與載入 簡單的儲存與載入方法： # 儲存整個網路 torch.save(net, PATH) # 儲存網路中的引數, 速度快，佔空間少 torch.save(n

    python sklearn svm模型的儲存與載入呼叫

    對於機器學習的一些模型，跑完之後，如果下一次測試又需要重新跑一遍模型是一件很繁瑣的事，這時候我們就需要儲存模型，再載入呼叫。 樓主發現有這些儲存模型的方法，網上有很多錯誤的例子，所以給大家在整理一下。(python3) 1.利用pickle import pickle

    [TensorFlow深度學習入門]實戰八·簡便方法實現TensorFlow模型引數儲存與載入（pb方式）

    [TensorFlow深度學習入門]實戰八·簡便方法實現TensorFlow模型引數儲存與載入（pb方式） 在上篇博文中，我們探索了TensorFlow模型引數儲存與載入實現方法採用的是儲存ckpt的方式。這篇博文我們會使用儲存為pd格式檔案來實現。 首先，我會在上篇博文基礎上，實現由c

    [TensorFlow深度學習入門]實戰七·簡便方法實現TensorFlow模型引數儲存與載入（ckpt方式）

    [TensorFlow深度學習入門]實戰七·簡便方法實現TensorFlow模型引數儲存與載入（ckpt方式） TensorFlow模型訓練的好網路引數如果想重複高效利用，模型引數儲存與載入是必須掌握的模組。本文提供一種簡單容易理解的方式來實現上述功能。參考部落格地址 備註： 本文采用的

    模型儲存，載入與呼叫

    模型儲存 BP： model.save(save_dir) SVM： from sklearn.externals import joblib joblib.dump(clf, save_dir) 模型載入 BP： from keras.models im