void FBXImporter::ReadUVs(FBXMeshData* fbxMeshData, int controlPointIndex, int index, int textureUVIndex, int uvLayer)
{
FbxMesh* mesh = fbxMeshData->mMesh;
vector<XMFLOAT2>& uvs = fbxMeshData->mUVs;
if (uvLayer >= 2 || mesh->GetElementUVCount() <= uvLayer)
{
return;
}
FbxGeometryElementUV* vertexUV = mesh->GetElementUV(0);
switch (vertexUV->GetMappingMode())
{
case FbxGeometryElement::eByControlPoint:
switch (vertexUV->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
{
XMFLOAT2 uv;
FbxVector2 fbxUV = vertexUV->GetDirectArray().GetAt(controlPointIndex);
uv.x = static_cast<float>(fbxUV[0]);
uv.y = static_cast<float>(fbxUV[1]);
uvs.push_back(uv);
}
break;
case FbxGeometryElement::eIndexToDirect:
{
int id = vertexUV->GetIndexArray().GetAt(controlPointIndex);
FbxVector2 fbxUV = vertexUV->GetDirectArray().GetAt(id);
XMFLOAT2 uv;
uv.x = static_cast<float>(fbxUV[0]);
uv.y = static_cast<float>(fbxUV[1]);
uvs.push_back(uv);
}
break;
default:
break;
}
case FbxGeometryElement::eByPolygonVertex:
switch (vertexUV->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
case FbxGeometryElement::eIndexToDirect:
#if USE_RIGHT_HAND
uvs[index].x = static_cast<float>(vertexUV->GetDirectArray().GetAt(textureUVIndex)[0]);
#else
uvs[index].x = 1.0f - static_cast<float>(vertexUV->GetDirectArray().GetAt(textureUVIndex)[0]);
#endif
uvs[index].y = 1.0f - static_cast<float>(vertexUV->GetDirectArray().GetAt(textureUVIndex)[1]);
break;
default:
break;
}
break;
}
}
bool FillData(ModelData* someData,FbxNode* aNode, AnimationData* aAnimation)
{
FbxMesh* mesh = aNode->GetMesh();
if (mesh == nullptr || !aNode)
return false;
const int lPolygonCount = mesh->GetPolygonCount();
// Count the polygon count of each material
FbxLayerElementArrayTemplate<int>* lMaterialIndice = NULL;
FbxGeometryElement::EMappingMode lMaterialMappingMode = FbxGeometryElement::eNone;
if (mesh->GetElementMaterial())
{
lMaterialIndice = &mesh->GetElementMaterial()->GetIndexArray();
lMaterialMappingMode = mesh->GetElementMaterial()->GetMappingMode();
if (lMaterialIndice && lMaterialMappingMode == FbxGeometryElement::eByPolygon)
{
FBX_ASSERT(lMaterialIndice->GetCount() == lPolygonCount);
if (lMaterialIndice->GetCount() == lPolygonCount)
{
// Count the faces of each material
for (int lPolygonIndex = 0; lPolygonIndex < lPolygonCount; ++lPolygonIndex)
{
const int lMaterialIndex = lMaterialIndice->GetAt(lPolygonIndex);
lMaterialIndex;
/*if (someData->mSubMeshes[lMaterialIndex] == NULL)
{
someData->mSubMeshes[lMaterialIndex] = new ModelData::SubMesh;
}
someData->mSubMeshes[lMaterialIndex]->TriangleCount += 1;*/
}
// Make sure we have no "holes" (NULL) in the mSubMeshes table. This can happen
// if, in the loop above, we resized the mSubMeshes by more than one slot.
/*for (int i = 0; i < someData->mSubMeshes.Count(); i++)
{
if (someData->mSubMeshes[i] == NULL)
someData->mSubMeshes[i] = new ModelData::SubMesh;
}*/
// Record the offset (how many vertex)
const int lMaterialCount = someData->mSubMeshes.Size();
lMaterialCount;
int lOffset = 0;
/*for (int lIndex = 0; lIndex < lMaterialCount; ++lIndex)
{
someData->mSubMeshes[lIndex]->IndexOffset = lOffset;
lOffset += someData->mSubMeshes[lIndex]->TriangleCount * 3;
// This will be used as counter in the following procedures, reset to zero
someData->mSubMeshes[lIndex]->TriangleCount = 0;
}*/
FBX_ASSERT(lOffset == lPolygonCount * 3);
}
}
}
// All faces will use the same material.
if (someData->mSubMeshes.Size() == 0)
{
if (someData->mSubMeshes.GetCapacity() == 0)
{
someData->mSubMeshes.Init(1);
}
someData->mSubMeshes.RemoveAll();
someData->mSubMeshes.AddEmptyObject();
someData->mSubMeshes[0] = new ModelData::SubMesh();
}
bool hasNormalMap = false;
const int lMaterialCount = aNode->GetMaterialCount();
for (int lMaterialIndex = 0; lMaterialIndex < lMaterialCount; ++lMaterialIndex)
{
FbxSurfaceMaterial * lMaterial = aNode->GetMaterial(lMaterialIndex);
if (lMaterial && !lMaterial->GetUserDataPtr())
{
TextureInfo diffuseInfo;
GetMaterialProperty(lMaterial,FbxSurfaceMaterial::sDiffuse,FbxSurfaceMaterial::sDiffuseFactor,diffuseInfo.myFileName);
diffuseInfo.myType = DIFFUSE;
if(diffuseInfo.myFileName.empty() == false)
{
someData->myTextures.push_back(diffuseInfo);
}
TextureInfo normalInfo;
GetMaterialProperty(lMaterial,FbxSurfaceMaterial::sNormalMap,FbxSurfaceMaterial::sBumpFactor,normalInfo.myFileName);
hasNormalMap = normalInfo.myFileName.empty() == false;
normalInfo.myType = NORMALMAP;
if(normalInfo.myFileName.empty() == false)
{
someData->myTextures.push_back(normalInfo);
hasNormalMap = true;
}
TextureInfo roughnessInfo;
GetMaterialProperty(lMaterial,FbxSurfaceMaterial::sSpecular,FbxSurfaceMaterial::sSpecularFactor,roughnessInfo.myFileName);
roughnessInfo.myType = ROUGHNESS;
if(roughnessInfo.myFileName.empty() == false)
{
someData->myTextures.push_back(roughnessInfo);
}
TextureInfo substanceInfo;
GetMaterialProperty(lMaterial,FbxSurfaceMaterial::sReflection,FbxSurfaceMaterial::sReflectionFactor,substanceInfo.myFileName);
substanceInfo.myType = SUBSTANCE;
if(substanceInfo.myFileName.empty() == false)
{
someData->myTextures.push_back(substanceInfo);
}
TextureInfo ambientInfo;
GetMaterialProperty(lMaterial, FbxSurfaceMaterial::sAmbient, FbxSurfaceMaterial::sAmbientFactor, ambientInfo.myFileName);
ambientInfo.myType = AO;
if (substanceInfo.myFileName.empty() == false)
{
someData->myTextures.push_back(ambientInfo);
}
}
}
// Congregate all the data of a mesh to be cached in VBOs.
// If normal or UV is by polygon vertex, record all vertex attributes by polygon vertex.'
someData->mHasNormal = mesh->GetElementNormalCount() > 0;
someData->mHasUV = mesh->GetElementUVCount() > 0;
someData->myHasBiNormal = mesh->GetElementBinormalCount() > 0;
FbxSkin * lSkinDeformer = (FbxSkin *)mesh->GetDeformer(0, FbxDeformer::eSkin);
someData->myHasSkinweights = lSkinDeformer != nullptr;
if(hasNormalMap && someData->myHasBiNormal == false)
{
mesh->GenerateTangentsDataForAllUVSets();
someData->myHasBiNormal = mesh->GetElementBinormalCount() > 0;
}
someData->myHasTangents = mesh->GetElementTangentCount() > 0;
FbxGeometryElement::EMappingMode lNormalMappingMode = FbxGeometryElement::eNone;
FbxGeometryElement::EMappingMode lUVMappingMode = FbxGeometryElement::eNone;
if (someData->mHasNormal)
{
lNormalMappingMode = mesh->GetElementNormal(0)->GetMappingMode();
if (lNormalMappingMode == FbxGeometryElement::eNone)
{
someData->mHasNormal = false;
}
if (someData->mHasNormal && lNormalMappingMode != FbxGeometryElement::eByControlPoint)
{
someData->mAllByControlPoint = false;
}
}
if (someData->mHasUV)
{
lUVMappingMode = mesh->GetElementUV(0)->GetMappingMode();
if (lUVMappingMode == FbxGeometryElement::eNone)
{
someData->mHasUV = false;
}
if (someData->mHasUV && lUVMappingMode != FbxGeometryElement::eByControlPoint)
{
someData->mAllByControlPoint = false;
}
}
// Allocate the array memory, by control point or by polygon vertex.
int lPolygonVertexCount = mesh->GetControlPointsCount();
//if (!someData->my)
{
ModelData::Layout newLayout;
newLayout.myType = ModelData::VERTEX_POS;
newLayout.mySize = VERTEX_STRIDE;
newLayout.myOffset = 0;
someData->myLayout.Add(newLayout);
lPolygonVertexCount = lPolygonCount * TRIANGLE_VERTEX_COUNT;
}
int stride = VERTEX_STRIDE;
size_t size = lPolygonVertexCount * VERTEX_STRIDE;
//float * lVertices = new float[lPolygonVertexCount * VERTEX_STRIDE];
unsigned int * lIndices = new unsigned int[lPolygonCount * TRIANGLE_VERTEX_COUNT];
someData->myIndexCount = lPolygonCount * TRIANGLE_VERTEX_COUNT;
//float * lNormals = NULL;
if (someData->mHasNormal)
{
ModelData::Layout newLayout;
newLayout.myType = ModelData::VERTEX_NORMAL;
newLayout.mySize = NORMAL_STRIDE;
newLayout.myOffset = stride*4;
someData->myLayout.Add(newLayout);
stride += NORMAL_STRIDE;
size += lPolygonVertexCount * NORMAL_STRIDE;
//lNormals = new float[lPolygonVertexCount * NORMAL_STRIDE];
}
//float * lUVs = NULL;
FbxStringList lUVNames;
mesh->GetUVSetNames(lUVNames);
const char * lUVName = NULL;
if (someData->mHasUV && lUVNames.GetCount())
{
ModelData::Layout newLayout;
newLayout.myType = ModelData::VERTEX_UV;
newLayout.mySize = UV_STRIDE;
newLayout.myOffset = stride*4;
someData->myLayout.Add(newLayout);
stride += UV_STRIDE;
size += lPolygonVertexCount * UV_STRIDE;
//lUVs = new float[lPolygonVertexCount * UV_STRIDE];
lUVName = lUVNames[0];
}
if (someData->myHasBiNormal)
{
ModelData::Layout newLayout;
newLayout.myType = ModelData::VERTEX_BINORMAL;
newLayout.mySize = BINORMAL_STRIDE;
newLayout.myOffset = stride*4;
someData->myLayout.Add(newLayout);
stride += BINORMAL_STRIDE;
size += lPolygonVertexCount * BINORMAL_STRIDE;
//lUVs = new float[lPolygonVertexCount * UV_STRIDE];
}
if (someData->myHasTangents)
{
ModelData::Layout newLayout;
newLayout.myType = ModelData::VERTEX_TANGENT;
newLayout.mySize = TANGENT_STRIDE;
newLayout.myOffset = stride*4;
someData->myLayout.Add(newLayout);
stride += TANGENT_STRIDE;
size += lPolygonVertexCount * TANGENT_STRIDE;
//lUVs = new float[lPolygonVertexCount * UV_STRIDE];
}
if (someData->myHasSkinweights)
{
ModelData::Layout newLayout;
newLayout.myType = ModelData::VERTEX_SKINWEIGHTS;
newLayout.mySize = SKINWEIGHT_STRIDE;
newLayout.myOffset = stride*4;
someData->myLayout.Add(newLayout);
stride += SKINWEIGHT_STRIDE;
size += lPolygonVertexCount * SKINWEIGHT_STRIDE;
newLayout.myType = ModelData::VERTEX_BONEID;
newLayout.mySize = BONEID_STRIDE;
newLayout.myOffset = stride*4;
someData->myLayout.Add(newLayout);
stride += BONEID_STRIDE;
size += lPolygonVertexCount * BONEID_STRIDE;
//lUVs = new float[lPolygonVertexCount * UV_STRIDE];
}
float * lVertices = new float[size];
FbxAMatrix globalPos;
FbxVector4* weights = nullptr;
FbxVectorTemplate4<int>* bones = nullptr;
FbxTime time = static_cast<FbxTime>(0.0f);
if(someData->myHasSkinweights)
{
weights = new FbxVector4[mesh->GetControlPointsCount()];
bones = new FbxVectorTemplate4<int>[mesh->GetControlPointsCount()];
ComputeLinearDeformation(globalPos,mesh,weights,bones,aAnimation);
}
const FbxGeometryElementBinormal * lBiNormalElement = NULL;
const FbxGeometryElementTangent * lTangentElement = NULL;
if (someData->myHasBiNormal)
{
lBiNormalElement = mesh->GetElementBinormal(0);
}
if (someData->myHasTangents)
{
lTangentElement = mesh->GetElementTangent(0);
}
// Populate the array with vertex attribute, if by control point.
const FbxVector4 * lControlPoints = mesh->GetControlPoints();
FbxVector4 lCurrentVertex;
FbxVector4 lCurrentNormal;
FbxVector4 lCurrentBiNormal;
FbxVector4 lCurrentTangent;
FbxVector2 lCurrentUV;
if (someData->mAllByControlPoint)
{
const FbxGeometryElementNormal * lNormalElement = NULL;
const FbxGeometryElementUV * lUVElement = NULL;
if (someData->mHasNormal)
{
lNormalElement = mesh->GetElementNormal(0);
}
if (someData->mHasUV)
{
lUVElement = mesh->GetElementUV(0);
}
for (int lIndex = 0; lIndex < lPolygonVertexCount; ++lIndex)
{
int currentIndex = lIndex * stride;
int addedSize = VERTEX_STRIDE;
// Save the vertex position.
lCurrentVertex = lControlPoints[lIndex];
CU::Vector4f position(static_cast<float>(lCurrentVertex[0]),
static_cast<float>(lCurrentVertex[1]),
static_cast<float>(lCurrentVertex[2]),
1);
CU::Matrix44f fixMatrix;
fixMatrix = CU::Matrix44<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1,0,0));
position = position*fixMatrix;
lVertices[currentIndex] = position.x;
lVertices[currentIndex + 1] = position.y;
lVertices[currentIndex + 2] = position.z;
lVertices[currentIndex + 3] = 1;
// Save the normal.
if (someData->mHasNormal)
{
int lNormalIndex = lIndex;
if (lNormalElement->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
lNormalIndex = lNormalElement->GetIndexArray().GetAt(lIndex);
}
lCurrentNormal = lNormalElement->GetDirectArray().GetAt(lNormalIndex);
CU::Vector3f normal( static_cast<float>(lCurrentNormal[0]), static_cast<float>(lCurrentNormal[1]), static_cast<float>(lCurrentNormal[2]));
normal = normal*CU::Matrix33<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1, 0, 0));
lVertices[currentIndex + addedSize] = normal.x;
lVertices[currentIndex + addedSize + 1] = normal.y;
lVertices[currentIndex + addedSize + 2] = normal.z;
lVertices[currentIndex + addedSize + 3] = 0;
addedSize += NORMAL_STRIDE;
}
// Save the UV.
if (someData->mHasUV)
{
int lUVIndex = lIndex;
if (lUVElement->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
lUVIndex = lUVElement->GetIndexArray().GetAt(lIndex);
}
lCurrentUV = lUVElement->GetDirectArray().GetAt(lUVIndex);
lVertices[currentIndex + addedSize] = static_cast<float>(lCurrentUV[0]);
lVertices[currentIndex + addedSize + 1] = static_cast<float>(lCurrentUV[1])*-1.0f;
addedSize += 2;
}
if (someData->myHasBiNormal)
{
int lBinormIndexIndex = lIndex;
if (lBiNormalElement->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
lBinormIndexIndex = lBiNormalElement->GetIndexArray().GetAt(lIndex);
}
lCurrentBiNormal = lBiNormalElement->GetDirectArray().GetAt(lBinormIndexIndex);
//mesh->GetElementBinormal(lPolygonIndex, lVerticeIndex, lCurrentNormal);
//lCurrentNormal = lCurrentNormal
CU::Vector3f normal( static_cast<float>(lCurrentBiNormal[0]), static_cast<float>(lCurrentBiNormal[1]), static_cast<float>(lCurrentBiNormal[2]));
normal = normal*CU::Matrix33<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1, 0, 0));
if (CU::Length(normal) != 0.f)
CU::Normalize(normal);
lVertices[currentIndex + addedSize] = normal.x;
lVertices[currentIndex + addedSize + 1] = normal.y;
lVertices[currentIndex + addedSize + 2] = normal.z;
lVertices[currentIndex + addedSize + 3] = 0;
addedSize += BINORMAL_STRIDE;
}
if (someData->myHasTangents)
{
int lBinormIndexIndex = lIndex;
if (lTangentElement->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
lBinormIndexIndex = lTangentElement->GetIndexArray().GetAt(lIndex);
}
lCurrentTangent = lTangentElement->GetDirectArray().GetAt(lBinormIndexIndex);
//lCurrentNormal = lCurrentNormal
CU::Vector3f normal( static_cast<float>(lCurrentTangent[0]), static_cast<float>(lCurrentTangent[1]), static_cast<float>(lCurrentTangent[2]));
normal = normal*CU::Matrix33<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1, 0, 0));
if (CU::Length(normal) != 0.f)
CU::Normalize(normal);
lVertices[currentIndex + addedSize] = normal.x;
lVertices[currentIndex + addedSize + 1] = normal.y;
lVertices[currentIndex + addedSize + 2] = normal.z;
lVertices[currentIndex + addedSize + 3] = 0;
addedSize += TANGENT_STRIDE;
}
if(someData->myHasSkinweights)
{
FbxVector4 currentWeights = weights[lIndex];
//currentWeights.Normalize();
lVertices[currentIndex + addedSize] = static_cast<float>(currentWeights[0]);
lVertices[currentIndex + addedSize + 1] = static_cast<float>(currentWeights[1]);
lVertices[currentIndex + addedSize + 2] = static_cast<float>(currentWeights[2]);
lVertices[currentIndex + addedSize + 3] = static_cast<float>(currentWeights[3]);
addedSize += SKINWEIGHT_STRIDE;
FbxVectorTemplate4<int> currentBones = bones[lIndex];
lVertices[currentIndex + addedSize] = static_cast<float>(currentBones[0]);
lVertices[currentIndex + addedSize + 1] = static_cast<float>(currentBones[1]);
lVertices[currentIndex + addedSize + 2] = static_cast<float>(currentBones[2]);
lVertices[currentIndex + addedSize + 3] = static_cast<float>(currentBones[3]);
addedSize += BONEID_STRIDE;
}
}
}
int lVertexCount = 0;
for (int lPolygonIndex = 0; lPolygonIndex < lPolygonCount; ++lPolygonIndex)
{
// The material for current face.
int lMaterialIndex = 0;
if (lMaterialIndice && lMaterialMappingMode == FbxGeometryElement::eByPolygon)
{
lMaterialIndex = lMaterialIndice->GetAt(lPolygonIndex);
}
// Where should I save the vertex attribute index, according to the material
const int lIndexOffset = someData->mSubMeshes[lMaterialIndex]->IndexOffset +
someData->mSubMeshes[lMaterialIndex]->TriangleCount * 3;
for (int lVerticeIndex = TRIANGLE_VERTEX_COUNT-1; lVerticeIndex > -1; --lVerticeIndex)
{
const int lControlPointIndex = mesh->GetPolygonVertex(lPolygonIndex, lVerticeIndex);
int vertexIndex = lIndexOffset + (TRIANGLE_VERTEX_COUNT-1) - lVerticeIndex;
if (someData->mAllByControlPoint)
{
lIndices[vertexIndex] = static_cast<unsigned int>(lControlPointIndex);
}
// Populate the array with vertex attribute, if by polygon vertex.
else
{
lIndices[vertexIndex] = static_cast<unsigned int>(lVertexCount);
lCurrentVertex = lControlPoints[lControlPointIndex];
int addedSize = VERTEX_STRIDE;
int currentIndex = lVertexCount * stride;
CU::Vector4f position(static_cast<float>(lCurrentVertex[0]),
static_cast<float>(lCurrentVertex[1]),
static_cast<float>(lCurrentVertex[2]),
1);
//fixMatrix
CU::Matrix44f fixMatrix;
fixMatrix = CU::Matrix44<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1, 0, 0));
position = position*fixMatrix;
lVertices[currentIndex] = position.x;
lVertices[currentIndex + 1] = position.y;
lVertices[currentIndex + 2] = position.z;
lVertices[currentIndex + 3] = 0;
if (someData->mHasNormal)
{
mesh->GetPolygonVertexNormal(lPolygonIndex, lVerticeIndex, lCurrentNormal);
CU::Vector3f normal( static_cast<float>(lCurrentNormal[0]), static_cast<float>(lCurrentNormal[1]), static_cast<float>(lCurrentNormal[2]));
normal = normal*CU::Matrix33<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1, 0, 0));
if (CU::Length(normal) != 0.f)
CU::Normalize(normal);
lVertices[currentIndex + addedSize] = normal.x;
lVertices[currentIndex + addedSize + 1] = normal.y;
lVertices[currentIndex + addedSize + 2] = normal.z;
lVertices[currentIndex + addedSize + 3] = 0;
addedSize += NORMAL_STRIDE;
}
if (someData->mHasUV)
{
bool lUnmappedUV;
mesh->GetPolygonVertexUV(lPolygonIndex, lVerticeIndex, lUVName, lCurrentUV, lUnmappedUV);
lVertices[currentIndex + addedSize] = static_cast<float>(lCurrentUV[0]);
lVertices[currentIndex + addedSize + 1] = static_cast<float>(lCurrentUV[1])*-1.0f;
addedSize += UV_STRIDE;
}
if (someData->myHasBiNormal)
{
int lBinormIndexIndex = lVerticeIndex;
if (lBiNormalElement->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
lBinormIndexIndex = lBiNormalElement->GetIndexArray().GetAt(lVerticeIndex);
}
lCurrentBiNormal = lBiNormalElement->GetDirectArray().GetAt(lBinormIndexIndex);
CU::Vector3f normal( static_cast<float>(lCurrentBiNormal[0]), static_cast<float>(lCurrentBiNormal[1]), static_cast<float>(lCurrentBiNormal[2]));
normal = normal*CU::Matrix33<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1, 0, 0));
if (CU::Length(normal) != 0.f)
CU::Normalize(normal);
lVertices[currentIndex + addedSize] = normal.x;
lVertices[currentIndex + addedSize + 1] = normal.y;
lVertices[currentIndex + addedSize + 2] = normal.z;
lVertices[currentIndex + addedSize + 3] = 0;
addedSize += BINORMAL_STRIDE;
}
if (someData->myHasTangents)
{
int lBinormIndexIndex = lVerticeIndex;
if (lTangentElement->GetReferenceMode() == FbxLayerElement::eIndexToDirect)
{
lBinormIndexIndex = lTangentElement->GetIndexArray().GetAt(lVerticeIndex);
}
lCurrentTangent = lTangentElement->GetDirectArray().GetAt(lBinormIndexIndex);
mesh->GetPolygonVertexNormal(lPolygonIndex, lVerticeIndex, lCurrentNormal);
CU::Vector3f normal( static_cast<float>(lCurrentTangent[0]), static_cast<float>(lCurrentTangent[1]), static_cast<float>(lCurrentTangent[2]));
normal = normal*CU::Matrix33<float>::CreateReflectionMatrixAboutAxis(CU::Vector3f(1, 0, 0));
if (CU::Length(normal) != 0.f)
CU::Normalize(normal);
lVertices[currentIndex + addedSize] = normal.x;
lVertices[currentIndex + addedSize + 1] = normal.y;
lVertices[currentIndex + addedSize + 2] = normal.z;
lVertices[currentIndex + addedSize + 3] = 0;
addedSize += TANGENT_STRIDE;
}
if(someData->myHasSkinweights)
{
FbxVector4 currentWeights = weights[lControlPointIndex];
FbxVectorTemplate4<int> currentBones = bones[lControlPointIndex];
for(int l = 0;l < 4;++l)
{
if(currentBones[l] == -1)
{
currentWeights[l] = 0.0f;
}
}
currentWeights.Normalize();
lVertices[currentIndex + addedSize] = static_cast<float>(currentWeights[0]);
lVertices[currentIndex + addedSize + 1] = static_cast<float>(currentWeights[1]);
lVertices[currentIndex + addedSize + 2] = static_cast<float>(currentWeights[2]);
lVertices[currentIndex + addedSize + 3] = static_cast<float>(currentWeights[3]);
addedSize += SKINWEIGHT_STRIDE;
lVertices[currentIndex + addedSize] = *(float*)¤tBones[0];
lVertices[currentIndex + addedSize + 1] = *(float*)¤tBones[1];
lVertices[currentIndex + addedSize + 2] = *(float*)¤tBones[2];
lVertices[currentIndex + addedSize + 3] = *(float*)¤tBones[3];
addedSize += BONEID_STRIDE;
}
}
++lVertexCount;
}
someData->mSubMeshes[lMaterialIndex]->TriangleCount += 1;
}
someData->myVertexCount = lVertexCount;
someData->myVertexStride = stride;
someData->myVertexBuffer = lVertices;
someData->myIndicies = lIndices;
if(weights)
{
delete [] weights;
delete [] bones;
}
return true;
}
//===============================================================================================================================
void FBXLoader::LoadMesh(FbxNode* node)
{
FBXSubsets* newSubset = new FBXSubsets();
FbxMesh* mesh = node->GetMesh();
newSubset->mPolygonCount = mesh->GetPolygonCount();
int vertexCounter = 0;
// http://stackoverflow.com/questions/30170521/how-to-read-in-fbx-2014-indices-properly-for-directx
/*newSubset->mTriangles.reserve(newSubset->mPolygonCount);
for (uint32 i = 0; i < newSubset->mPolygonCount; ++i)
{
XMFLOAT3 normal[3];
XMFLOAT3 tangent[3];
XMFLOAT3 binormal[3];
XMFLOAT2 uv[3][2];
ZShadeSandboxMesh::FBXTriangle triangle;
newSubset->mTriangles.push_back(triangle);
for (uint32 j = 0; j < 3; ++j)
{
int controlPointIndex = mesh->GetPolygonVertex(i, j);
ZShadeSandboxMesh::PhysicalPoint* ctlPoint = mControlPoints[controlPointIndex];
LoadVertexNormal(mesh, controlPointIndex, vertexCounter, 0, normal[j]);
// Only have diffuse texture
for (int k = 0; k < 1; ++k)
{
LoadVertexTexture(mesh, controlPointIndex, mesh->GetTextureUVIndex(i, j), k, uv[j][k]);
}
//LoadVertexTangent(mesh, controlPointIndex, vertexCounter, 0, tangent[j]);
ZShadeSandboxMesh::VertexNormalTexBlend temp;
temp.position = ctlPoint->position;
temp.normal = normal[j];
//temp.tangent = tangent[j];
temp.texture = uv[j][0];
// Copy the blending from each control point
for (uint32 i = 0; i < ctlPoint->blendingInfo.size(); ++i)
{
ZShadeSandboxMesh::VertexBlendingInfo blendingInfo;
blendingInfo.blendingIndex = ctlPoint->blendingInfo[i].blendingIndex;
blendingInfo.blendingWeight = ctlPoint->blendingInfo[i].blendingWeight;
temp.vertexBlendingInfos.push_back(blendingInfo);
}
// Sort blending info to remove duplicate vertices
temp.SortBlendingInfoByWeight();
newSubset->mVertices.push_back(temp);
newSubset->mTriangles.back().indices.push_back(vertexCounter);
++vertexCounter;
}
}*/
/*int* indices = mesh->GetPolygonVertices();
for (int ind = 0; ind < mesh->GetPolygonVertexCount(); ind++)
{
newSubset->mIndices.push_back(indices[ind]);
string indice = ZShadeSandboxGlobal::Convert::ConvertToString<int>(indices[ind]);
outIndiceFile << "indice: " << indice << "\n";
}*/
for (uint32 polygonID = 0; polygonID < newSubset->mPolygonCount; ++polygonID)
{
int polyVertCount = mesh->GetPolygonSize(polygonID);
for (uint32 polygonVertexID = 0; polygonVertexID < polyVertCount; ++polygonVertexID)
{
ZShadeSandboxMesh::VertexNormalTexBlend temp;
// Initialize the vertex data
temp.position = XMFLOAT3(0, 0, 0);
temp.normal = XMFLOAT3(0, 0, 0);
temp.texture = XMFLOAT2(0, 0);
temp.tangent = XMFLOAT3(0, 0, 0);
int controlPointIndex = mesh->GetPolygonVertex(polygonID, polygonVertexID);
ZShadeSandboxMesh::PhysicalPoint* ctlPoint = mControlPoints[controlPointIndex];
//
// Load vertex position
//
temp.position = ctlPoint->position;
//
// Load vertex normal
//
int normElementCount = mesh->GetElementNormalCount();
for (int normElement = 0; normElement < normElementCount; normElement++)
{
XMFLOAT3 normal;
if (LoadVertexNormal(mesh, controlPointIndex, vertexCounter, normElement, normal))
{
temp.normal = normal;
break;
}
}
//
// Load vertex UV
//
int uvElementCount = mesh->GetElementUVCount();
for (int uvElement = 0; uvElement < uvElementCount; uvElement++)
{
XMFLOAT2 uv;
if (LoadVertexTexture(mesh, controlPointIndex, mesh->GetTextureUVIndex(polygonID, polygonVertexID), uvElement, uv))
{
temp.texture = uv;
break;
}
}
//
// Load vertex tangent
//
int tangentElementCount = mesh->GetElementTangentCount();
for (int tangentElement = 0; tangentElement < tangentElementCount; tangentElement++)
{
XMFLOAT3 tangent;
if (LoadVertexTangent(mesh, controlPointIndex, vertexCounter, tangentElement, tangent))
{
temp.tangent = tangent;
break;
}
}
//
// Load vertex blending information for skinning
//
// Copy the blending from each control point
for (uint32 i = 0; i < ctlPoint->blendingInfo.size(); ++i)
{
ZShadeSandboxMesh::VertexBlendingInfo blendingInfo;
blendingInfo.blendingIndex = ctlPoint->blendingInfo[i].blendingIndex;
blendingInfo.blendingWeight = ctlPoint->blendingInfo[i].blendingWeight;
temp.vertexBlendingInfos.push_back(blendingInfo);
}
// Sort blending info to remove duplicate vertices
temp.SortBlendingInfoByWeight();
//
// Make sure the vertices are unique and get the index
//
vector<ZShadeSandboxMesh::VertexNormalTexBlend>& uniqueVerts = newSubset->mVertices;
size_t size = uniqueVerts.size();
uint32 indice;
for (indice = 0; indice < size; indice++)
{
if (temp.EqualsPosNormTex(uniqueVerts[indice]))
{
break;
}
}
if (indice == size)
{
uniqueVerts.push_back(temp);
string pos = ZShadeSandboxGlobal::Convert::ConvertFloat3ToString(temp.position);
outVertexFile << "vertex: " << pos << "\n";
}
newSubset->mIndices.push_back(indice);
string indice_str = ZShadeSandboxGlobal::Convert::ConvertToString<uint32>(indice);
outIndiceFile << "indice: " << indice_str << "\n";
++vertexCounter;
}
}
// Now mControlPoints has served its purpose so we can free its memory
for(auto itr = mControlPoints.begin(); itr != mControlPoints.end(); ++itr)
{
delete itr->second;
}
mControlPoints.clear();
// Adding a new subset to the mesh
mSubsets.push_back(newSubset);
}
//--------------------------------------------------------------------------
void SaveMesh(FbxNode* pNode, const VeDirectoryPtr& spDest) noexcept
{
Mesh kMesh;
FbxMesh* pMesh = (FbxMesh*)pNode->GetNodeAttribute();
kMesh.m_kName = pNode->GetName();
kMesh.m_stFaces = pMesh->GetPolygonCount();
kMesh.m_stVerts = kMesh.m_stFaces * 3;
kMesh.m_kIndices.resize(kMesh.m_stVerts);
kMesh.m_kPosition.resize(kMesh.m_stVerts);
kMesh.m_kNormals.resize(pMesh->GetElementNormalCount());
for (auto& v : kMesh.m_kNormals)
{
v.resize(kMesh.m_stVerts);
}
kMesh.m_kTexcoords.resize(pMesh->GetElementUVCount());
for (auto& v : kMesh.m_kTexcoords)
{
v.resize(kMesh.m_stVerts);
}
kMesh.m_kColors.resize(pMesh->GetElementVertexColorCount());
for (auto& v : kMesh.m_kColors)
{
v.resize(kMesh.m_stVerts);
}
int element_mat = -1;
for (int i(0); i < pMesh->GetElementMaterialCount(); ++i)
{
FbxGeometryElementMaterial* lMaterialElement = pMesh->GetElementMaterial(i);
if (lMaterialElement->GetMappingMode() == FbxGeometryElement::eByPolygon)
{
element_mat = i;
break;
}
}
if (element_mat >= 0)
{
kMesh.m_kAttributes.resize(kMesh.m_stFaces);
}
FbxVector4* lControlPoints = pMesh->GetControlPoints();
for (int i(0); i < (int)(kMesh.m_stFaces); ++i)
{
int lPolygonSize = pMesh->GetPolygonSize(i);
VE_ASSERT_ALWAYS(lPolygonSize == 3);
for (int j(0); j < lPolygonSize; ++j)
{
uint32_t u32Index = i * 3 + j;
kMesh.m_kIndices[u32Index] = u32Index;
int lControlPointIndex = pMesh->GetPolygonVertex(i, j);
auto& pos = kMesh.m_kPosition[u32Index];
pos.x = (float)lControlPoints[lControlPointIndex][0];
pos.y = (float)lControlPoints[lControlPointIndex][1];
pos.z = (float)lControlPoints[lControlPointIndex][2];
for (int k(0); k < (int)(kMesh.m_kColors.size()); ++k)
{
FbxColor c;
FbxGeometryElementVertexColor* leVtxc = pMesh->GetElementVertexColor(k);
switch (leVtxc->GetMappingMode())
{
default:
break;
case FbxGeometryElement::eByControlPoint:
switch (leVtxc->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
c = leVtxc->GetDirectArray().GetAt(lControlPointIndex);
break;
case FbxGeometryElement::eIndexToDirect:
{
int id = leVtxc->GetIndexArray().GetAt(lControlPointIndex);
c = leVtxc->GetDirectArray().GetAt(id);
}
break;
default:
break; // other reference modes not shown here!
}
break;
case FbxGeometryElement::eByPolygonVertex:
{
switch (leVtxc->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
c = leVtxc->GetDirectArray().GetAt(u32Index);
break;
case FbxGeometryElement::eIndexToDirect:
{
int id = leVtxc->GetIndexArray().GetAt(u32Index);
c = leVtxc->GetDirectArray().GetAt(id);
}
break;
default:
break; // other reference modes not shown here!
}
}
break;
case FbxGeometryElement::eByPolygon: // doesn't make much sense for UVs
case FbxGeometryElement::eAllSame: // doesn't make much sense for UVs
case FbxGeometryElement::eNone: // doesn't make much sense for UVs
break;
}
auto& color = kMesh.m_kColors[k][u32Index];
color.x = (float)c[0];
color.y = (float)c[1];
color.z = (float)c[2];
color.w = (float)c[3];
}
for (int k(0); k < (int)(kMesh.m_kTexcoords.size()); ++k)
{
FbxVector2 uv;
FbxGeometryElementUV* leUV = pMesh->GetElementUV(k);
switch (leUV->GetMappingMode())
{
default:
break;
case FbxGeometryElement::eByControlPoint:
switch (leUV->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
uv = leUV->GetDirectArray().GetAt(lControlPointIndex);
break;
case FbxGeometryElement::eIndexToDirect:
{
int id = leUV->GetIndexArray().GetAt(lControlPointIndex);
uv = leUV->GetDirectArray().GetAt(id);
}
break;
default:
break; // other reference modes not shown here!
}
break;
case FbxGeometryElement::eByPolygonVertex:
{
int lTextureUVIndex = pMesh->GetTextureUVIndex(i, j);
switch (leUV->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
case FbxGeometryElement::eIndexToDirect:
{
uv = leUV->GetDirectArray().GetAt(lTextureUVIndex);
}
break;
default:
break; // other reference modes not shown here!
}
}
break;
case FbxGeometryElement::eByPolygon: // doesn't make much sense for UVs
case FbxGeometryElement::eAllSame: // doesn't make much sense for UVs
case FbxGeometryElement::eNone: // doesn't make much sense for UVs
break;
}
auto& texcoord = kMesh.m_kTexcoords[k][u32Index];
texcoord.x = (float)uv[0];
texcoord.y = (float)uv[1];
}
for (int k(0); k < (int)(kMesh.m_kNormals.size()); ++k)
{
FbxVector4 n;
FbxGeometryElementNormal* leNormal = pMesh->GetElementNormal(k);
if (leNormal->GetMappingMode() == FbxGeometryElement::eByPolygonVertex)
{
switch (leNormal->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
n = leNormal->GetDirectArray().GetAt(u32Index);
break;
case FbxGeometryElement::eIndexToDirect:
{
int id = leNormal->GetIndexArray().GetAt(u32Index);
n = leNormal->GetDirectArray().GetAt(id);
}
break;
default:
break; // other reference modes not shown here!
}
}
auto& normal = kMesh.m_kNormals[k][u32Index];
normal.x = (float)n[0];
normal.y = (float)n[1];
normal.z = (float)n[2];
}
if (element_mat >= 0)
{
FbxGeometryElementMaterial* lMaterialElement = pMesh->GetElementMaterial(element_mat);
FbxSurfaceMaterial* lMaterial = NULL;
int lMatId = -1;
lMaterial = pMesh->GetNode()->GetMaterial(lMaterialElement->GetIndexArray().GetAt(i));
lMatId = lMaterialElement->GetIndexArray().GetAt(i);
kMesh.m_kAttributes[i] = lMatId;
}
}
}
kMesh.Process();
kMesh.Save(spDest);
}