void MeshImporter::LoadNodeMesh(FbxNode* node, ID3D11Device3* device,
ID3D11DeviceContext3* context)
{
unsigned int numPolygons = 0;
unsigned int numVertices = 0;
unsigned int numIndices = 0;
unsigned int numPolygonVert = 0;
if (node->GetNodeAttribute() != NULL &&
node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eMesh)
{
//PrintNode(node);
// Create meshes
FbxMesh* fbxMesh = node->GetMesh();
numPolygons = fbxMesh->GetPolygonCount();
numIndices = fbxMesh->GetPolygonVertexCount();
numVertices = fbxMesh->GetControlPointsCount();
// Do not use indexed drawing method
numVertices = numIndices;
vector<Vertex> vertices(numVertices);
vector<unsigned int> indices(numIndices);
numPolygonVert = 3;
//assert(numPolygonVert == 3);
FbxVector4* controlPoints = fbxMesh->GetControlPoints();
int* indices_array = fbxMesh->GetPolygonVertices();
// Need to be changed for optimization
for (unsigned int i = 0; i < numIndices; i++)
{
indices[i] = indices_array[i];
vertices[i].pos.x = (float)fbxMesh->GetControlPointAt(indices[i]).mData[0];// / 1000.0f;
vertices[i].pos.y = (float)fbxMesh->GetControlPointAt(indices[i]).mData[1];// / 1000.0f;
vertices[i].pos.z = (float)fbxMesh->GetControlPointAt(indices[i]).mData[2];// / 1000.0f;
}
// For indexed drawing
/*for (unsigned int i = 0; i < numVertices; i++)
{
vertices[i].pos.x = (float)controlPoints[i].mData[0];
vertices[i].pos.y = (float)controlPoints[i].mData[1];
vertices[i].pos.z = (float)controlPoints[i].mData[2];
}*/
LoadUV(fbxMesh, &vertices[0], &indices[0]);
//OutputDebugStringA(("\n number of polygons: " + to_string(numPolygons) + " \n").c_str());
//OutputDebugStringA(("\n number of indices: " + to_string(numIndices) + " \n").c_str());
//OutputDebugStringA(("\n number of vertices: " + to_string(vertices.size()) + " \n").c_str());
// Read mesh base transform matrix
FbxAMatrix fbxGlobalMeshBaseMatrix = node->EvaluateGlobalTransform().Inverse().Transpose();
XMFLOAT4X4 globalMeshBaseMatrix;
for (int r = 0; r < 4; r++)
{
//PrintTab("Global mesh base mat: " + to_string(fbxGlobalMeshBaseMatrix.mData[r][0]));
for (int c = 0; c < 4; c++)
{
globalMeshBaseMatrix.m[r][c] = (float)fbxGlobalMeshBaseMatrix.mData[r][c];
}
}
// To be considered when importing Maya fbx model
//FbxAMatrix geoMatrix = GetTransformMatrix(node);
//ConvertFbxAMatrixToDXMatrix(&globalMeshBaseMatrix, fbxGlobalMeshBaseMatrix);
MeshEntry mesh;
mesh.vertices = vertices;
mesh.indices = indices;
mesh.numVertices = numVertices;
mesh.numIndices = numIndices;
mesh.fbxNode = node;
mesh.globalMeshBaseMatrix = globalMeshBaseMatrix;
// Load materials and textures
LoadMaterials(node, &mesh, device, context);
// Load weights
LoadWeight(fbxMesh, &mesh);
// Set to be clockwise, must be done after reading uvs, normals, weights and etc
for (auto it = mesh.vertices.begin(); it != mesh.vertices.end(); it += 3)
{
swap(*it, *(it + 2));
}
model->entries.push_back(mesh);
}
int numChild = node->GetChildCount();
for (int i = 0; i < numChild; i++)
{
LoadNodeMesh(node->GetChild(i), device, context);
}
}
void MeshImporter::LoadNodeMesh(FbxNode* node, ID3D11Device3* device,
ID3D11DeviceContext3* context)
{
unsigned int numPolygons = 0;
unsigned int numVertices = 0;
unsigned int numIndices = 0;
unsigned int numPolygonVert = 0;
if (node->GetNodeAttribute() != NULL &&
node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eMesh)
{
//PrintNode(node);
// Create meshes
FbxMesh* fbxMesh = node->GetMesh();
numPolygons = fbxMesh->GetPolygonCount();
numIndices = fbxMesh->GetPolygonVertexCount();
numVertices = fbxMesh->GetControlPointsCount();
// Do not use indexed drawing method
numVertices = numIndices;
vector<Vertex> vertices(numVertices);
vector<unsigned int> indices(numIndices);
numPolygonVert = 3;
//assert(numPolygonVert == 3);
FbxVector4* controlPoints = fbxMesh->GetControlPoints();
int* indices_array = fbxMesh->GetPolygonVertices();
// Need to be changed for optimization
for (unsigned int i = 0; i < numIndices; i++)
{
indices[i] = indices_array[i];
vertices[i].pos.x = (float)fbxMesh->GetControlPointAt(indices[i]).mData[0] / 10000.0f;
vertices[i].pos.y = (float)fbxMesh->GetControlPointAt(indices[i]).mData[1] / 10000.0f;
vertices[i].pos.z = (float)fbxMesh->GetControlPointAt(indices[i]).mData[2] / 10000.0f;
}
// For indexed drawing
/*for (unsigned int i = 0; i < numVertices; i++)
{
vertices[i].pos.x = (float)controlPoints[i].mData[0];// / 25.0f;
vertices[i].pos.y = (float)controlPoints[i].mData[1];// / 25.0f;
vertices[i].pos.z = (float)controlPoints[i].mData[2];// / 25.0f;
}*/
LoadUV(fbxMesh, &vertices[0], &indices[0]);
// Set to be clockwise, must be done after reading uvs and normals
for (auto it = vertices.begin(); it != vertices.end(); it += 3)
{
std::swap(*it, *(it + 2));
}
//OutputDebugStringA(("\n number of polygons: " + to_string(numPolygons) + " \n").c_str());
//OutputDebugStringA(("\n number of indices: " + to_string(numIndices) + " \n").c_str());
//OutputDebugStringA(("\n number of vertices: " + to_string(vertices.size()) + " \n").c_str());
ModelObj::MeshEntry mesh;
mesh.vertices = vertices;
mesh.indices = indices;
mesh.numVertices = numVertices;
mesh.numIndices = numIndices;
LoadMaterials(node, &mesh, device, context);
model->entries.push_back(mesh);
}
for (int i = 0; i < node->GetChildCount(); i++)
{
LoadNodeMesh(node->GetChild(i), device, context);
}
}
void importFBXNode(
FbxNode *node,
vector<Vector3> &vertices,
vector<Color> &colors,
vector<Vector2> &uvs,
vector<Vector3> &normals,
vector<uint32> &elements) {
FbxNode *childNode = 0;
int numKids = node->GetChildCount();
for ( int i=0 ; i<numKids ; i++)
{
childNode = node->GetChild(i);
FbxMesh *mesh = childNode->GetMesh();
if ( mesh != NULL )
{
auto offset = node->GetGeometricTranslation(FbxNode::eSourcePivot);
//================= Get Vertices ====================================
int baseline = vertices.size();
int numVerts = mesh->GetControlPointsCount();
for ( int j=0; j<numVerts; j++)
{
FbxVector4 vert = mesh->GetControlPointAt(j);
vertices.push_back(
Vector3(vert.mData[0], vert.mData[1], vert.mData[2])
/*+ Vector3(offset.mData[0], offset.mData[1], offset.mData[2])*/);
colors.push_back(Vector3(1, 1, 1));
uvs.push_back(Vector2(0, 0));
}
//================= Get Indices ====================================
int numIndices=mesh->GetPolygonVertexCount();
int *indicesRaw = mesh->GetPolygonVertices();
for (int j = 0; j < numIndices; j++) {
elements.push_back(indicesRaw[j] + baseline);
}
int cnt = 0;
int polygonCount = mesh->GetPolygonCount();
for (int j = 0; j < polygonCount; ++j) {
FbxLayerElementArrayTemplate<FbxVector2>* uvVertices= 0;
mesh->GetTextureUV(&uvVertices, FbxLayerElement::eTextureDiffuse);
for (int k = 0; k < mesh->GetPolygonSize(j); ++k) {
FbxVector2 uv = (*uvVertices)[mesh->GetTextureUVIndex(j, k)];
uvs[indicesRaw[cnt] + baseline].x = uv[0];
uvs[indicesRaw[cnt] + baseline].y = uv[1];
cnt++;
}
}
}
importFBXNode(childNode, vertices, colors, uvs, normals, elements);
}
}
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 FbxLoader::LoadAttribute(FbxNodeAttribute* pAttribute)
{
if (pAttribute->GetAttributeType() == FbxNodeAttribute::eMesh)
{
FbxMesh* pMesh = (FbxMesh*)pAttribute;
FbxVector4* IControlPoints = pMesh->GetControlPoints();
m_vertexCount = pMesh->GetControlPointsCount();
m_vertexBuffer = new float[m_vertexCount * 4];
for (int i = 0; i < m_vertexCount * 4; i+=4)
{
m_vertexBuffer[i] = (float)IControlPoints[i / 4].mData[0];
m_vertexBuffer[i + 1] = (float)IControlPoints[i / 4].mData[1];
m_vertexBuffer[i + 2] = (float)IControlPoints[i / 4].mData[2];
m_vertexBuffer[i + 3] = 1.0f;// IControlPoints[i / 4].mData[3];
}
int* pIndices = pMesh->GetPolygonVertices();
m_indexCount = pMesh->GetPolygonVertexCount();
m_indexBuffer = new uint32[m_indexCount];
for (int i = 0; i < m_indexCount; ++i)
{
m_indexBuffer[i] = pIndices[i];
}
FbxLayer* pLayer = pMesh->GetLayer(0);
if (pLayer != NULL)
{
FbxLayerElementNormal* pNormal = pLayer->GetNormals();
m_normalCount = pNormal->mDirectArray->GetCount();
m_normalBuffer = new float[m_normalCount * 3];
for (int i = 0; i < m_normalCount * 3; i+=3)
{
m_normalBuffer[i] = (float)(*pNormal->mDirectArray)[i / 3][0];
m_normalBuffer[i + 1] = (float)(*pNormal->mDirectArray)[i / 3][1];
m_normalBuffer[i + 2] = (float)(*pNormal->mDirectArray)[i / 3][2];
//m_normalBuffer[i + 3] = (*pNormal->mDirectArray)[i / 4][3];
}
FbxLayerElementUV* pUV = pLayer->GetUVs();
if (pUV->GetMappingMode() == FbxLayerElement::eByPolygonVertex)
{
if (pUV->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
m_uvCount = pUV->mIndexArray->GetCount();
m_uvBuffer = new float[m_uvCount * 2];
for (int i = 0; i < m_uvCount * 2; i+=2)
{
m_uvBuffer[i] = (float)(*pUV->mDirectArray)[(*pUV->mIndexArray)[i / 2]][0];
m_uvBuffer[i + 1] = (float)(*pUV->mDirectArray)[(*pUV->mIndexArray)[i / 2]][1];
}
}
else
{
m_uvCount = pUV->mDirectArray->GetCount();
m_uvBuffer = new float[m_uvCount * 2];
for (int i = 0; i < m_uvCount * 2; i += 2)
{
m_uvBuffer[i] = (float)(*pUV->mDirectArray)[i / 2][0];
m_uvBuffer[i + 1] = (float)(*pUV->mDirectArray)[i / 2][1];
}
}
}
else
{
if (pUV->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
m_uvCount = pUV->mIndexArray->GetCount();
m_uvBuffer = new float[m_uvCount * 2];
for (int i = 0; i < m_uvCount * 2; i+=2)
{
m_uvBuffer[i] = (float)(*pUV->mDirectArray)[(*pUV->mIndexArray)[i / 2]][0];
m_uvBuffer[i + 1] = (float)(*pUV->mDirectArray)[(*pUV->mIndexArray)[i / 2]][1];
}
}
else
{
m_uvCount = pUV->mDirectArray->GetCount();
m_uvBuffer = new float[m_uvCount * 2];
for (int i = 0; i < m_uvCount * 2; i+=2)
{
m_uvBuffer[i] = (float)(*pUV->mDirectArray)[i / 2][0];
m_uvBuffer[i + 1] = (float)(*pUV->mDirectArray)[i / 2][1];
}
}
}
}
}
}