void FBXImporter::LoadMaterialTexture(FBXMeshData* fbxMeshData, const char* textureType)
{
FbxProperty property;
// #NoteReference to DisplayMesh.cxx in FBX SDK samples.Note#
property = fbxMeshData->mSurfaceMaterial->FindProperty(textureType);
if (property.IsValid())
{
int textureCount = property.GetSrcObjectCount<FbxTexture>();
for (int i = 0; i < textureCount; i++)
{
FbxTexture* texture = FbxCast<FbxTexture>(property.GetSrcObject<FbxTexture>(i));
if (texture != nullptr)
{
FbxFileTexture* fileTexture = FbxCast<FbxFileTexture>(texture);
string textureFileName = fileTexture->GetFileName();
if (strcmp(textureType, FbxSurfaceMaterial::sDiffuse) == 0)
{
fbxMeshData->mMaterial->setDiffuseTexture(textureFileName);
}
else if (strcmp(textureType, FbxSurfaceMaterial::sBump) == 0)
{
fbxMeshData->mMaterial->setNormalMapTexture(textureFileName);
}
}
}
}
}
// Bake node attributes and materials for this scene and load the textures.
void LoadCacheRecursive(SceneContext* pSceneCtx, FbxScene * pScene, FbxAnimLayer * pAnimLayer, GXLPCWSTR pFbxFileName, bool pSupportVBO)
{
// Load the textures into GPU, only for file texture now
const int lTextureCount = pScene->GetTextureCount();
for (int lTextureIndex = 0; lTextureIndex < lTextureCount; ++lTextureIndex)
{
FbxTexture * lTexture = pScene->GetTexture(lTextureIndex);
FbxFileTexture * lFileTexture = FbxCast<FbxFileTexture>(lTexture);
if (lFileTexture && !lFileTexture->GetUserDataPtr())
{
// Try to load the texture from absolute path
const FbxString lFileName = lFileTexture->GetFileName();
// Only TGA textures are supported now.
//if (lFileName.Right(3).Upper() != "TGA")
//{
// FBXSDK_printf("Only TGA textures are supported now: %s\n", lFileName.Buffer());
// continue;
//}
//unsigned int lTextureObject = 0;
//bool lStatus = LoadTextureFromFile(lFileName, lTextureObject);
//const FbxString lAbsFbxFileName = FbxPathUtils::Resolve(pFbxFileName);
//const FbxString lAbsFolderName = FbxPathUtils::GetFolderName(lAbsFbxFileName);
//if (!lStatus)
//{
// // Load texture from relative file name (relative to FBX file)
// const FbxString lResolvedFileName = FbxPathUtils::Bind(lAbsFolderName, lFileTexture->GetRelativeFileName());
// lStatus = LoadTextureFromFile(lResolvedFileName, lTextureObject);
//}
//if (!lStatus)
//{
// // Load texture from file name only (relative to FBX file)
// const FbxString lTextureFileName = FbxPathUtils::GetFileName(lFileName);
// const FbxString lResolvedFileName = FbxPathUtils::Bind(lAbsFolderName, lTextureFileName);
// lStatus = LoadTextureFromFile(lResolvedFileName, lTextureObject);
//}
//if (!lStatus)
//{
// FBXSDK_printf("Failed to load texture file: %s\n", lFileName.Buffer());
// continue;
//}
//if (lStatus)
//{
// int * lTextureName = new int(lTextureObject);
// lFileTexture->SetUserDataPtr(lTextureName);
//}
}
}
LoadCacheRecursive(pSceneCtx, pScene->GetRootNode(), pAnimLayer, pSupportVBO);
}
//-------------------------------------------------------------------------------------------------------------------------------------------
void transferTextureInfo(FbxTexture* texture, int blendMode, Texture* modelTexture){
FbxFileTexture* fileTexture = FbxCast<FbxFileTexture>(texture);
FbxProceduralTexture* proceduralTexture = FbxCast<FbxProceduralTexture>(texture);
modelTexture->TextureName = texture->GetName();
if (fileTexture){
Image* image = loadImage(fileTexture->GetFileName(), &Texture::Images);
modelTexture->Image = image;
}
else if (proceduralTexture){
LOG_WARNING << "Procedural texture ! "
<< "Texture name: " << modelTexture->TextureName;
}
modelTexture->ScaleU = texture->GetScaleU();
modelTexture->ScaleV = texture->GetScaleV();
modelTexture->TranslateU = texture->GetTranslationU();
modelTexture->TranslateV = texture->GetTranslationV();
modelTexture->IsSwapUV = texture->GetSwapUV();
modelTexture->RotateU = texture->GetRotationU();
modelTexture->RotateV = texture->GetRotationV();
modelTexture->RotateW = texture->GetRotationW();
const char* lAlphaSources[] = { "None", "RGB Intensity", "Black" };
modelTexture->AlphaSource = lAlphaSources[texture->GetAlphaSource()];
modelTexture->CropLeft = texture->GetCroppingLeft();
modelTexture->CropRight = texture->GetCroppingRight();
modelTexture->CropTop = texture->GetCroppingTop();
modelTexture->CropBottom = texture->GetCroppingBottom();
const char* lMappingTypes[] = { "Null", "Planar", "Spherical", "Cylindrical",
"Box", "Face", "UV", "Environment" };
modelTexture->MappingType = lMappingTypes[texture->GetMappingType()];
const char* lBlendModes[] = { "Translucent", "Add", "Modulate", "Modulate2" };
if (blendMode >= 0){
modelTexture->BlendMode = lBlendModes[blendMode];
}
modelTexture->Alpha = texture->GetDefaultAlpha();
if (fileTexture){
const char* lMaterialUses[] = { "Model Material", "Default Material" };
modelTexture->MaterialUsed = lMaterialUses[fileTexture->GetMaterialUse()];
}
const char* pTextureUses[] = { "Standard", "Shadow Map", "Light Map",
"Spherical Reflexion Map", "Sphere Reflexion Map", "Bump Normal Map" };
modelTexture->TextureUsed = pTextureUses[texture->GetTextureUse()];
LOG_INFO << "Texture information: \n" << modelTexture->ToString();
LOG_DEBUG << "Read texture successfully!";
}
reMaterial* reFBXAsset::getMaterial( FbxMesh* fmesh, int i, reMaterialSet& set)
{
reMaterial* mat = NULL;
for (int l = 0; l < fmesh->GetElementMaterialCount(); l++)
{
FbxGeometryElementMaterial* lMaterialElement = fmesh->GetElementMaterial(l);
int lMatId = lMaterialElement->GetIndexArray().GetAt(i);
if(lMatId >= 0)
{
if (mat = set.materialById(lMatId))
return mat;
mat = new reMaterial;
mat->id = lMatId;
set.addMetarial(mat);
FbxSurfaceMaterial* lMaterial = fmesh->GetNode()->GetMaterial(lMaterialElement->GetIndexArray().GetAt(i));
if (!lMaterial)
{
continue;
}
//////////////////////////////////////////////////////////////////////////
FbxProperty lProperty = lMaterial->FindProperty(FbxSurfaceMaterial::sDiffuse);
if (lMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
FbxDouble3 lFbxDouble3;
lFbxDouble3 =((FbxSurfacePhong *)lMaterial)->Diffuse;
mat->diffuseColor = reColor4(lFbxDouble3[0], lFbxDouble3[1], lFbxDouble3[2], 1);
}
if (lMaterial->GetClassId().Is(FbxSurfaceLambert::ClassId))
{
FbxDouble3 lFbxDouble3;
lFbxDouble3 =((FbxSurfaceLambert *)lMaterial)->Diffuse;
mat->diffuseColor = reColor4(lFbxDouble3[0], lFbxDouble3[1], lFbxDouble3[2], 1);
}
////////////////////////////////////////////////////////////////////////// read texture
int lNbTextures = lProperty.GetSrcObjectCount(FbxTexture::ClassId);
if (lNbTextures)
{
mat->diffuseTexture = new reTexture;
FbxTexture* lTexture = FbxCast <FbxTexture> (lProperty.GetSrcObject(FbxTexture::ClassId,0));
qDebug() << "map: " << lTexture->GetName();
FbxFileTexture *lFileTexture = FbxCast<FbxFileTexture>(lTexture);
if (lFileTexture)
{
mat->diffuseTexture->fileName(lFileTexture->GetFileName());
}
}
//////////////////////////////////////////////////////////////////////////
}
}
return mat;
}
jstring getMaterialMapByProperty(JNIEnv *env, jint materialIndex, const char *property) {
FbxTexture *texture = currentNode->GetMaterial(materialIndex)->FindProperty(property).GetSrcObject<FbxTexture>();
if (texture) {
FbxFileTexture *fileTexture = FbxCast<FbxFileTexture>(texture);
if (fileTexture) {
return env->NewStringUTF(fileTexture->GetFileName());
}
}
return NULL;
}
std::string getTextureFileName(FbxTexture* fbxTexture) {
std::string returnString = "";
FbxFileTexture *fbxFileTexture = FbxCast<FbxFileTexture>(fbxTexture);
FbxProceduralTexture *fbxProceduralTexture = FbxCast<FbxProceduralTexture>(fbxTexture);
if (fbxFileTexture != nullptr) {
const char* textureFileName = fbxFileTexture->GetFileName();
returnString = textureFileName;
printf("\nFound texture filename: %s", returnString.c_str());
}
if (fbxProceduralTexture != nullptr) {
printf("\nWARNING : Procedural textures found");
}
return returnString;
}
//--------------------------------------------------------------------------------------
void FBXScene::ProcessMaterials(FbxScene* pScene)
{
for( int i = 0; i < pScene->GetMaterialCount(); ++i )
{
Material* pMaterial = new Material(i);
FbxSurfaceMaterial* pFBXMaterial = pScene->GetMaterial(i);
FbxProperty diffuseTextureProperty = pFBXMaterial->FindProperty(FbxSurfaceMaterial::sDiffuse);
if( diffuseTextureProperty.IsValid() )
{
FbxFileTexture* pDiffuseTexture = diffuseTextureProperty.GetSrcObject<FbxFileTexture>(0);
if( pDiffuseTexture )
{
std::string strFileName = pDiffuseTexture->GetFileName();
if( strFileName.length() == 0 )
strFileName = pDiffuseTexture->GetRelativeFileName();
strFileName = GetFileFromPath(strFileName);
pMaterial->SetDiffuseTextureName(strFileName);
}
}
FbxProperty normalTextureProperty = pFBXMaterial->FindProperty(FbxSurfaceMaterial::sNormalMap);
if( normalTextureProperty.IsValid() )
{
FbxFileTexture* pNormalTexture = normalTextureProperty.GetSrcObject<FbxFileTexture>(0);
if( pNormalTexture )
{
std::string strFileName = pNormalTexture->GetFileName();
if( strFileName.length() == 0 )
strFileName = pNormalTexture->GetRelativeFileName();
strFileName = GetFileFromPath(strFileName);
pMaterial->SetNormalTextureName(strFileName);
}
}
FbxSurfaceLambert* pLambert = FbxCast<FbxSurfaceLambert>(pFBXMaterial);
FbxSurfacePhong* pPhong = FbxCast<FbxSurfacePhong>(pFBXMaterial);
BTHFBX_VEC3 AmbientColor2;
BTHFBX_VEC3 EmissiveColor2;
BTHFBX_VEC3 DiffuseColor2;
BTHFBX_VEC3 SpecularColor2;
float fSpecularPower = 1.0f;
float fTransparency = 1.0f;
if( pLambert )
{
AmbientColor2 = GetMaterialColor2(pLambert->Ambient, pLambert->AmbientFactor);
EmissiveColor2 = GetMaterialColor2(pLambert->Emissive, pLambert->EmissiveFactor);
DiffuseColor2 = GetMaterialColor2(pLambert->Diffuse, pLambert->DiffuseFactor);
FbxPropertyT<FbxDouble> FBXTransparencyProperty = pLambert->TransparencyFactor;
if( FBXTransparencyProperty.IsValid() )
fTransparency = (float)FBXTransparencyProperty.Get();
}
if( pPhong )
{
SpecularColor2 = GetMaterialColor2(pPhong->Specular, pPhong->SpecularFactor);
FbxPropertyT<FbxDouble> FBXSpecularPowerProperty = pPhong->Shininess;
if( FBXSpecularPowerProperty.IsValid() )
fSpecularPower = (float)FBXSpecularPowerProperty.Get();
}
pMaterial->SetAmbientColor2(AmbientColor2);
pMaterial->SetEmissiveColor2(EmissiveColor2);
pMaterial->SetDiffuseColor2(DiffuseColor2);
pMaterial->SetSpecularColor2(SpecularColor2);
pMaterial->SetSpecularPower(fSpecularPower);
pMaterial->SetTransparency(fTransparency);
pMaterial->AddTexturePath( GetFilePath(this->mFilename) + "/" );
m_Materials.push_back(pMaterial);
m_FBXMaterials.push_back(pFBXMaterial);
}
}
void Tools::DisplayMaterial::DisplayMaterial( FbxGeometry *i_geometry )
{
DisplayCommon::DisplayString( "\n\n--------------------\nMaterial\n--------------------" );
int materialCount = 0;
FbxNode *node = NULL;
if( i_geometry )
{
node = i_geometry->GetNode();
if( node )
materialCount = node->GetMaterialCount();
}
if( materialCount > 0 )
{
FbxPropertyT<FbxDouble3> double3;
FbxPropertyT<FbxDouble> double1;
FbxColor theColor;
for( int ctr = 0; ctr < materialCount; ctr++ )
{
DisplayCommon::DisplayInt( " Material ", ctr );
FbxSurfaceMaterial *material = node->GetMaterial( ctr );
DisplayCommon::DisplayString( " Name: \"", (char *) material->GetName(), "\"" );
#ifdef DISPLAY_HARDWARE_SHADER_INFORMATION
//Get the implementation to see if it's a hardware shader.
// Note:: this cause memory leak
const FbxImplementation* implementation = GetImplementation( material, FBXSDK_IMPLEMENTATION_HLSL );
FbxString implementationType = "HLSL";
if( !implementation )
{
implementation = GetImplementation( material, FBXSDK_IMPLEMENTATION_CGFX );
implementationType = "CGFX";
}
if( implementation )
{
//Now we have a hardware shader, let's read it
FBXSDK_printf( " Hardware Shader Type: %s\n", implemenationType.Buffer() );
DisplayCommon::DisplayString( " Hardware Shader Type: ", implemenationType );
const FbxBindingTable* rootTable = implementation->GetRootTable();
FbxString fileName = rootTable->DescAbsoluteURL.Get();
FbxString techniqueName = rootTable->DescTAG.Get();
const FbxBindingTable* table = implementation->GetRootTable();
size_t entryNum = table->GetEntryCount();
for( int i = 0; i < (int)entryNum; i++ )
{
const FbxBindingTableEntry& entry = table->GetEntry( i );
const char *entrySrcType = entry.GetEntryType( true );
FbxProperty fbxProp;
FbxString test = entry.GetSource();
FBXSDK_printf( " Entry: %s\n", test.Buffer() );
DisplayCommon::DisplayString( " Entry: %s\n", test );
if ( strcmp( FbxPropertyEntryView::sEntryType, entrySrcType ) == 0 )
{
fbxProp = material->FindPropertyHierarchical(entry.GetSource());
if( !fbxProp.IsValid() )
{
fbxProp = material->RootProperty.FindHierarchical( entry.GetSource() );
}
}
else if( strcmp( FbxConstantEntryView::sEntryType, entrySrcType ) == 0 )
{
fbxProp = implementation->GetConstants().FindHierarchical( entry.GetSource() );
}
if( fbxProp.IsValid() )
{
if( fbxProp.GetSrcObjectCount<FbxTexture>() > 0 )
{
//do what you want with the textures
for( int j = 0; j < fbxProp.GetSrcObjectCount<FbxFileTexture>(); j++ )
{
FbxFileTexture *tex = fbxProp.GetSrcObject<FbxFileTexture>( j );
FBXSDK_printf( " File Texture: %s\n", tex->GetFileName() );
DisplayCommon::DisplayString( " File Texture: %s\n", tex->GetFileName() );
}
for( int j = 0; j < fbxProp.GetSrcObjectCount<FbxLayeredTexture>(); j++ )
{
FbxLayeredTexture *tex = fbxProp.GetSrcObject<FbxLayeredTexture>( j );
FBXSDK_printf( " Layered Texture: %s\n", tex->GetName() );
DisplayCommon::DisplayString( " Layered Texture: %s\n", tex->GetName() );
}
for( int j = 0; j < fbxProp.GetSrcObjectCount<FbxProceduralTexture>(); j++ )
{
FbxProceduralTexture *tex = fbxProp.GetSrcObject<FbxProceduralTexture>( j );
FBXSDK_printf( " Procedural Texture: %s\n", tex->GetName() );
DisplayCommon::DisplayString( " Procedural Texture: %s\n", tex->GetName() );
}
}
else
{
FbxDataType fbxType = fbxProp.GetPropertyDataType();
FbxString fbxName = fbxType.GetName();
if( FbxBoolDT == fbxType )
{
DisplayCommon::DisplayBool( " Bool: ", fbxProp.Get<FbxBool>() );
}
else if( FbxIntDT == fbxType || FbxEnumDT == fbxType )
{
DisplayCommon::DisplayInt( " Int: ", fbxProp.Get<FbxInt>() );
}
else if( FbxFloatDT == fbxType )
{
DisplayCommon::DisplayDouble( " Float: ", fbxProp.Get<FbxFloat>() );
}
else if( FbxDoubleDT == fbxType )
{
DisplayCommon::DisplayDouble( " Double: ", fbxProp.Get<FbxDouble>() );
}
else if( FbxStringDT == fbxType || FbxUrlDT == fbxType || FbxXRefUrlDT == fbxType )
{
DisplayCommon::DisplayString( " String: ", fbxProp.Get<FbxString>().Buffer() );
}
else if( FbxDouble2DT == fbxType )
{
FbxDouble2 double2 = fbxProp.Get<FbxDouble2>();
FbxVector2 vector;
vector[0] = double2[0];
vector[1] = double2[1];
DisplayCommon::Display2DVector( " 2D vector: ", vector );
}
else if( (FbxDouble3DT == fbxType) || (FbxColor3DT == fbxType) )
{
FbxDouble3 double3 = fbxProp.Get<FbxDouble3>();
FbxVector4 vector;
vector[0] = double3[0];
vector[1] = double3[1];
vector[2] = double3[2];
DisplayCommon::Display3DVector( " 3D vector: ", vector );
}
else if( (FbxDouble4DT == fbxType) || (FbxColor4DT == fbxType) )
{
FbxDouble4 double4 = fbxProp.Get<FbxDouble4>();
FbxVector4 vector;
vector[0] = double4[0];
vector[1] = double4[1];
vector[2] = double4[2];
vector[3] = double4[3];
DisplayCommon::Display4DVector( " 4D vector: ", vector );
}
else if( FbxDouble4x4DT == fbxType )
{
FbxDouble4x4 double44 = fbxProp.Get<FbxDouble4x4>();
for( int j = 0; j < 4; j++ )
{
FbxVector4 vector;
vector[0] = double44[j][0];
vector[1] = double44[j][1];
vector[2] = double44[j][2];
vector[3] = double44[j][3];
DisplayCommon::Display4DVector( " 4x4D vector: ", vector );
}
}
}
}
}
}
else
#endif // #ifdef DISPLAY_HARDWARE_SHADER_INFORMATION
if( material->GetClassId().Is(FbxSurfacePhong::ClassId) )
{
// We found a Phong material. Display its properties.
// Display the Ambient Color
double3 = ((FbxSurfacePhong *) material)->Ambient;
theColor.Set( double3.Get()[0], double3.Get()[1], double3.Get()[2] );
DisplayCommon::DisplayColor( " Ambient: ", theColor );
// Display the Diffuse Color
double3 = ((FbxSurfacePhong *) material)->Diffuse;
theColor.Set( double3.Get()[0], double3.Get()[1], double3.Get()[2] );
DisplayCommon::DisplayColor( " Diffuse: ", theColor );
// Display the Specular Color (unique to Phong materials)
double3 = ((FbxSurfacePhong *) material)->Specular;
theColor.Set( double3.Get()[0], double3.Get()[1], double3.Get()[2] );
DisplayCommon::DisplayColor( " Specular: ", theColor );
// Display the Emissive Color
double3 = ((FbxSurfacePhong *) material)->Emissive;
theColor.Set( double3.Get()[0], double3.Get()[1], double3.Get()[2] );
DisplayCommon::DisplayColor( " Emissive: ", theColor );
//Opacity is Transparency factor now
double1 = ((FbxSurfacePhong *) material)->TransparencyFactor;
DisplayCommon::DisplayDouble( " Opacity: ", 1.0-double1.Get() );
// Display the Shininess
double1 = ((FbxSurfacePhong *) material)->Shininess;
DisplayCommon::DisplayDouble( " Shininess: ", double1.Get() );
// Display the Reflectivity
double1 = ((FbxSurfacePhong *) material)->ReflectionFactor;
DisplayCommon::DisplayDouble( " Reflectivity: ", double1.Get() );
}
else if( material->GetClassId().Is(FbxSurfaceLambert::ClassId) )
{
// We found a Lambert material. Display its properties.
// Display the Ambient Color
double3 = ((FbxSurfaceLambert *)material)->Ambient;
theColor.Set( double3.Get()[0], double3.Get()[1], double3.Get()[2] );
DisplayCommon::DisplayColor( " Ambient: ", theColor );
// Display the Diffuse Color
double3 = ((FbxSurfaceLambert *)material)->Diffuse;
theColor.Set( double3.Get()[0], double3.Get()[1], double3.Get()[2] );
DisplayCommon::DisplayColor( " Diffuse: ", theColor );
// Display the Emissive
double3 = ((FbxSurfaceLambert *)material)->Emissive;
theColor.Set( double3.Get()[0], double3.Get()[1], double3.Get()[2] );
DisplayCommon::DisplayColor( " Emissive: ", theColor );
// Display the Opacity
double1 = ((FbxSurfaceLambert *)material)->TransparencyFactor;
DisplayCommon::DisplayDouble( " Opacity: ", 1.0-double1.Get() );
}
else
DisplayCommon::DisplayString( "Unknown type of Material" );
FbxPropertyT<FbxString> string;
string = material->ShadingModel;
DisplayCommon::DisplayString( " Shading Model: ", string.Get() );
}
}
}
// マテリアルプロパティ獲得
FbxDouble3 GetMaterialProperty(
const FbxSurfaceMaterial * pMaterial,
const char * pPropertyName,
const char * pFactorPropertyName)
{
FbxDouble3 lResult(0, 0, 0);
const FbxProperty lProperty = pMaterial->FindProperty(pPropertyName);
const FbxProperty lFactorProperty = pMaterial->FindProperty(pFactorPropertyName);
if(lProperty.IsValid() && lFactorProperty.IsValid())
{
lResult = lProperty.Get<FbxDouble3>();
double lFactor = lFactorProperty.Get<FbxDouble>();
if(lFactor != 1)
{
lResult[0] *= lFactor;
lResult[1] *= lFactor;
lResult[2] *= lFactor;
}
}
if(lProperty.IsValid())
{
printf("テクスチャ\n");
const int lTextureCount = lProperty.GetSrcObjectCount<FbxFileTexture>();
for(int i = 0; i<lTextureCount; i++)
{
FbxFileTexture* lFileTexture = lProperty.GetSrcObject<FbxFileTexture>(i);
if(lFileTexture)
{
FbxString uvsetName = lFileTexture->UVSet.Get();
std::string uvSetString = uvsetName.Buffer();
std::string filepath = lFileTexture->GetFileName();
printf("UVSet名=%s\n", uvSetString.c_str());
printf("テクスチャ名=%s\n", filepath.c_str());
}
}
puts("");
printf("レイヤードテクスチャ\n");
const int lLayeredTextureCount = lProperty.GetSrcObjectCount<FbxLayeredTexture>();
for(int i = 0; i<lLayeredTextureCount; i++)
{
FbxLayeredTexture* lLayeredTexture = lProperty.GetSrcObject<FbxLayeredTexture>(i);
const int lTextureFileCount = lLayeredTexture->GetSrcObjectCount<FbxFileTexture>();
for(int j = 0; j<lTextureFileCount; j++)
{
FbxFileTexture* lFileTexture = lLayeredTexture->GetSrcObject<FbxFileTexture>(j);
if(lFileTexture)
{
FbxString uvsetName = lFileTexture->UVSet.Get();
std::string uvSetString = uvsetName.Buffer();
std::string filepath = lFileTexture->GetFileName();
printf("UVSet名=%s\n", uvSetString.c_str());
printf("テクスチャ名=%s\n", filepath.c_str());
}
}
}
puts("");
}
return lResult;
}
void Resource::FBX::FBXMaterial::InitMaterial(const FbxSurfaceMaterial *pFbxMaterial, Resource::ResourceManager& rm) {
// Logger::Debug(pFbxMaterial->GetName());
Render::MaterialElement& material = AddElement();
const FbxImplementation *lImplementation = pFbxMaterial->GetDefaultImplementation();
FbxPropertyT<FbxDouble3> lKFbxDouble3;
FbxPropertyT<FbxDouble> lKFbxDouble1;
FbxColor theColor;
if(lImplementation){
const FbxBindingTable *lTable = lImplementation->GetRootTable();
size_t lEntryNum = lTable->GetEntryCount();
for (int i = 0; i < (int) lEntryNum; ++i) {
const FbxBindingTableEntry &lEntry = lTable->GetEntry(i);
const char *lEntrySrcType = lEntry.GetEntryType(true);
FbxProperty lFbxProp;
FbxString lTest = lEntry.GetSource();
FBXSDK_printf(" Entry: %s\n", lTest.Buffer());
if (strcmp(FbxPropertyEntryView::sEntryType, lEntrySrcType) == 0) {
lFbxProp = pFbxMaterial->FindPropertyHierarchical(lEntry.GetSource());
if (!lFbxProp.IsValid()) {
lFbxProp = pFbxMaterial->RootProperty.FindHierarchical(lEntry.GetSource());
}
}
else if (strcmp(FbxConstantEntryView::sEntryType, lEntrySrcType) == 0) {
lFbxProp = lImplementation->GetConstants().FindHierarchical(lEntry.GetSource());
}
}
}
else if (pFbxMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
// We found a Phong material. Display its properties.
// Display the Ambient Color
lKFbxDouble3 =((FbxSurfacePhong *) pFbxMaterial)->Ambient;
theColor.Set(lKFbxDouble3.Get()[0], lKFbxDouble3.Get()[1], lKFbxDouble3.Get()[2]);
// Display the Diffuse Color
lKFbxDouble3 =((FbxSurfacePhong *) pFbxMaterial)->Diffuse;
theColor.Set(lKFbxDouble3.Get()[0], lKFbxDouble3.Get()[1], lKFbxDouble3.Get()[2]);
// Display the Specular Color (unique to Phong materials)
lKFbxDouble3 =((FbxSurfacePhong *) pFbxMaterial)->Specular;
theColor.Set(lKFbxDouble3.Get()[0], lKFbxDouble3.Get()[1], lKFbxDouble3.Get()[2]);
// Display the Emissive Color
lKFbxDouble3 =((FbxSurfacePhong *) pFbxMaterial)->Emissive;
theColor.Set(lKFbxDouble3.Get()[0], lKFbxDouble3.Get()[1], lKFbxDouble3.Get()[2]);
//Opacity is Transparency factor now
lKFbxDouble1 =((FbxSurfacePhong *) pFbxMaterial)->TransparencyFactor;
// Display the Shininess
lKFbxDouble1 =((FbxSurfacePhong *) pFbxMaterial)->Shininess;
double dShininess = lKFbxDouble1.Get();
lKFbxDouble1 =((FbxSurfacePhong *) pFbxMaterial)->Specular;
double dSpecular = lKFbxDouble1.Get();
lKFbxDouble1 =((FbxSurfacePhong *) pFbxMaterial)->SpecularFactor;
double dSpecularFactor = lKFbxDouble1.Get();
material.m_fShininess = dShininess;
material.m_fSpecular = dSpecular * dSpecularFactor;
// Display the Reflectivity
lKFbxDouble1 =((FbxSurfacePhong *) pFbxMaterial)->ReflectionFactor;
material.m_fReflectionFactor = lKFbxDouble1.Get();
}
else if(pFbxMaterial->GetClassId().Is(FbxSurfaceLambert::ClassId) )
{
// We found a Lambert material. Display its properties.
// Display the Ambient Color
lKFbxDouble3=((FbxSurfaceLambert *)pFbxMaterial)->Ambient;
theColor.Set(lKFbxDouble3.Get()[0], lKFbxDouble3.Get()[1], lKFbxDouble3.Get()[2]);
// Display the Diffuse Color
lKFbxDouble3 =((FbxSurfaceLambert *)pFbxMaterial)->Diffuse;
theColor.Set(lKFbxDouble3.Get()[0], lKFbxDouble3.Get()[1], lKFbxDouble3.Get()[2]);
// Display the Emissive
lKFbxDouble3 =((FbxSurfaceLambert *)pFbxMaterial)->Emissive;
theColor.Set(lKFbxDouble3.Get()[0], lKFbxDouble3.Get()[1], lKFbxDouble3.Get()[2]);
// Display the Opacity
lKFbxDouble1 =((FbxSurfaceLambert *)pFbxMaterial)->TransparencyFactor;
}
else
Logger::Debug("Unknown type of Material");
FbxProperty prop = pFbxMaterial->FindProperty(FbxSurfaceMaterial::sDiffuse);
// Check if it's layeredtextures
int layeredTextureCount = prop.GetSrcObjectCount<FbxLayeredTexture>();
for (int j = 0; j < layeredTextureCount; j++)
{
FbxLayeredTexture* layered_texture = FbxCast<FbxLayeredTexture>(prop.GetSrcObject<FbxLayeredTexture>(j));
int lcount = layered_texture->GetSrcObjectCount<FbxFileTexture>();
for (int k = 0; k < lcount; k++)
{
FbxFileTexture* texture = FbxCast<FbxFileTexture>(layered_texture->GetSrcObject<FbxFileTexture>(k));
// Then, you can get all the properties of the texture, include its name
const char* textureName = texture->GetFileName();
material.AddTexture(rm.LoadImageFromFile(textureName));
}
}
int textureCount = prop.GetSrcObjectCount<FbxFileTexture>();
for(int i=0; i<textureCount; ++i){
FbxFileTexture* texture = FbxCast<FbxFileTexture>(prop.GetSrcObject<FbxFileTexture>(i));
const char* textureName = texture->GetFileName();
material.AddTexture(rm.LoadImageFromFile(textureName));
}
FbxPropertyT<FbxString> lString;
lString = pFbxMaterial->ShadingModel;
}
FbxDouble3 CFBXLoader::GetMaterialProperty(
const FbxSurfaceMaterial * pMaterial,
const char * pPropertyName,
const char * pFactorPropertyName,
FBX_MATRIAL_ELEMENT* pElement)
{
pElement->type = FBX_MATRIAL_ELEMENT::ELEMENT_NONE;
FbxDouble3 lResult(0, 0, 0);
const FbxProperty lProperty = pMaterial->FindProperty(pPropertyName);
const FbxProperty lFactorProperty = pMaterial->FindProperty(pFactorPropertyName);
if (lProperty.IsValid() && lFactorProperty.IsValid())
{
lResult = lProperty.Get<FbxDouble3>();
double lFactor = lFactorProperty.Get<FbxDouble>();
if (lFactor != 1)
{
lResult[0] *= lFactor;
lResult[1] *= lFactor;
lResult[2] *= lFactor;
}
pElement->type = FBX_MATRIAL_ELEMENT::ELEMENT_COLOR;
}
if (lProperty.IsValid())
{
int existTextureCount = 0;
const int lTextureCount = lProperty.GetSrcObjectCount<FbxFileTexture>();
for(int i=0;i<lTextureCount;i++)
{
FbxFileTexture* lFileTexture = lProperty.GetSrcObject<FbxFileTexture>(i);
if(!lFileTexture)
continue;
FbxString uvsetName = lFileTexture->UVSet.Get();
std::string uvSetString = uvsetName.Buffer();
std::string filepath = lFileTexture->GetFileName();
pElement->textureSetArray[uvSetString].push_back(filepath);
existTextureCount++;
}
const int lLayeredTextureCount = lProperty.GetSrcObjectCount<FbxLayeredTexture>();
for(int i=0;i<lLayeredTextureCount;i++)
{
FbxLayeredTexture* lLayeredTexture = lProperty.GetSrcObject<FbxLayeredTexture>(i);
const int lTextureFileCount = lLayeredTexture->GetSrcObjectCount<FbxFileTexture>();
for(int j=0;j<lTextureFileCount;j++)
{
FbxFileTexture* lFileTexture = lLayeredTexture->GetSrcObject<FbxFileTexture>(j);
if(!lFileTexture)
continue;
FbxString uvsetName = lFileTexture->UVSet.Get();
std::string uvSetString = uvsetName.Buffer();
std::string filepath = lFileTexture->GetFileName();
pElement->textureSetArray[uvSetString].push_back(filepath);
existTextureCount++;
}
}
if(existTextureCount > 0)
{
if(pElement->type == FBX_MATRIAL_ELEMENT::ELEMENT_COLOR)
pElement->type = FBX_MATRIAL_ELEMENT::ELEMENT_BOTH;
else
pElement->type = FBX_MATRIAL_ELEMENT::ELEMENT_TEXTURE;
}
}
return lResult;
}
//converts a FBX mesh to a CC mesh
static ccMesh* FromFbxMesh(FbxMesh* fbxMesh, FileIOFilter::LoadParameters& parameters)
{
if (!fbxMesh)
return 0;
int polyCount = fbxMesh->GetPolygonCount();
//fbxMesh->GetLayer(
unsigned triCount = 0;
unsigned polyVertCount = 0; //different from vertCount (vertices can be counted multiple times here!)
//as we can't load all polygons (yet ;) we already look if we can load any!
{
unsigned skipped = 0;
for (int i=0; i<polyCount; ++i)
{
int pSize = fbxMesh->GetPolygonSize(i);
if (pSize == 3)
{
++triCount;
polyVertCount += 3;
}
else if (pSize == 4)
{
triCount += 2;
polyVertCount += 4;
}
else
{
++skipped;
}
}
if (triCount == 0)
{
ccLog::Warning(QString("[FBX] No triangle or quad found in mesh '%1'! (polygons with more than 4 vertices are not supported for the moment)").arg(fbxMesh->GetName()));
return 0;
}
else if (skipped != 0)
{
ccLog::Warning(QString("[FBX] Some polygons in mesh '%1' were ignored (%2): polygons with more than 4 vertices are not supported for the moment)").arg(fbxMesh->GetName()).arg(skipped));
return 0;
}
}
int vertCount = fbxMesh->GetControlPointsCount();
if (vertCount <= 0)
{
ccLog::Warning(QString("[FBX] Mesh '%1' has no vetex or no polygon?!").arg(fbxMesh->GetName()));
return 0;
}
ccPointCloud* vertices = new ccPointCloud("vertices");
ccMesh* mesh = new ccMesh(vertices);
mesh->setName(fbxMesh->GetName());
mesh->addChild(vertices);
vertices->setEnabled(false);
if (!mesh->reserve(static_cast<unsigned>(triCount)) || !vertices->reserve(vertCount))
{
ccLog::Warning(QString("[FBX] Not enough memory to load mesh '%1'!").arg(fbxMesh->GetName()));
delete mesh;
return 0;
}
//colors
{
for (int l=0; l<fbxMesh->GetElementVertexColorCount(); l++)
{
FbxGeometryElementVertexColor* vertColor = fbxMesh->GetElementVertexColor(l);
//CC can only handle per-vertex colors
if (vertColor->GetMappingMode() == FbxGeometryElement::eByControlPoint)
{
if (vertColor->GetReferenceMode() == FbxGeometryElement::eDirect
|| vertColor->GetReferenceMode() == FbxGeometryElement::eIndexToDirect)
{
if (vertices->reserveTheRGBTable())
{
switch (vertColor->GetReferenceMode())
{
case FbxGeometryElement::eDirect:
{
for (int i=0; i<vertCount; ++i)
{
FbxColor c = vertColor->GetDirectArray().GetAt(i);
vertices->addRGBColor( static_cast<colorType>(c.mRed * ccColor::MAX),
static_cast<colorType>(c.mGreen * ccColor::MAX),
static_cast<colorType>(c.mBlue * ccColor::MAX) );
}
}
break;
case FbxGeometryElement::eIndexToDirect:
{
for (int i=0; i<vertCount; ++i)
{
int id = vertColor->GetIndexArray().GetAt(i);
FbxColor c = vertColor->GetDirectArray().GetAt(id);
vertices->addRGBColor( static_cast<colorType>(c.mRed * ccColor::MAX),
static_cast<colorType>(c.mGreen * ccColor::MAX),
static_cast<colorType>(c.mBlue * ccColor::MAX) );
}
}
break;
default:
assert(false);
break;
}
vertices->showColors(true);
mesh->showColors(true);
break; //no need to look for other color fields (we won't be able to handle them!
}
else
{
ccLog::Warning(QString("[FBX] Not enough memory to load mesh '%1' colors!").arg(fbxMesh->GetName()));
}
}
else
{
ccLog::Warning(QString("[FBX] Color field #%i of mesh '%1' will be ignored (unhandled type)").arg(l).arg(fbxMesh->GetName()));
}
}
else
{
ccLog::Warning(QString("[FBX] Color field #%i of mesh '%1' will be ignored (unhandled type)").arg(l).arg(fbxMesh->GetName()));
}
}
}
//normals can be per vertices or per-triangle
int perPointNormals = -1;
int perVertexNormals = -1;
int perPolygonNormals = -1;
{
for (int j=0; j<fbxMesh->GetElementNormalCount(); j++)
{
FbxGeometryElementNormal* leNormals = fbxMesh->GetElementNormal(j);
switch(leNormals->GetMappingMode())
{
case FbxGeometryElement::eByControlPoint:
perPointNormals = j;
break;
case FbxGeometryElement::eByPolygonVertex:
perVertexNormals = j;
break;
case FbxGeometryElement::eByPolygon:
perPolygonNormals = j;
break;
default:
//not handled
break;
}
}
}
//per-point normals
if (perPointNormals >= 0)
{
FbxGeometryElementNormal* leNormals = fbxMesh->GetElementNormal(perPointNormals);
FbxLayerElement::EReferenceMode refMode = leNormals->GetReferenceMode();
const FbxLayerElementArrayTemplate<FbxVector4>& normals = leNormals->GetDirectArray();
assert(normals.GetCount() == vertCount);
if (normals.GetCount() != vertCount)
{
ccLog::Warning(QString("[FBX] Wrong number of normals on mesh '%1'!").arg(fbxMesh->GetName()));
perPointNormals = -1;
}
else if (!vertices->reserveTheNormsTable())
{
ccLog::Warning(QString("[FBX] Not enough memory to load mesh '%1' normals!").arg(fbxMesh->GetName()));
perPointNormals = -1;
}
else
{
//import normals
for (int i=0; i<vertCount; ++i)
{
int id = refMode != FbxGeometryElement::eDirect ? leNormals->GetIndexArray().GetAt(i) : i;
FbxVector4 N = normals.GetAt(id);
//convert to CC-structure
CCVector3 Npc( static_cast<PointCoordinateType>(N.Buffer()[0]),
static_cast<PointCoordinateType>(N.Buffer()[1]),
static_cast<PointCoordinateType>(N.Buffer()[2]) );
vertices->addNorm(Npc);
}
vertices->showNormals(true);
mesh->showNormals(true);
//no need to import the other normals (if any)
perVertexNormals = -1;
perPolygonNormals = -1;
}
}
//per-triangle normals
NormsIndexesTableType* normsTable = 0;
if (perVertexNormals >= 0 || perPolygonNormals >= 0)
{
normsTable = new NormsIndexesTableType();
if (!normsTable->reserve(polyVertCount) || !mesh->reservePerTriangleNormalIndexes())
{
ccLog::Warning(QString("[FBX] Not enough memory to load mesh '%1' normals!").arg(fbxMesh->GetName()));
normsTable->release();
normsTable = 0;
}
else
{
mesh->setTriNormsTable(normsTable);
vertices->showNormals(true);
mesh->showNormals(true);
}
}
//materials
ccMaterialSet* materials = 0;
{
FbxNode* lNode = fbxMesh->GetNode();
int lMaterialCount = lNode ? lNode->GetMaterialCount() : 0;
for (int i=0; i<lMaterialCount; i++)
{
FbxSurfaceMaterial *lBaseMaterial = lNode->GetMaterial(i);
bool isLambert = lBaseMaterial->GetClassId().Is(FbxSurfaceLambert::ClassId);
bool isPhong = lBaseMaterial->GetClassId().Is(FbxSurfacePhong::ClassId);
if (isLambert || isPhong)
{
ccMaterial::Shared mat(new ccMaterial(lBaseMaterial->GetName()));
FbxSurfaceLambert* lLambertMat = static_cast<FbxSurfaceLambert*>(lBaseMaterial);
float ambient[4];
float diffuse[4];
float emission[4];
float specular[4];
FbxSurfacePhong* lPhongMat = isPhong ? static_cast<FbxSurfacePhong*>(lBaseMaterial) : 0;
for (int k=0; k<3; ++k)
{
ambient[k] = static_cast<float>(lLambertMat->Ambient.Get()[k]);
diffuse[k] = static_cast<float>(lLambertMat->Diffuse.Get()[k]);
emission[k] = static_cast<float>(lLambertMat->Emissive.Get()[k]);
if (lPhongMat)
{
specular[k] = static_cast<float>(lPhongMat->Specular.Get()[k]);
}
}
mat->setAmbient(ambient);
mat->setDiffuse(diffuse);
mat->setEmission(emission);
if (isPhong)
{
mat->setSpecular(specular);
assert(lPhongMat);
mat->setShininess(static_cast<float>(lPhongMat->Shininess));
}
//import associated texture (if any)
{
int lTextureIndex;
FBXSDK_FOR_EACH_TEXTURE(lTextureIndex)
{
FbxProperty lProperty = lBaseMaterial->FindProperty(FbxLayerElement::sTextureChannelNames[lTextureIndex]);
if( lProperty.IsValid() )
{
int lTextureCount = lProperty.GetSrcObjectCount<FbxTexture>();
FbxTexture* texture = 0; //we can handle only one texture per material! We'll take the non layered one by default (if any)
for (int j = 0; j < lTextureCount; ++j)
{
//Here we have to check if it's layeredtextures, or just textures:
FbxLayeredTexture *lLayeredTexture = lProperty.GetSrcObject<FbxLayeredTexture>(j);
if (lLayeredTexture)
{
//we don't handle layered textures!
/*int lNbTextures = lLayeredTexture->GetSrcObjectCount<FbxTexture>();
for (int k=0; k<lNbTextures; ++k)
{
FbxTexture* lTexture = lLayeredTexture->GetSrcObject<FbxTexture>(k);
if(lTexture)
{
}
}
//*/
}
else
{
//non-layered texture
FbxTexture* lTexture = lProperty.GetSrcObject<FbxTexture>(j);
if(lTexture)
{
//we take the first non layered texture by default
texture = lTexture;
break;
}
}
}
if (texture)
{
FbxFileTexture *lFileTexture = FbxCast<FbxFileTexture>(texture);
if (lFileTexture)
{
const char* texAbsoluteFilename = lFileTexture->GetFileName();
ccLog::PrintDebug(QString("[FBX] Texture absolue filename: %1").arg(texAbsoluteFilename));
if (texAbsoluteFilename != 0 && texAbsoluteFilename[0] != 0)
{
if (!mat->loadAndSetTexture(texAbsoluteFilename))
{
ccLog::Warning(QString("[FBX] Failed to load texture file: %1").arg(texAbsoluteFilename));
}
}
}
}
}
}
}
if (!materials)
{
materials = new ccMaterialSet("materials");
mesh->addChild(materials);
}
materials->addMaterial(mat);
}
else
{
ccLog::Warning(QString("[FBX] Material '%1' has an unhandled type").arg(lBaseMaterial->GetName()));
}
}
SceneNode *SceneConverter::makeSceneNode(FbxNode *node)
{
SceneNode *sceneNode = new SceneNode();
if (node->GetParent() == NULL) // The root
{
// Type
sceneNode->type = FbxString("root");
// Name
sceneNode->attributes.push_back(std::make_pair(FbxString("name"), node->GetName()));
// Transformation
FbxAMatrix m = node->EvaluateGlobalTransform();
const FbxVector4 translation = m.GetT();
const FbxVector4 rotation = m.GetR();
const FbxVector4 scaling = m.GetS();
char buffer[1024];
FBXSDK_sprintf(buffer, 1024, "s:%8.5f,%8.5f,%8.5f,r:%8.5f,%8.5f,%8.5f,t:%8.5f,%8.5f,%8.5f",
(float)scaling[0], (float)scaling[1], (float)scaling[2],
(float)rotation[0], (float)rotation[1], (float)rotation[2],
(float)translation[0], (float)translation[1], (float)translation[2]);
sceneNode->attributes.push_back(std::make_pair(FbxString("transform"), FbxString(buffer)));
}
else
{
FbxCamera *camera = node->GetCamera();
if (camera != NULL)
{
sceneNode->type = FbxString("camera");
sceneNode->attributes.push_back(std::make_pair(FbxString("name"), node->GetName()));
sceneNode->attributes.push_back(std::make_pair(FbxString("fixed"), FbxString("true")));
FbxVector4 position = camera->EvaluatePosition();
FbxVector4 center = camera->EvaluateLookAtPosition();
// FIXME: seems EvaluateUpDirection doesn't give correct result as it
// is affected by its parent nodes' tranforms however we attach camera
// to the root in paper3d's scene.
// FbxVector4 up = camera->EvaluateUpDirection(position, center);
FbxDouble3 up = camera->UpVector.Get();
char buffer[1024];
FBXSDK_sprintf(buffer, 1024, "eye:%8.5f,%8.5f,%8.5f,center:%8.5f,%8.5f,%8.5f,up:%8.5f,%8.5f,%8.5f",
(float)position[0], (float)position[1], (float)position[2],
(float)center[0], (float)center[1], (float)center[2],
(float)up[0], (float)up[1], (float)up[2]);
sceneNode->attributes.push_back(std::make_pair(FbxString("lookat"), FbxString(buffer)));
float nearZ = (float)camera->GetNearPlane();
float farZ = (float)camera->GetFarPlane();
if (camera->ProjectionType.Get() == FbxCamera::ePerspective)
{
FbxCamera::EAspectRatioMode lCamAspectRatioMode = camera->GetAspectRatioMode();
double lAspectX = camera->AspectWidth.Get();
double lAspectY = camera->AspectHeight.Get();
double lAspectRatio = 1.333333;
switch( lCamAspectRatioMode)
{
case FbxCamera::eWindowSize:
lAspectRatio = lAspectX / lAspectY;
break;
case FbxCamera::eFixedRatio:
lAspectRatio = lAspectX;
break;
case FbxCamera::eFixedResolution:
lAspectRatio = lAspectX / lAspectY * camera->GetPixelRatio();
break;
case FbxCamera::eFixedWidth:
lAspectRatio = camera->GetPixelRatio() / lAspectY;
break;
case FbxCamera::eFixedHeight:
lAspectRatio = camera->GetPixelRatio() * lAspectX;
break;
default:
break;
}
//get the aperture ratio
double lFilmHeight = camera->GetApertureHeight();
double lFilmWidth = camera->GetApertureWidth() * camera->GetSqueezeRatio();
//here we use Height : Width
double lApertureRatio = lFilmHeight / lFilmWidth;
//change the aspect ratio to Height : Width
lAspectRatio = 1 / lAspectRatio;
//revise the aspect ratio and aperture ratio
FbxCamera::EGateFit lCameraGateFit = camera->GateFit.Get();
switch( lCameraGateFit )
{
case FbxCamera::eFitFill:
if( lApertureRatio > lAspectRatio) // the same as eHORIZONTAL_FIT
{
lFilmHeight = lFilmWidth * lAspectRatio;
camera->SetApertureHeight( lFilmHeight);
lApertureRatio = lFilmHeight / lFilmWidth;
}
else if( lApertureRatio < lAspectRatio) //the same as eVERTICAL_FIT
{
lFilmWidth = lFilmHeight / lAspectRatio;
camera->SetApertureWidth( lFilmWidth);
lApertureRatio = lFilmHeight / lFilmWidth;
}
break;
case FbxCamera::eFitVertical:
lFilmWidth = lFilmHeight / lAspectRatio;
camera->SetApertureWidth( lFilmWidth);
lApertureRatio = lFilmHeight / lFilmWidth;
break;
case FbxCamera::eFitHorizontal:
lFilmHeight = lFilmWidth * lAspectRatio;
camera->SetApertureHeight( lFilmHeight);
lApertureRatio = lFilmHeight / lFilmWidth;
break;
case FbxCamera::eFitStretch:
lAspectRatio = lApertureRatio;
break;
case FbxCamera::eFitOverscan:
if( lFilmWidth > lFilmHeight)
{
lFilmHeight = lFilmWidth * lAspectRatio;
}
else
{
lFilmWidth = lFilmHeight / lAspectRatio;
}
lApertureRatio = lFilmHeight / lFilmWidth;
break;
case FbxCamera::eFitNone:
default:
break;
}
//change the aspect ratio to Width : Height
lAspectRatio = 1 / lAspectRatio;
#define HFOV2VFOV(h, ar) (2.0 * atan((ar) * tan( (h * FBXSDK_PI_DIV_180) * 0.5)) * FBXSDK_180_DIV_PI) //ar : aspectY / aspectX
#define VFOV2HFOV(v, ar) (2.0 * atan((ar) * tan( (v * FBXSDK_PI_DIV_180) * 0.5)) * FBXSDK_180_DIV_PI) //ar : aspectX / aspectY
double lFieldOfViewX = 0.0;
double lFieldOfViewY = 0.0;
if (camera->GetApertureMode() == FbxCamera::eVertical)
{
lFieldOfViewY = camera->FieldOfView.Get();
lFieldOfViewX = VFOV2HFOV( lFieldOfViewY, 1 / lApertureRatio);
}
else if (camera->GetApertureMode() == FbxCamera::eHorizontal)
{
lFieldOfViewX = camera->FieldOfView.Get(); //get HFOV
lFieldOfViewY = HFOV2VFOV( lFieldOfViewX, lApertureRatio);
}
else if (camera->GetApertureMode() == FbxCamera::eFocalLength)
{
lFieldOfViewX = camera->ComputeFieldOfView(camera->FocalLength.Get()); //get HFOV
lFieldOfViewY = HFOV2VFOV( lFieldOfViewX, lApertureRatio);
}
else if (camera->GetApertureMode() == FbxCamera::eHorizAndVert)
{
lFieldOfViewX = camera->FieldOfViewX.Get();
lFieldOfViewY = camera->FieldOfViewY.Get();
}
#undef HFOV2VFOV
#undef VFOV2HFOV
FBXSDK_sprintf(buffer, 1024, "perspective,fov:%8.5f,aspect:-1,znear:%8.5f,zfar:%8.5f",
(float)lFieldOfViewY, nearZ, farZ);
sceneNode->attributes.push_back(std::make_pair(FbxString("projection"), FbxString(buffer)));
}
else
{
FBXSDK_sprintf(buffer, 1024, "orthogonal,aspect:-1,znear:%8.5f,zfar:%8.5f", nearZ, farZ);
sceneNode->attributes.push_back(std::make_pair(FbxString("projection"), FbxString(buffer)));
}
m_numCameras++;
}
else
{
FbxLight *light = node->GetLight();
if (light != NULL)
{
m_numLights++;
FBX_ASSERT(!"Not implemented!");
}
else
{
// Type
sceneNode->type = FbxString("drawable");
// Name
sceneNode->attributes.push_back(std::make_pair(FbxString("name"), node->GetName()));
// Transformation
FbxAMatrix m = node->EvaluateLocalTransform();
//FbxAMatrix m1 = node->EvaluateGlobalTransform();
const FbxVector4 translation = m.GetT();
const FbxVector4 rotation = m.GetR();
const FbxVector4 scaling = m.GetS();
float s[3], r[3], t[3];
t[0] = (float)translation.mData[0];
t[1] = (float)translation.mData[1];
t[2] = (float)translation.mData[2];
r[0] = (float)(rotation[0] * FBXSDK_DEG_TO_RAD);
r[1] = (float)(rotation[1] * FBXSDK_DEG_TO_RAD);
r[2] = (float)(rotation[2] * FBXSDK_DEG_TO_RAD);
s[0] = (float)scaling[0];
s[1] = (float)scaling[1];
s[2] = (float)scaling[2];
//const FbxVector4 translation1 = m1.GetT();
//const FbxVector4 rotation1 = m1.GetR();
//const FbxVector4 scaling1 = m1.GetS();
char buffer[1024];
FBXSDK_sprintf(buffer, 1024, "s:%8.5f,%8.5f,%8.5f,r:%8.5f,%8.5f,%8.5f,t:%8.5f,%8.5f,%8.5f",
s[0], s[1], s[2], r[0], r[1], r[2], t[0], t[1], t[2]);
sceneNode->attributes.push_back(std::make_pair(FbxString("transform"), FbxString(buffer)));
// Mesh
//if (node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eCamera)
//{
// FBXSDK_printf("f**k");
//}
static FbxUInt32 i = 0;
if (node->GetMesh() == NULL)
{
sceneNode->type = FbxString("node");
}
else
{
const char *meshName = node->GetMesh()->GetName();
if (meshName == NULL || meshName[0] == 0)
{
meshName = node->GetName();
}
FbxString prefix;
if (meshName == NULL || meshName[0] == 0)
{
prefix = FbxString("mesh_") + FbxString(int(i++));
}
else
{
prefix = FbxString(meshName);
}
sceneNode->geometry = prefix + FbxString(".") + m_arguments->meshFormat;
// Material
FbxSurfaceMaterial *material = node->GetMaterial(0);
if (material != NULL)
{
// This only gets the material of type sDiffuse, you probably need to
// traverse all Standard Material Property by its name to get all
// possible textures.
FbxProperty prop = material->FindProperty(FbxSurfaceMaterial::sDiffuse);
// Check if it's layeredtextures
int layeredTextureCount = prop.GetSrcObjectCount<FbxLayeredTexture>();
if (prop.GetSrcObjectCount<FbxTexture>() > 0)
{
FbxFileTexture *lTex = prop.GetSrcObject<FbxFileTexture>(0);
FbxString filename = FbxPathUtils::GetFileName(lTex->GetFileName());
sceneNode->texture = filename.Lower();
m_textures.push_back(FbxString(lTex->GetFileName()));
}
// root node is not counted as a drawable.
m_numDrawables++;
}
}
}
}
}
return sceneNode;
}
//===============================================================================================================================
void FBXLoader::LoadMaterialTexture(FbxSurfaceMaterial* inMaterial, ZShadeSandboxLighting::ShaderMaterial*& ioMaterial)
{
uint32 textureIndex = 0;
FbxProperty property;
FBXSDK_FOR_EACH_TEXTURE(textureIndex)
{
property = inMaterial->FindProperty(FbxLayerElement::sTextureChannelNames[textureIndex]);
if (property.IsValid())
{
uint32 textureCount = property.GetSrcObjectCount<FbxTexture>();
for (uint32 i = 0; i < textureCount; ++i)
{
FbxLayeredTexture* layeredTexture = property.GetSrcObject<FbxLayeredTexture>(i);
if(layeredTexture)
{
throw std::exception("Layered Texture is currently unsupported\n");
}
else
{
FbxTexture* texture = property.GetSrcObject<FbxTexture>(i);
if (texture)
{
std::string textureType = property.GetNameAsCStr();
FbxFileTexture* fileTexture = FbxCast<FbxFileTexture>(texture);
if (fileTexture)
{
string str_filename(fileTexture->GetFileName());
std::size_t index = str_filename.find_last_of('/\\');
if (index != string::npos)
{
BetterString str(fileTexture->GetFileName());
int dot_index = str.get_index('.');
BetterString pathName = str.substring(index + 1, dot_index);
BetterString ext = str.substring(dot_index + 1);
BetterString filename = pathName + "." + ext;
str_filename = filename.toString();
}
if (textureType == "DiffuseColor")
{
ioMaterial->sDiffuseTextureName = str_filename;
ioMaterial->bHasDiffuseTexture = true;
}
else if (textureType == "SpecularColor")
{
ioMaterial->sSpecularTextureName = str_filename;
ioMaterial->bHasSpecularTexture = true;
}
else if (textureType == "Bump")
{
ioMaterial->sNormalMapTextureName = str_filename;
ioMaterial->bHasNormalMapTexture = true;
}
}
}
}
}
}
}
ioMaterial->SetD3D(m_pD3DSystem);
bool addToMM = false;
if (ioMaterial->bHasDiffuseTexture)
{
ZShadeSandboxLighting::ShaderMaterial* material;
if (material = MaterialManager::Instance()->GetMaterial(ioMaterial->sMaterialName))
{
// The texture has already been loaded
ioMaterial->SetMaterialDiffuseTexture(material->DiffuseTexture());
}
else
{
// Need to load new texture
ioMaterial->AddDiffuseTexture(m_pGD3D->m_textures_path, ioMaterial->sDiffuseTextureName);
addToMM = true;
}
}
if (ioMaterial->bHasSpecularTexture)
{
ZShadeSandboxLighting::ShaderMaterial* material;
if (material = MaterialManager::Instance()->GetMaterial(ioMaterial->sMaterialName))
{
// The texture has already been loaded
ioMaterial->SetMaterialSpecularTexture(material->SpecularTexture());
}
else
{
// Need to load new texture
ioMaterial->AddDiffuseTexture(m_pGD3D->m_textures_path, ioMaterial->sSpecularTextureName);
addToMM = true;
}
}
if (ioMaterial->bHasNormalMapTexture)
{
ZShadeSandboxLighting::ShaderMaterial* material;
if (material = MaterialManager::Instance()->GetMaterial(ioMaterial->sMaterialName))
{
// The texture has already been loaded
ioMaterial->SetMaterialNormalMapTexture(material->NormalMapTexture());
}
else
{
// Need to load new texture
ioMaterial->AddDiffuseTexture(m_pGD3D->m_textures_path, ioMaterial->sNormalMapTextureName);
addToMM = true;
}
}
if (addToMM)
{
MaterialManager::Instance()->Add(ioMaterial);
}
}
FbxModelData* FBXLoader::loadModel( const char* aFile )
{
FBX_LOG("FBXLoader Creating ModelData...");
myLoadingModel = new FbxModelData;
FBX_LOG("Success!");
FBX_LOG("FBXLoader Creating TextureData...");
myLoadingModel->myTextureData = new TextureData();
FBX_LOG("Success!");
FBX_LOG("FBXLoader Loading Scene...");
auto scene = LoadScene(aFile);
FBX_LOG("Successfully loaded scene!");
FBX_LOG("FBXLoader Loading Textures...");
//TextureData
const int lTextureCount = scene->GetTextureCount();
for (int lTextureIndex = 0; lTextureIndex < lTextureCount; ++lTextureIndex)
{
FbxTexture * lTexture = scene->GetTexture(lTextureIndex);
FbxFileTexture * lFileTexture = reinterpret_cast<FbxFileTexture*>(lTexture);
if (lFileTexture && !lFileTexture->GetUserDataPtr())
{
const FbxString lFileName = lFileTexture->GetFileName();
unsigned int lTextureObject = 0;
lTextureObject;
bool lStatus = false;
lStatus;
const FbxString lAbsFbxFileName = FbxPathUtils::Resolve(aFile);
const FbxString lAbsFolderName = FbxPathUtils::GetFolderName(lAbsFbxFileName);
const FbxString lTextureFileName = lAbsFolderName + "\\" + lFileTexture->GetRelativeFileName();// FbxPathUtils::GetFileName(lFileName);
const FbxString lResolvedFileName = lAbsFolderName + "\\" + FbxPathUtils::GetFileName(lFileName);// lFileTexture->GetRelativeFileName();;// FbxPathUtils::Bind(lAbsFolderName, lTextureFileName);
TextureInfo info;
info.myFileName = lResolvedFileName;
//info.myFileName += "\\";
info.myFileName = lFileTexture->GetRelativeFileName();
myLoadingModel->myTextureData->myTextures.push_back(info);
lFileTexture->SetFileName(lResolvedFileName);
}
}
FBX_LOG("Success!");
FBX_LOG("FBXLoader Loading Animations...");
FbxArray<FbxString*> animationNames;
FbxArray<FbxPose*> poses;
scene->FillAnimStackNameArray(animationNames);
scene->FillPoseArray(poses);
FbxAnimStack * lCurrentAnimationStack = nullptr;
FbxAnimLayer* lCurrentAnimLayer = nullptr;
if(animationNames.GetCount() > 0)
{
lCurrentAnimationStack = scene->FindMember<FbxAnimStack>(animationNames[0]->Buffer());
if (lCurrentAnimationStack != NULL)
{
lCurrentAnimLayer = lCurrentAnimationStack->GetMember<FbxAnimLayer>();
}
}
//lCurrentAnimLayer->IsR
myLoadingModel->myAnimation = new AnimationData();
FbxPose* pose = nullptr;
if(poses.GetCount() > 0)
{
pose = poses[0];
}
LoadAnimation(*myLoadingModel->myAnimation,scene->GetRootNode(),FbxAMatrix(),pose, lCurrentAnimLayer,-1);
LoadNodeRecursive(myLoadingModel, *myLoadingModel->myAnimation, scene->GetRootNode(), FbxAMatrix(), pose, lCurrentAnimLayer, -1);
FBX_LOG("Success!");
return myLoadingModel;
}
void FbxMaterial::AddProperty(const FbxProperty &property,
const FbxProperty &factor_property)
{
/**
*If we are dealing with an invalid properties, abort
*/
if (!property.IsValid() || !factor_property.IsValid())
return;
/**
*Get the name of the property
*/
QString property_name = property.GetNameAsCStr();
/**
*Based on the property's name, load required stuff
*/
if (property_name == FbxSurfaceMaterial::sDiffuse)
{
/**
*Get the diffuse color and intensity
*/
FbxDouble3 diffuse_color = property.Get<FbxDouble3>();
FbxDouble diffuse_intensity = factor_property.Get<FbxDouble>();
/**
*Set diffuse color and intensity
*/
SetDiffuseColor(aae::mesh_util::QVector3DFromFbxVector3D(diffuse_color));
SetDiffuseIntensity(diffuse_intensity);
/**
*If there are no textures attached to the property, return
*/
if(!property.GetSrcObjectCount<FbxFileTexture>() > 0)
return;
/**
*Get the texture handler
*/
FbxFileTexture * texture = property.GetSrcObject<FbxFileTexture>();
if (!texture)
return;
/**
*Add the diffuse texture name of the material
*/
AddTexture(diffuse, texture->GetFileName());
}
else if (property_name == FbxSurfaceMaterial::sNormalMap)
{
/**
*If there are no textures attached to the property, return
*/
if(!property.GetSrcObjectCount<FbxFileTexture>() > 0)
return;
/**
*Get the texture handler
*/
FbxFileTexture * texture = property.GetSrcObject<FbxFileTexture>();
if (!texture)
return;
/**
*Set normal map texture of the material
*/
AddTexture(normal, texture->GetFileName());
}
else if (property_name == FbxSurfaceMaterial::sSpecular)
{
/**
*Get the specular color and intensity
*/
FbxDouble3 specular_color = property.Get<FbxDouble3>();
FbxDouble specular_intensity = factor_property.Get<FbxDouble>();
/**
*Set the specular color and intensity
*/
SetSpecularColor(aae::mesh_util::QVector3DFromFbxVector3D(specular_color));
SetSpecularIntensity(specular_intensity);
}
else if (property_name == FbxSurfaceMaterial::sShininess)
{
/**
*Get and set specular hardness
*/
FbxDouble specular_hardness = property.Get<FbxDouble>();
SetSpecularHardness(specular_hardness);
}
}
