// Converts a CC mesh to an FBX mesh
static FbxNode* ToFbxMesh(ccGenericMesh* mesh, FbxScene* pScene, QString filename, size_t meshIndex)
{
if (!mesh)
return 0;
FbxNode* lNode = FbxNode::Create(pScene,qPrintable(mesh->getName()));
FbxMesh* lMesh = FbxMesh::Create(pScene, qPrintable(mesh->getName()));
lNode->SetNodeAttribute(lMesh);
ccGenericPointCloud* cloud = mesh->getAssociatedCloud();
if (!cloud)
return 0;
unsigned vertCount = cloud->size();
unsigned faceCount = mesh->size();
// Create control points.
{
lMesh->InitControlPoints(vertCount);
FbxVector4* lControlPoints = lMesh->GetControlPoints();
for (unsigned i=0; i<vertCount; ++i)
{
const CCVector3* P = cloud->getPoint(i);
lControlPoints[i] = FbxVector4(P->x,P->y,P->z);
//lControlPoints[i] = FbxVector4(P->x,P->z,-P->y); //DGM: see loadFile (Y and Z are inverted)
}
}
ccMesh* asCCMesh = 0;
if (mesh->isA(CC_TYPES::MESH))
asCCMesh = static_cast<ccMesh*>(mesh);
// normals
if (mesh->hasNormals())
{
FbxGeometryElementNormal* lGeometryElementNormal = lMesh->CreateElementNormal();
if (mesh->hasTriNormals())
{
// We want to have one normal per vertex of each polygon,
// so we set the mapping mode to eByPolygonVertex.
lGeometryElementNormal->SetMappingMode(FbxGeometryElement::eByPolygonVertex);
lGeometryElementNormal->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
lGeometryElementNormal->GetIndexArray().SetCount(faceCount*3);
if (asCCMesh)
{
NormsIndexesTableType* triNorms = asCCMesh->getTriNormsTable();
assert(triNorms);
for (unsigned i=0; i<triNorms->currentSize(); ++i)
{
const CCVector3& N = ccNormalVectors::GetNormal(triNorms->getValue(i));
FbxVector4 Nfbx(N.x,N.y,N.z);
lGeometryElementNormal->GetDirectArray().Add(Nfbx);
}
for (unsigned j=0; j<faceCount; ++j)
{
int i1,i2,i3;
asCCMesh->getTriangleNormalIndexes(j,i1,i2,i3);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+0, i1);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+1, i2);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+2, i3);
}
}
else
{
for (unsigned j=0; j<faceCount; ++j)
{
//we can't use the 'NormsIndexesTable' so we save all the normals of all the vertices
CCVector3 Na,Nb,Nc;
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Na.x,Na.y,Na.z));
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Nb.x,Nb.y,Nb.z));
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Nc.x,Nc.y,Nc.z));
mesh->getTriangleNormals(j,Na,Nb,Nc);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+0, static_cast<int>(j)*3+0);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+1, static_cast<int>(j)*3+1);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+2, static_cast<int>(j)*3+2);
}
}
}
else
{
// We want to have one normal for each vertex (or control point),
// so we set the mapping mode to eByControlPoint.
lGeometryElementNormal->SetMappingMode(FbxGeometryElement::eByControlPoint);
// The first method is to set the actual normal value
// for every control point.
lGeometryElementNormal->SetReferenceMode(FbxGeometryElement::eDirect);
for (unsigned i=0; i<vertCount; ++i)
{
const CCVector3& N = cloud->getPointNormal(i);
FbxVector4 Nfbx(N.x,N.y,N.z);
lGeometryElementNormal->GetDirectArray().Add(Nfbx);
}
}
}
else
{
ccLog::Warning("[FBX] Mesh has no normal! You can manually compute them (select it then call \"Edit > Normals > Compute\")");
}
// Set material mapping.
bool hasMaterial = false;
if (asCCMesh && asCCMesh->hasMaterials())
{
const ccMaterialSet* matSet = asCCMesh->getMaterialSet();
size_t matCount = matSet->size();
//check if we have textures
bool hasTextures = asCCMesh->hasTextures();
if (hasTextures)
{
//check that we actually have materials with textures as well!
hasTextures = false;
for (size_t i=0; i<matCount; ++i)
{
ccMaterial::CShared mat = matSet->at(i);
if (mat->hasTexture())
{
hasTextures = true;
break;
}
}
}
static const char gDiffuseElementName[] = "DiffuseUV";
// Create UV for Diffuse channel
if (hasTextures)
{
FbxGeometryElementUV* lUVDiffuseElement = lMesh->CreateElementUV(gDiffuseElementName);
assert(lUVDiffuseElement != 0);
lUVDiffuseElement->SetMappingMode(FbxGeometryElement::eByPolygonVertex);
lUVDiffuseElement->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
//fill Direct Array
const TextureCoordsContainer* texCoords = asCCMesh->getTexCoordinatesTable();
assert(texCoords);
if (texCoords)
{
unsigned count = texCoords->currentSize();
lUVDiffuseElement->GetDirectArray().SetCount(static_cast<int>(count));
for (unsigned i=0; i<count; ++i)
{
const float* uv = texCoords->getValue(i);
lUVDiffuseElement->GetDirectArray().SetAt(i,FbxVector2(uv[0],uv[1]));
}
}
//fill Indexes Array
assert(asCCMesh->hasPerTriangleTexCoordIndexes());
if (asCCMesh->hasPerTriangleTexCoordIndexes())
{
unsigned triCount = asCCMesh->size();
lUVDiffuseElement->GetIndexArray().SetCount(static_cast<int>(3*triCount));
for (unsigned j=0; j<triCount; ++j)
{
int t1=0, t2=0, t3=0;
asCCMesh->getTriangleTexCoordinatesIndexes(j, t1, t2, t3);
lUVDiffuseElement->GetIndexArray().SetAt(j*3+0,t1);
lUVDiffuseElement->GetIndexArray().SetAt(j*3+1,t2);
lUVDiffuseElement->GetIndexArray().SetAt(j*3+2,t3);
}
}
}
//Textures used in this file
QMap<QString,QString> texFilenames;
//directory to save textures (if any)
QFileInfo info(filename);
QString textDirName = info.baseName() + QString(".fbm");
QDir baseDir = info.absoluteDir();
QDir texDir = QDir(baseDir.absolutePath() + QString("/") + textDirName);
for (size_t i=0; i<matCount; ++i)
{
ccMaterial::CShared mat = matSet->at(i);
FbxSurfacePhong *lMaterial = FbxSurfacePhong::Create(pScene, qPrintable(mat->getName()));
const ccColor::Rgbaf& emission = mat->getEmission();
const ccColor::Rgbaf& ambient = mat->getAmbient();
const ccColor::Rgbaf& diffuse = mat->getDiffuseFront();
const ccColor::Rgbaf& specular = mat->getDiffuseFront();
lMaterial->Emissive.Set(FbxDouble3(emission.r,emission.g,emission.b));
lMaterial->Ambient .Set(FbxDouble3( ambient.r, ambient.g, ambient.b));
lMaterial->Diffuse .Set(FbxDouble3( diffuse.r, diffuse.g, diffuse.b));
lMaterial->Specular.Set(FbxDouble3(specular.r,specular.g,specular.b));
lMaterial->Shininess = mat->getShininessFront();
lMaterial->ShadingModel.Set("Phong");
if (hasTextures && mat->hasTexture())
{
QString texFilename = mat->getTextureFilename();
//texture has not already been processed
if (!texFilenames.contains(texFilename))
{
//if necessary, we (try to) create a subfolder to store textures
if (!texDir.exists())
{
texDir = baseDir;
if (texDir.mkdir(textDirName))
{
texDir.cd(textDirName);
}
else
{
textDirName = QString();
ccLog::Warning("[FBX] Failed to create subfolder '%1' to store texture files (files will be stored next to the .fbx file)");
}
}
QFileInfo fileInfo(texFilename);
QString baseTexName = fileInfo.fileName();
//add extension
QString extension = QFileInfo(texFilename).suffix();
if (fileInfo.suffix().isEmpty())
baseTexName += QString(".png");
QString absoluteFilename = texDir.absolutePath() + QString("/") + baseTexName;
ccLog::PrintDebug(QString("[FBX] Material '%1' texture: %2").arg(mat->getName()).arg(absoluteFilename));
texFilenames[texFilename] = absoluteFilename;
}
//mat.texture.save(absoluteFilename);
// Set texture properties.
FbxFileTexture* lTexture = FbxFileTexture::Create(pScene,"DiffuseTexture");
assert(!texFilenames[texFilename].isEmpty());
lTexture->SetFileName(qPrintable(texFilenames[texFilename]));
lTexture->SetTextureUse(FbxTexture::eStandard);
lTexture->SetMappingType(FbxTexture::eUV);
lTexture->SetMaterialUse(FbxFileTexture::eModelMaterial);
lTexture->SetSwapUV(false);
lTexture->SetTranslation(0.0, 0.0);
lTexture->SetScale(1.0, 1.0);
lTexture->SetRotation(0.0, 0.0);
lTexture->UVSet.Set(FbxString(gDiffuseElementName)); // Connect texture to the proper UV
// don't forget to connect the texture to the corresponding property of the material
lMaterial->Diffuse.ConnectSrcObject(lTexture);
}
int matIndex = lNode->AddMaterial(lMaterial);
assert(matIndex == static_cast<int>(i));
}
//don't forget to save the texture files
{
for (QMap<QString,QString>::ConstIterator it = texFilenames.begin(); it != texFilenames.end(); ++it)
{
const QImage image = ccMaterial::GetTexture(it.key());
image.mirrored().save(it.value());
}
texFilenames.clear(); //don't need this anymore!
}
// Create 'triangle to material index' mapping
{
FbxGeometryElementMaterial* lMaterialElement = lMesh->CreateElementMaterial();
lMaterialElement->SetMappingMode(FbxGeometryElement::eByPolygon);
lMaterialElement->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
}
hasMaterial = true;
}
// colors
if (cloud->hasColors())
{
FbxGeometryElementVertexColor* lGeometryElementVertexColor = lMesh->CreateElementVertexColor();
lGeometryElementVertexColor->SetMappingMode(FbxGeometryElement::eByControlPoint);
lGeometryElementVertexColor->SetReferenceMode(FbxGeometryElement::eDirect);
lGeometryElementVertexColor->GetDirectArray().SetCount(vertCount);
for (unsigned i=0; i<vertCount; ++i)
{
const colorType* C = cloud->getPointColor(i);
FbxColor col( static_cast<double>(C[0])/ccColor::MAX,
static_cast<double>(C[1])/ccColor::MAX,
static_cast<double>(C[2])/ccColor::MAX );
lGeometryElementVertexColor->GetDirectArray().SetAt(i,col);
}
if (!hasMaterial)
{
//it seems that we have to create a fake material in order for the colors to be displayed (in Unity and FBX Review at least)!
FbxSurfacePhong *lMaterial = FbxSurfacePhong::Create(pScene, "ColorMaterial");
lMaterial->Emissive.Set(FbxDouble3(0,0,0));
lMaterial->Ambient.Set(FbxDouble3(0,0,0));
lMaterial->Diffuse.Set(FbxDouble3(1,1,1));
lMaterial->Specular.Set(FbxDouble3(0,0,0));
lMaterial->Shininess = 0;
lMaterial->ShadingModel.Set("Phong");
FbxGeometryElementMaterial* lMaterialElement = lMesh->CreateElementMaterial();
lMaterialElement->SetMappingMode(FbxGeometryElement::eAllSame);
lMaterialElement->SetReferenceMode(FbxGeometryElement::eDirect);
lNode->AddMaterial(lMaterial);
}
}
// Create polygons
{
for (unsigned j=0; j<faceCount; ++j)
{
const CCLib::TriangleSummitsIndexes* tsi = mesh->getTriangleIndexes(j);
int matIndex = hasMaterial ? asCCMesh->getTriangleMtlIndex(j) : -1;
lMesh->BeginPolygon(matIndex);
lMesh->AddPolygon(tsi->i1);
lMesh->AddPolygon(tsi->i2);
lMesh->AddPolygon(tsi->i3);
lMesh->EndPolygon();
}
}
return lNode;
}
/**
* Adds an Fbx Mesh to the FBX scene based on the data in the given FStaticLODModel
*/
FbxNode* FFbxExporter::CreateMesh(const USkeletalMesh* SkelMesh, const TCHAR* MeshName)
{
const FSkeletalMeshResource* SkelMeshResource = SkelMesh->GetImportedResource();
const FStaticLODModel& SourceModel = SkelMeshResource->LODModels[0];
const int32 VertexCount = SourceModel.NumVertices;
// Verify the integrity of the mesh.
if (VertexCount == 0) return NULL;
// Copy all the vertex data from the various chunks to a single buffer.
// Makes the rest of the code in this function cleaner and easier to maintain.
TArray<FSoftSkinVertex> Vertices;
SourceModel.GetVertices(Vertices);
if (Vertices.Num() != VertexCount) return NULL;
FbxMesh* Mesh = FbxMesh::Create(Scene, TCHAR_TO_UTF8(MeshName));
// Create and fill in the vertex position data source.
Mesh->InitControlPoints(VertexCount);
FbxVector4* ControlPoints = Mesh->GetControlPoints();
for (int32 VertIndex = 0; VertIndex < VertexCount; ++VertIndex)
{
FVector Position = Vertices[VertIndex].Position;
ControlPoints[VertIndex] = Converter.ConvertToFbxPos(Position);
}
// Create Layer 0 to hold the normals
FbxLayer* LayerZero = Mesh->GetLayer(0);
if (LayerZero == NULL)
{
Mesh->CreateLayer();
LayerZero = Mesh->GetLayer(0);
}
// Create and fill in the per-face-vertex normal data source.
// We extract the Z-tangent and drop the X/Y-tangents which are also stored in the render mesh.
FbxLayerElementNormal* LayerElementNormal= FbxLayerElementNormal::Create(Mesh, "");
LayerElementNormal->SetMappingMode(FbxLayerElement::eByControlPoint);
// Set the normal values for every control point.
LayerElementNormal->SetReferenceMode(FbxLayerElement::eDirect);
for (int32 VertIndex = 0; VertIndex < VertexCount; ++VertIndex)
{
FVector Normal = Vertices[VertIndex].TangentZ;
FbxVector4 FbxNormal = Converter.ConvertToFbxPos(Normal);
LayerElementNormal->GetDirectArray().Add(FbxNormal);
}
LayerZero->SetNormals(LayerElementNormal);
// Create and fill in the per-face-vertex texture coordinate data source(s).
// Create UV for Diffuse channel.
const int32 TexCoordSourceCount = SourceModel.NumTexCoords;
TCHAR UVChannelName[32];
for (int32 TexCoordSourceIndex = 0; TexCoordSourceIndex < TexCoordSourceCount; ++TexCoordSourceIndex)
{
FbxLayer* Layer = Mesh->GetLayer(TexCoordSourceIndex);
if (Layer == NULL)
{
Mesh->CreateLayer();
Layer = Mesh->GetLayer(TexCoordSourceIndex);
}
if (TexCoordSourceIndex == 1)
{
FCString::Sprintf(UVChannelName, TEXT("LightMapUV"));
}
else
{
FCString::Sprintf(UVChannelName, TEXT("DiffuseUV"));
}
FbxLayerElementUV* UVDiffuseLayer = FbxLayerElementUV::Create(Mesh, TCHAR_TO_UTF8(UVChannelName));
UVDiffuseLayer->SetMappingMode(FbxLayerElement::eByControlPoint);
UVDiffuseLayer->SetReferenceMode(FbxLayerElement::eDirect);
// Create the texture coordinate data source.
for (int32 TexCoordIndex = 0; TexCoordIndex < VertexCount; ++TexCoordIndex)
{
const FVector2D& TexCoord = Vertices[TexCoordIndex].UVs[TexCoordSourceIndex];
UVDiffuseLayer->GetDirectArray().Add(FbxVector2(TexCoord.X, -TexCoord.Y + 1.0));
}
Layer->SetUVs(UVDiffuseLayer, FbxLayerElement::eTextureDiffuse);
}
FbxLayerElementMaterial* MatLayer = FbxLayerElementMaterial::Create(Mesh, "");
MatLayer->SetMappingMode(FbxLayerElement::eByPolygon);
MatLayer->SetReferenceMode(FbxLayerElement::eIndexToDirect);
LayerZero->SetMaterials(MatLayer);
// Create the per-material polygons sets.
TArray<uint32> Indices;
SourceModel.MultiSizeIndexContainer.GetIndexBuffer(Indices);
int32 SectionCount = SourceModel.Sections.Num();
for (int32 SectionIndex = 0; SectionIndex < SectionCount; ++SectionIndex)
{
const FSkelMeshSection& Section = SourceModel.Sections[SectionIndex];
int32 MatIndex = Section.MaterialIndex;
// Static meshes contain one triangle list per element.
int32 TriangleCount = Section.NumTriangles;
// Copy over the index buffer into the FBX polygons set.
for (int32 TriangleIndex = 0; TriangleIndex < TriangleCount; ++TriangleIndex)
{
Mesh->BeginPolygon(MatIndex);
for (int32 PointIndex = 0; PointIndex < 3; PointIndex++)
{
Mesh->AddPolygon(Indices[Section.BaseIndex + ((TriangleIndex * 3) + PointIndex)]);
}
Mesh->EndPolygon();
}
}
// Create and fill in the vertex color data source.
FbxLayerElementVertexColor* VertexColor = FbxLayerElementVertexColor::Create(Mesh, "");
VertexColor->SetMappingMode(FbxLayerElement::eByControlPoint);
VertexColor->SetReferenceMode(FbxLayerElement::eDirect);
FbxLayerElementArrayTemplate<FbxColor>& VertexColorArray = VertexColor->GetDirectArray();
LayerZero->SetVertexColors(VertexColor);
for (int32 VertIndex = 0; VertIndex < VertexCount; ++VertIndex)
{
FLinearColor VertColor = Vertices[VertIndex].Color.ReinterpretAsLinear();
VertexColorArray.Add( FbxColor(VertColor.R, VertColor.G, VertColor.B, VertColor.A ));
}
FbxNode* MeshNode = FbxNode::Create(Scene, TCHAR_TO_UTF8(MeshName));
MeshNode->SetNodeAttribute(Mesh);
// Add the materials for the mesh
int32 MaterialCount = SkelMesh->Materials.Num();
for(int32 MaterialIndex = 0; MaterialIndex < MaterialCount; ++MaterialIndex)
{
UMaterialInterface* MatInterface = SkelMesh->Materials[MaterialIndex].MaterialInterface;
FbxSurfaceMaterial* FbxMaterial = NULL;
if(MatInterface && !FbxMaterials.Find(MatInterface))
{
FbxMaterial = ExportMaterial(MatInterface);
}
else
{
// Note: The vertex data relies on there being a set number of Materials.
// If you try to add the same material again it will not be added, so create a
// default material with a unique name to ensure the proper number of materials
TCHAR NewMaterialName[MAX_SPRINTF]=TEXT("");
FCString::Sprintf( NewMaterialName, TEXT("Fbx Default Material %i"), MaterialIndex );
FbxMaterial = FbxSurfaceLambert::Create(Scene, TCHAR_TO_UTF8(NewMaterialName));
((FbxSurfaceLambert*)FbxMaterial)->Diffuse.Set(FbxDouble3(0.72, 0.72, 0.72));
}
MeshNode->AddMaterial(FbxMaterial);
}
int32 SavedMaterialCount = MeshNode->GetMaterialCount();
check(SavedMaterialCount == MaterialCount);
return MeshNode;
}
void Material::ExportMaterials(FbxScene* scene, FbxMesh* mesh, const ImporterMesh& importedMesh, const ImporterMaterial* importedMaterials)
{
for (int i = 0; i < importedMesh.material_count; i++)
{
FbxNode* node = mesh->GetNode();
FbxString materialName = importedMaterials[importedMesh.material_Id[i]].name;
FbxString shadingName;
FbxDouble3 diffuseColor(importedMaterials[importedMesh.material_Id[i]].diffuse[0], importedMaterials[importedMesh.material_Id[i]].diffuse[1], importedMaterials[importedMesh.material_Id[i]].diffuse[2]);
FbxDouble3 ambientColor(importedMaterials[importedMesh.material_Id[i]].ambient[0], importedMaterials[importedMesh.material_Id[i]].ambient[1], importedMaterials[importedMesh.material_Id[i]].ambient[2]);
FbxDouble3 emissiveColor(importedMaterials[importedMesh.material_Id[i]].incandescence[0], importedMaterials[importedMesh.material_Id[i]].incandescence[1], importedMaterials[importedMesh.material_Id[i]].incandescence[2]);
FbxDouble3 transparencyColor(importedMaterials[importedMesh.material_Id[i]].transparency_color[0], importedMaterials[importedMesh.material_Id[i]].transparency_color[1], importedMaterials[importedMesh.material_Id[i]].transparency_color[2]);
FbxDouble3 specularColor(importedMaterials[importedMesh.material_Id[i]].specular[0], importedMaterials[importedMesh.material_Id[i]].specular[1] , importedMaterials[importedMesh.material_Id[i]].specular[2]);
const char* pathName = "C://Users/Litet/Documents/GitHub/SmallGameProject/FBX Export/FBX Export/";
// Lambert
if (importedMaterials[importedMesh.material_Id[i]].mtrl_type == 0)
{
shadingName = "Lambert";
FbxSurfaceLambert* material = NULL;
material= node->GetSrcObject<FbxSurfaceLambert>(0);
material = FbxSurfaceLambert::Create(scene, materialName.Buffer());
materialName += i;
material->Emissive.Set(emissiveColor);
material->Ambient.Set(ambientColor);
material->Diffuse.Set(diffuseColor);
material->DiffuseFactor.Set(importedMaterials[importedMesh.material_Id[i]].diffuse_factor);
material->TransparentColor.Set(transparencyColor);
FbxNode* node = mesh->GetNode();
if (node)
{
node->AddMaterial(material);
}
// Diffuse Texture
FbxFileTexture* texture = FbxFileTexture::Create(scene, "Diffuse Texture");
std::cout << "DAFUSE MAP LENGTH: " << importedMaterials[importedMesh.material_Id[i]].duffuse_map_length << std::endl;
if (importedMaterials[importedMesh.material_Id[i]].duffuse_map_length > 0)
{
std::string tmp(pathName);
tmp += importedMaterials[importedMesh.material_Id[i]].diffuse_map;
texture->SetFileName(tmp.c_str());
texture->SetTextureUse(FbxTexture::eStandard);
texture->SetMappingType(FbxTexture::eUV);
texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
texture->SetSwapUV(false);
texture->SetTranslation(0.0, 0.0);
texture->SetScale(1.0, 1.0);
texture->SetRotation(0.0, 0.0);
if (material)
material->Diffuse.ConnectSrcObject(texture);
}
// Normal Texture
texture = FbxFileTexture::Create(scene, "Normal Texture");
if (importedMaterials[importedMesh.material_Id[i]].normal_map_length > 0)
{
texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].normal_map);
texture->SetTextureUse(FbxTexture::eStandard);
texture->SetMappingType(FbxTexture::eUV);
texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
texture->SetSwapUV(false);
texture->SetTranslation(0.0, 0.0);
texture->SetScale(1.0, 1.0);
texture->SetRotation(0.0, 0.0);
if (material)
material->NormalMap.ConnectSrcObject(texture);
}
}
// Phong
else
{
shadingName = "Phong";
FbxSurfacePhong* material = NULL;
material = node->GetSrcObject<FbxSurfacePhong>(0);
material = FbxSurfacePhong::Create(scene, materialName.Buffer());
materialName += i;
material->Emissive.Set(emissiveColor);
material->Ambient.Set(ambientColor);
material->Diffuse.Set(diffuseColor);
material->DiffuseFactor.Set(importedMaterials[importedMesh.material_Id[i]].diffuse_factor);
material->TransparentColor.Set(transparencyColor);
material->Specular.Set(specularColor);
// No need... super boost?
//material->SpecularFactor.Set(importedMaterials[importedMesh.material_Id[i]].specular_factor * 100);
material->Shininess.Set(importedMaterials[importedMesh.material_Id[i]].specular_factor);
material->Reflection.Set(FbxDouble3(importedMaterials[importedMesh.material_Id[i]].reflection[0], importedMaterials[importedMesh.material_Id[i]].reflection[1], importedMaterials[importedMesh.material_Id[i]].reflection[2]));
// Bugged...?
material->ReflectionFactor.Set(FbxDouble(importedMaterials[importedMesh.material_Id[i]].reflection_factor));
cout << importedMaterials[importedMesh.material_Id[i]].shininess << endl;
FbxNode* node = mesh->GetNode();
if (node)
{
node->AddMaterial(material);
}
// Diffuse Texture
FbxFileTexture* texture = FbxFileTexture::Create(scene, "Diffuse Texture");
if (importedMaterials[importedMesh.material_Id[i]].duffuse_map_length > 0)
{
texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].diffuse_map);
texture->SetTextureUse(FbxTexture::eStandard);
texture->SetMappingType(FbxTexture::eUV);
texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
texture->SetSwapUV(false);
texture->SetTranslation(0.0, 0.0);
texture->SetScale(1.0, 1.0);
texture->SetRotation(0.0, 0.0);
if (material)
material->Diffuse.ConnectSrcObject(texture);
}
// Specular Texture
texture = FbxFileTexture::Create(scene, "Specular Texture");
if (importedMaterials[importedMesh.material_Id[i]].specular_map_length > 0)
{
texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].specular_map);
texture->SetTextureUse(FbxTexture::eStandard);
texture->SetMappingType(FbxTexture::eUV);
texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
texture->SetSwapUV(false);
texture->SetTranslation(0.0, 0.0);
texture->SetScale(1.0, 1.0);
texture->SetRotation(0.0, 0.0);
if (material)
material->Specular.ConnectSrcObject(texture);
}
// Normal Texture
texture = FbxFileTexture::Create(scene, "Normal Texture");
if (importedMaterials[importedMesh.material_Id[i]].normal_map_length > 0)
{
texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].normal_map);
texture->SetTextureUse(FbxTexture::eStandard);
texture->SetMappingType(FbxTexture::eUV);
texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
texture->SetSwapUV(false);
texture->SetTranslation(0.0, 0.0);
texture->SetScale(1.0, 1.0);
texture->SetRotation(0.0, 0.0);
if (material)
material->NormalMap.ConnectSrcObject(texture);
}
}
}
}