基于FBX SDK的FBX模型解析与加载 -（一）

http://blog.csdn.net/bugrunner/article/details/7210511

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的网站上进行获得最新的版本http://usa.autodesk.com/adsk/servlet/index?siteID=123112&id=7478532(需要填些基本信息注册下)。安装之后在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

[cpp] view plain copy
  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.   
  10.     if(mpFBXSDKManager == NULL)  
  11.     {  
  12.        return false;  
  13.     }  
  14.   
  15.     // Create an IOSettings object  
  16.     KFbxIOSettings* ios = KFbxIOSettings::Create(mpFBXSDKManager , IOSROOT);  
  17.     mpFBXSDKManager->SetIOSettings(ios);  
  18.   
  19.     // Load plug-ins from the executable directory  
  20.     KString lExtension = "dll";  
  21.     KString lPath = KFbxGetApplicationDirectory();  
  22.     mpFBXSDKManager->LoadPluginsDirectory(lPath.Buffer() , lExtension.Buffer());  
  23.   
  24.     // Create the entity that hold the whole Scene  
  25.     mpFBXSDKScene = KFbxScene::Create(mpFBXSDKManager , "");  
  26.   
  27.     return true;  
  28. }  

 FbxScene的初始化

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

 在完成了对KFbxScene的初始化操作之后即可以从其中得到整个模型的所有信息。由于FBX的是采用了类似于树的结构来进行存储，因而就很容易使用类似于树的递归方法来遍历其中的每个结点，并根据结点的属性选择合适的处理操作，下述代码就完成了从根结点开始的全局遍历：

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

上述代码比较简单，直接传入由KFbxScene中获得的根结点之后即可遍历到每一个子结点。在FBX的存储中，每个父结点可以包含多个子结点，但每个子结点只有一个根结点，而且这其中的联系是双向的，这样很方便，比如在处理Skeleton时就常常需要从子结点中得到父结点的matrix等信息，而这种双向关系使得这些操作很容易实现。注意，上述代码中有pNode->GetNodeAttribute()检查操作是必须的，因为并不是所有的结点都有相应的属性（Attribute也是以子结点的方式关联到当前的结点上的，因而可能为空）。

4. 加载几何网格

FBX对几何网格支持得还是很好的，Nurbes、Polygon、Triangle等均可以存储。不过为了简化加载和处理时的操作，最好直接在FBX导出插件中选择一种统一的模式。比如可以在导出生成FBX时选中Triangluation的属性，那么FBX导出插件会自动把所有的Nurbes、Polygon三角化为三角形进行存储。当然，这个过程也可以在模型进行加载时来进行。这样在得到的FBX中就只有三角形这样一种网格模型，方便了加载的操作。模型的几何数据主要包括以下部分：

  • Vertex      组成网格的顶点信息，这一部分是必须的。
  • Color       每个顶点的颜色。
  • Normal    每个顶点所对应的法向，是由FBX导出插件计算生成，可以是逐面片或逐顶点。
  • Tangent   每个顶点所对应的切向，是由FBX导出插件计算生成，可以是逐面片或逐顶点。
  • UV每个顶点所对应的贴图UV值，一般来说，每个UV对应一个Layer，一个顶点可以有多个UV通道，这在读入的时间需要进行判断

几何网格的加载比较简单，直接递归地从根结点来遍历整个graph，检测当前的结点是否为eMESH的属性，若是即处理其中的几何数据，主要代码如下所示：

[cpp] view plain copy
  1. void ProcessMesh(KFbxNode* pNode)  
  2. {  
  3.     KFbxMesh* pMesh = pNode->GetMesh();  
  4.     if(pMesh == NULL)  
  5.     {  
  6.         return;  
  7.     }  
  8.   
  9.     D3DXVECTOR3 vertex[3];  
  10.     D3DXVECTOR4 color[3];  
  11.     D3DXVECTOR3 normal[3];  
  12.     D3DXVECTOR3 tangent[3];  
  13.     D3DXVECTOR2 uv[3][2];  
  14.   
  15.     int triangleCount = pMesh->GetPolygonCount();  
  16.     int vertexCounter = 0;  
  17.   
  18.     for(int i = 0 ; i < triangleCount ; ++i)  
  19.     {  
  20.         for(int j = 0 ; j < 3 ; j++)  
  21.         {  
  22.             int ctrlPointIndex = pMesh->GetPolygonVertex(i , j);  
  23.   
  24.             // Read the vertex  
  25.             ReadVertex(pMesh , ctrlPointIndex , &vertex[j]);  
  26.   
  27.             // Read the color of each vertex  
  28.             ReadColor(pMesh , ctrlPointIndex , vertexCounter , &color[j]);  
  29.   
  30.             // Read the UV of each vertex  
  31.             for(int k = 0 ; k < 2 ; ++k)  
  32.             {  
  33.                 ReadUV(pMesh , ctrlPointIndex , pMesh->GetTextureUVIndex(i, j) , k , &(uv[j][k]));  
  34.             }  
  35.   
  36.             // Read the normal of each vertex  
  37.             ReadNormal(pMesh , ctrlPointIndex , vertexCounter , &normal[j]);  
  38.   
  39.             // Read the tangent of each vertex  
  40.             ReadTangent(pMesh , ctrlPointIndex , vertexCounter , &tangent[j]);  
  41.   
  42.             vertexCounter++;  
  43.         }  
  44.   
  45.         // 根据读入的信息组装三角形，并以某种方式使用即可，比如存入到列表中、保存到文件等...  
  46.     }  
  47. }  

上述代码完成了从一个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中的信息，因而增加这样的一个变量来进行记录。

读入顶点：

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

读入Color:

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

读入UV:

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

读入Normal:

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

读入Tangent:

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

上述几个Normal、Tangent、UV等信息读取的函数的实现其实都差不多，首先需要判断有没有相应的Layer关联在当前的Mesh中，若有则获取其地址，然后根据不同的映射方式使用不同的方法从内存中读取相应的值即可。

完成了这些基本几何信息的读取之后即可以使用其进行渲染了：


【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/nafio/p/9137423.html