3320 lines
109 KiB
C++
3320 lines
109 KiB
C++
/* = NULL */
|
|
//
|
|
//=============================================================================
|
|
|
|
|
|
// Valve includes
|
|
#include "filesystem.h"
|
|
#include "fbxsystem/ifbxsystem.h"
|
|
#include "fbxutils/dmfbxserializer.h"
|
|
#include "movieobjects/dmedccmakefile.h"
|
|
#include "movieobjects/dmeanimationlist.h"
|
|
#include "movieobjects/dmeaxissystem.h"
|
|
#include "movieobjects/dmechannel.h"
|
|
#include "movieobjects/dmeclip.h"
|
|
#include "movieobjects/dmecombinationoperator.h"
|
|
#include "movieobjects/dmedag.h"
|
|
#include "movieobjects/dmeexporttags.h"
|
|
#include "movieobjects/dmefaceset.h"
|
|
#include "movieobjects/dmelog.h"
|
|
#include "movieobjects/dmematerial.h"
|
|
#include "movieobjects/dmemesh.h"
|
|
#include "movieobjects/dmemodel.h"
|
|
#include "resourcefile/resourcedictionary.h"
|
|
#ifdef SOURCE2
|
|
#include "resourcesystem/resourcehandletypes.h"
|
|
#endif
|
|
#include "tier1/fmtstr.h"
|
|
|
|
|
|
// Last include
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CDmeFbxAxisSystem : public FbxAxisSystem
|
|
{
|
|
public:
|
|
CDmeFbxAxisSystem(
|
|
CDmeAxisSystem::Axis_t eUpAxis,
|
|
CDmeAxisSystem::ForwardParity_t eForwardParity,
|
|
CDmeAxisSystem::CoordSys_t eCoordSys )
|
|
: FbxAxisSystem(
|
|
static_cast< EUpVector >( eUpAxis ),
|
|
static_cast< EFrontVector >( eForwardParity ),
|
|
static_cast< ECoordSystem >( eCoordSys ) )
|
|
{
|
|
}
|
|
|
|
CDmeFbxAxisSystem( EUpVector eUpVector, EFrontVector eFrontVector, ECoordSystem eCoordSystem )
|
|
: FbxAxisSystem( eUpVector, eFrontVector, eCoordSystem )
|
|
{
|
|
}
|
|
|
|
CDmeFbxAxisSystem( const FbxAxisSystem &rhs )
|
|
{
|
|
FbxAxisSystem::operator=( rhs );
|
|
}
|
|
|
|
CDmeFbxAxisSystem &operator=( const FbxAxisSystem &rhs )
|
|
{
|
|
FbxAxisSystem::operator=( rhs );
|
|
return *this;
|
|
}
|
|
|
|
CUtlString GetAxes() const
|
|
{
|
|
int nUSign = 0;
|
|
const int nU = GetUpAxis( nUSign );
|
|
int nFSign = 0;
|
|
const int nF = GetFrontAxis( nFSign );
|
|
int nLSign = 0;
|
|
const int nL = GetLeftAxis( nLSign );
|
|
|
|
const char *szAxis[] = { "X", "Y", "Z" };
|
|
|
|
return CUtlString( CFmtStr( "U: %s%s F: %s%s L: %s%s",
|
|
nUSign < 0 ? "-" : " ", szAxis[nU],
|
|
nFSign < 0 ? "-" : " ", szAxis[nF],
|
|
nLSign < 0 ? "-" : " ", szAxis[nL] ).Get() );
|
|
}
|
|
|
|
CUtlString PrintRot( const FbxAxisSystem &from ) const
|
|
{
|
|
FbxMatrix mFbx;
|
|
GetConversionMatrix( from, mFbx );
|
|
FbxVector4 vT;
|
|
FbxQuaternion qR;
|
|
FbxVector4 vSh;
|
|
FbxVector4 vSc;
|
|
double flSign;
|
|
mFbx.GetElements( vT, qR, vSh, vSc, flSign );
|
|
FbxVector4 vR = qR.DecomposeSphericalXYZ();
|
|
|
|
mFbx = mFbx.Inverse();
|
|
mFbx.GetElements( vT, qR, vSh, vSc, flSign );
|
|
FbxVector4 vI = qR.DecomposeSphericalXYZ();
|
|
return CUtlString( CFmtStr( "F < %6.2f %6.2f %6.2f > I < %6.2f %6.2f %6.2f >\n",
|
|
RAD2DEG( vR[0] ),
|
|
RAD2DEG( vR[1] ),
|
|
RAD2DEG( vR[2] ),
|
|
RAD2DEG( vI[0] ),
|
|
RAD2DEG( vI[1] ),
|
|
RAD2DEG( vI[2] ) ).Get() );
|
|
}
|
|
|
|
void GetConversionRotation( RadianEuler &e, const FbxAxisSystem &from )
|
|
{
|
|
FbxMatrix mFbx;
|
|
GetConversionMatrix( from, mFbx );
|
|
mFbx = mFbx.Inverse();
|
|
FbxVector4 vT;
|
|
FbxQuaternion qR;
|
|
FbxVector4 vSh;
|
|
FbxVector4 vSc;
|
|
double flSign;
|
|
mFbx.GetElements( vT, qR, vSh, vSc, flSign );
|
|
FbxVector4 vR = qR.DecomposeSphericalXYZ();
|
|
e.x = vR[0];
|
|
e.y = vR[1];
|
|
e.z = vR[2];
|
|
}
|
|
|
|
int GetUpAxis( int &nSign ) const { nSign = mUpVector.mSign; return mUpVector.mAxis; };
|
|
int GetFrontAxis( int &nSign ) const { nSign = mFrontVector.mSign; return mFrontVector.mAxis; };
|
|
int GetLeftAxis( int &nSign ) const { nSign = mCoorSystem.mSign; return mCoorSystem.mAxis; };
|
|
|
|
// static void Validate();
|
|
};
|
|
|
|
|
|
#if 0
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFbxAxisSystem::Validate()
|
|
{
|
|
const int fbxUp[] = { -FbxAxisSystem::eXAxis, -FbxAxisSystem::eYAxis, -FbxAxisSystem::eZAxis, FbxAxisSystem::eXAxis, FbxAxisSystem::eYAxis, FbxAxisSystem::eZAxis };
|
|
const int fbxParity[] = { -FbxAxisSystem::eParityEven, -FbxAxisSystem::eParityOdd, FbxAxisSystem::eParityEven, FbxAxisSystem::eParityOdd };
|
|
|
|
const int dmxUp[] = { CDmeAxisSystem::AS_AXIS_NX, CDmeAxisSystem::AS_AXIS_NY, CDmeAxisSystem::AS_AXIS_NZ, CDmeAxisSystem::AS_AXIS_X, CDmeAxisSystem::AS_AXIS_Y, CDmeAxisSystem::AS_AXIS_Z };
|
|
const int dmxParity[] = { CDmeAxisSystem::AS_PARITY_NEVEN, CDmeAxisSystem::AS_PARITY_NODD, CDmeAxisSystem::AS_PARITY_EVEN, CDmeAxisSystem::AS_PARITY_ODD };
|
|
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( fbxUp ) == ARRAYSIZE( dmxUp ) );
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( fbxParity ) == ARRAYSIZE( dmxParity ) );
|
|
|
|
int nOkCount = 0;
|
|
int nBadCount = 0;
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( fbxUp ); ++i )
|
|
{
|
|
const int nFbxAU = fbxUp[i];
|
|
const int nDmxAU = dmxUp[i];
|
|
|
|
Assert( nFbxAU == nDmxAU );
|
|
|
|
for ( int j = 0; j < ARRAYSIZE( fbxParity ); ++j )
|
|
{
|
|
const int nFbxAP = fbxParity[j];
|
|
const int nDmxAP = dmxParity[j];
|
|
|
|
Assert( nFbxAP == nDmxAP );
|
|
|
|
// A = FROM
|
|
CDmeFbxAxisSystem fA(
|
|
static_cast< FbxAxisSystem::EUpVector >( nFbxAU ),
|
|
static_cast< FbxAxisSystem::EFrontVector >( nFbxAP ),
|
|
FbxAxisSystem::eRightHanded );
|
|
|
|
const CDmeAxisSystem::Axis_t eAU = static_cast< CDmeAxisSystem::Axis_t >( nDmxAU );
|
|
const CDmeAxisSystem::ForwardParity_t eAF = static_cast< CDmeAxisSystem::ForwardParity_t >( nDmxAP );
|
|
const CDmeAxisSystem::CoordSys_t eAC = CDmeAxisSystem::AS_RIGHT_HANDED;
|
|
|
|
for ( int k = 0; k < ARRAYSIZE( fbxUp ); ++k )
|
|
{
|
|
const int nFbxBU = fbxUp[k];
|
|
const int nDmxBU = dmxUp[k];
|
|
|
|
Assert( nFbxBU == nDmxBU );
|
|
|
|
for ( int l = 0; l < ARRAYSIZE( fbxParity ); ++l )
|
|
{
|
|
const int nFbxBP = fbxParity[l];
|
|
const int nDmxBP = dmxParity[l];
|
|
|
|
Assert( nFbxBP == nDmxBP );
|
|
|
|
// B = TO
|
|
CDmeFbxAxisSystem fB(
|
|
static_cast< FbxAxisSystem::EUpVector >( nFbxBU ),
|
|
static_cast< FbxAxisSystem::EFrontVector >( nFbxBP ),
|
|
FbxAxisSystem::eRightHanded );
|
|
|
|
const CDmeAxisSystem::Axis_t eBU = static_cast< CDmeAxisSystem::Axis_t >( nDmxBU );
|
|
const CDmeAxisSystem::ForwardParity_t eBF = static_cast< CDmeAxisSystem::ForwardParity_t >( nDmxBP );
|
|
const CDmeAxisSystem::CoordSys_t eBC = CDmeAxisSystem::AS_RIGHT_HANDED;
|
|
|
|
RadianEuler eFbx;
|
|
fB.GetConversionRotation( eFbx, fA );
|
|
|
|
if ( i == k && j == l )
|
|
{
|
|
Assert( RadianEulersAreEqual( eFbx, RadianEuler( 0.0f, 0.0f, 0.0f ), 1.0e-6 ) );
|
|
}
|
|
|
|
matrix3x4a_t mDmx;
|
|
CDmeAxisSystem::GetConversionMatrix( mDmx,
|
|
eBU, eBF, eBC,
|
|
eAU, eAF, eAC );
|
|
RadianEuler eDmx;
|
|
MatrixAngles( mDmx, eDmx );
|
|
|
|
if ( i == k && j == l )
|
|
{
|
|
Assert( RadianEulersAreEqual( eDmx, RadianEuler( 0.0f, 0.0f, 0.0f ), 1.0e-6 ) );
|
|
}
|
|
|
|
// Account for FBX/DMX differences in converting matrix to Euler
|
|
Quaternion qFbx = eFbx;
|
|
QuaternionNormalize( qFbx );
|
|
Quaternion qDmx = eDmx;
|
|
QuaternionNormalize( qDmx );
|
|
eFbx = qFbx;
|
|
eDmx = qDmx;
|
|
|
|
if ( !QuaternionsAreEqual( qFbx, qDmx, 1.0e-6 ) )
|
|
{
|
|
Msg( " * FBX \"%s\" -> \"%s\": %6.2f %6.2f %6.2f\n", fA.GetAxes().Get(), fB.GetAxes().Get(),
|
|
RAD2DEG( eFbx.x ),
|
|
RAD2DEG( eFbx.y ),
|
|
RAD2DEG( eFbx.z ) );
|
|
Msg( " * DMX \"%s\" -> \"%s\": %6.2f %6.2f %6.2f\n",
|
|
CDmeAxisSystem::GetAxisString( eAU, eAF, eAC ).Get(),
|
|
CDmeAxisSystem::GetAxisString( eBU, eBF, eBC ).Get(),
|
|
RAD2DEG( eDmx.x ),
|
|
RAD2DEG( eDmx.y ),
|
|
RAD2DEG( eDmx.z ) );
|
|
Msg( "\n" );
|
|
|
|
++nBadCount;
|
|
}
|
|
else
|
|
{
|
|
++nOkCount;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Msg( " * OK: %4d Bad: %d\n", nOkCount, nBadCount );
|
|
}
|
|
#endif // 0
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
const char *FbxImporterGetErrorString( FbxImporter *pFbxImporter )
|
|
{
|
|
#if FBXSDK_VERSION_MAJOR >= 2014
|
|
return pFbxImporter->GetStatus().GetErrorString();
|
|
#else // FBXSDK_VERSION_MAJOR
|
|
return pFbxImporter->GetLastErrorString();
|
|
#endif // FBXSDK_VERSION_MAJOR
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// CDmFbxSerializer
|
|
//
|
|
//=============================================================================
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmFbxSerializer::CDmFbxSerializer()
|
|
: m_nOptVerbosity( 0 )
|
|
, m_bOptUnderscoreForCorrectors( false )
|
|
, m_bAnimation( false )
|
|
, m_bReturnDmeModel( false )
|
|
, m_flOptScale( 1.0f )
|
|
{
|
|
// Initialize Axis System To Maya Y Up
|
|
CDmeAxisSystem::GetPredefinedAxisSystem( m_eOptUpAxis, m_eOptForwardParity, m_eCoordSys, CDmeAxisSystem::AS_MAYA_YUP );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmFbxSerializer::~CDmFbxSerializer()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Common function both ReadFBX & Unserialize can call
|
|
//-----------------------------------------------------------------------------
|
|
CDmElement *CDmFbxSerializer::ReadFBX( const char *pszFilename )
|
|
{
|
|
FbxManager *pFbxManager = GetFbxManager();
|
|
if ( !pFbxManager )
|
|
return NULL;
|
|
|
|
DmFileId_t nDmFileId = g_pDataModel->FindOrCreateFileId( pszFilename );
|
|
|
|
if ( nDmFileId == DMFILEID_INVALID )
|
|
{
|
|
Warning( "Warning! Couldn't create DmFileId_t for \"%s\"\n", pszFilename );
|
|
return NULL;
|
|
}
|
|
|
|
FbxTime::EMode eFbxTimeMode = FbxTime::eFrames30;
|
|
|
|
FbxScene *pFbxScene = LoadFbxScene( eFbxTimeMode, pszFilename );
|
|
if ( !pFbxScene )
|
|
return NULL;
|
|
|
|
if ( !FloatsAreEqual( m_flOptScale, 1.0f, 1.0e-4 ) )
|
|
{
|
|
FbxSystemUnit fbxSystemUnit( 1.0 / m_flOptScale );
|
|
fbxSystemUnit.ConvertScene( pFbxScene );
|
|
}
|
|
|
|
CDmeFbxAxisSystem fromAxisSystem = pFbxScene->GetGlobalSettings().GetAxisSystem();
|
|
CDmeFbxAxisSystem toAxisSystem( m_eOptUpAxis, m_eOptForwardParity, m_eCoordSys );
|
|
toAxisSystem.ConvertScene( pFbxScene );
|
|
|
|
CDmeAxisSystem::Axis_t eUpAxis;
|
|
CDmeAxisSystem::ForwardParity_t eForwardParity;
|
|
CDmeAxisSystem::CoordSys_t eCoordSys;
|
|
|
|
{
|
|
// nU [ -1, 1 ], eU [ 1, 2, 3 ]
|
|
int nU = 0;
|
|
const int eU = fromAxisSystem.GetUpVector( nU );
|
|
eUpAxis = static_cast< CDmeAxisSystem::Axis_t >( nU * eU );
|
|
|
|
// nF [ -1, 1 ], eF [ 1, 2 ]
|
|
int nF = 0;
|
|
const int eF = fromAxisSystem.GetFrontVector( nF );
|
|
eForwardParity = static_cast< CDmeAxisSystem::ForwardParity_t >( nF * eF );
|
|
|
|
// GetCoordSys() [ 0, 1 ]
|
|
eCoordSys = static_cast< CDmeAxisSystem::CoordSys_t >( fromAxisSystem.GetCoorSystem() );
|
|
}
|
|
|
|
char szFileBase[ MAX_PATH ] = "";
|
|
V_FileBase( pszFilename, szFileBase, ARRAYSIZE( szFileBase ) );
|
|
|
|
CDmElement *pDmeRoot = NULL;
|
|
CDmeModel *pDmeModel = CreateElement< CDmeModel >( szFileBase, nDmFileId );
|
|
#ifdef SOURCE2
|
|
pDmeModel->SetAxisSystem( m_eOptUpAxis, m_eOptForwardParity, m_eCoordSys );
|
|
#endif
|
|
if ( !m_bAnimation && m_bReturnDmeModel )
|
|
{
|
|
pDmeRoot = pDmeModel;
|
|
}
|
|
else
|
|
{
|
|
pDmeRoot = CreateElement< CDmElement >( "root", nDmFileId );
|
|
pDmeRoot->SetValue( "skeleton", pDmeModel );
|
|
|
|
if ( !m_bAnimation )
|
|
{
|
|
// Don't set "model" if animation only... Studiomdl can't handle it
|
|
pDmeRoot->SetValue( "model", pDmeModel );
|
|
}
|
|
}
|
|
|
|
g_pDataModel->SetFileRoot( nDmFileId, pDmeRoot->GetHandle() );
|
|
|
|
CDmeDCCMakefile *pDmeMakefile = CreateElement< CDmeDCCMakefile >( "makefile", nDmFileId );
|
|
pDmeRoot->SetValue( pDmeMakefile->GetName(), pDmeMakefile );
|
|
|
|
// DMX sources are relative to the DMX file
|
|
|
|
char szFullPath[ MAX_PATH ];
|
|
if ( g_pFullFileSystem->RelativePathToFullPath( pszFilename, NULL, szFullPath, ARRAYSIZE( szFullPath ) ) )
|
|
{
|
|
pDmeMakefile->AddSource< CDmeSource >( szFullPath );
|
|
}
|
|
else
|
|
{
|
|
pDmeMakefile->AddSource< CDmeSource >( pszFilename );
|
|
}
|
|
|
|
FbxDocumentInfo *pFbxDocumentInfo = pFbxScene->GetSceneInfo();
|
|
if ( pFbxDocumentInfo )
|
|
{
|
|
FbxString sUrl = pFbxDocumentInfo->LastSavedUrl.Get();
|
|
FbxString sOrigFilename = pFbxDocumentInfo->Original_FileName.Get();
|
|
|
|
char szUrl[MAX_PATH] = {};
|
|
char szOrigFilename[MAX_PATH] = {};
|
|
|
|
V_FixupPathName( szUrl, ARRAYSIZE( szUrl ), sUrl.Buffer() );
|
|
V_FixSlashes( szUrl, '/' );
|
|
V_FixupPathName( szOrigFilename, ARRAYSIZE( szOrigFilename ), sOrigFilename.Buffer() );
|
|
V_FixSlashes( szOrigFilename, '/' );
|
|
|
|
if ( V_strcmp( szUrl, szOrigFilename ) != 0 )
|
|
{
|
|
#ifdef SOURCE2
|
|
char szRelativePath[MAX_PATH] = {};
|
|
GenerateResourceNameFromFileName( sOrigFilename.Buffer(), szRelativePath, ARRAYSIZE( szRelativePath ) );
|
|
|
|
if ( V_strlen( szRelativePath ) > 0 && GenerateStandardFullPathForResourceName( szRelativePath, RESOURCE_PATH_CONTENT, szFullPath, ARRAYSIZE( szFullPath ) ) )
|
|
{
|
|
pDmeMakefile->AddSource< CDmeSource >( szFullPath );
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
pDmeMakefile->AddSource< CDmeSource >( sOrigFilename.Buffer() );
|
|
}
|
|
}
|
|
}
|
|
|
|
CDmeExportTags *pDmeExportTags = CreateElement< CDmeExportTags >( "exportTags", nDmFileId );
|
|
pDmeExportTags->Init( "fbx2dmx", g_pFbx->GetFbxManager()->GetVersion() );
|
|
pDmeExportTags->SetValue( "cmdLine", CommandLine()->GetCmdLine() );
|
|
{
|
|
char szCurrentDirectory[ MAX_PATH ];
|
|
Plat_getwd( szCurrentDirectory, ARRAYSIZE( szCurrentDirectory ) );
|
|
V_FixSlashes( szCurrentDirectory, '/' );
|
|
pDmeExportTags->SetValue( "pwd", szCurrentDirectory );
|
|
}
|
|
|
|
pDmeRoot->SetValue( pDmeExportTags->GetName(), pDmeExportTags );
|
|
|
|
CDmAttribute *pRootAttr = pDmeModel->AddAttribute( "__rootElement", AT_ELEMENT );
|
|
if ( pRootAttr )
|
|
{
|
|
pRootAttr->AddFlag( FATTRIB_DONTSAVE );
|
|
pRootAttr->SetValue( pDmeRoot );
|
|
}
|
|
|
|
FbxToDmxMap_t fbxToDmxMap( CDefOps< FbxToDmxMap_t::KeyType_t >::LessFunc );
|
|
|
|
// Don't create a DmeDag for the root node
|
|
FbxNode *pFbxRootNode = pFbxScene->GetRootNode();
|
|
|
|
if ( Verbose2() )
|
|
{
|
|
Msg( " * Skeleton\n" );
|
|
}
|
|
|
|
for ( int i = 0; i < pFbxRootNode->GetChildCount(); ++i )
|
|
{
|
|
LoadModelAndSkeleton_R( fbxToDmxMap, pDmeModel, pDmeModel, pFbxRootNode->GetChild( i ), m_bAnimation, 0 );
|
|
}
|
|
|
|
pDmeModel->CaptureJointsToBaseState( "bind" );
|
|
|
|
if ( m_bAnimation )
|
|
{
|
|
LoadAnimation( pDmeRoot, pDmeModel, fbxToDmxMap, pFbxScene, pFbxRootNode, eFbxTimeMode );
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < pFbxRootNode->GetChildCount(); ++i )
|
|
{
|
|
SkinMeshes_R( fbxToDmxMap, pDmeModel, pFbxRootNode->GetChild( i ) );
|
|
AddBlendShapes_R( fbxToDmxMap, pDmeRoot, pFbxRootNode->GetChild( i ) );
|
|
}
|
|
}
|
|
|
|
pFbxScene->Destroy();
|
|
|
|
pDmeModel->ConvertToAxisSystem( CDmeAxisSystem::AS_VALVE_ENGINE );
|
|
|
|
return pDmeRoot;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Feed the CDmElement returned by ReadFBX to see if there were non-fatal conversion errors which the user should be informed about
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmFbxSerializer::HasConversionErrors( CDmElement *pDmRoot )
|
|
{
|
|
if ( !pDmRoot )
|
|
return false;
|
|
|
|
CDmAttribute *pConversionErrorsAttr = pDmRoot->GetAttribute( "conversionErrors", AT_STRING_ARRAY );
|
|
if ( !pConversionErrorsAttr )
|
|
return false;
|
|
|
|
return ( CDmrStringArrayConst( pConversionErrorsAttr ).Count() > 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Feed the CDmElement returned by ReadFBX to see if there were non-fatal conversion errors which the user should be informed about, they are stored in pConversionErrors, if no errors, pConversionErrors is not touched
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::GetConversionErrors( CDmElement *pDmRoot, CUtlVector< CUtlString > *pConversionErrors )
|
|
{
|
|
if ( !pDmRoot || !pConversionErrors || !HasConversionErrors( pDmRoot ) )
|
|
return;
|
|
|
|
CDmAttribute *pConversionErrorsAttr = pDmRoot->GetAttribute( "conversionErrors", AT_STRING_ARRAY );
|
|
if ( !pConversionErrorsAttr )
|
|
return;
|
|
|
|
CDmrStringArrayConst conversionErrors( pConversionErrorsAttr );
|
|
|
|
for ( int i = 0; i < conversionErrors.Count(); ++i )
|
|
{
|
|
pConversionErrors->AddToTail( conversionErrors[i] );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
FbxScene *CDmFbxSerializer::LoadFbxScene( FbxTime::EMode &eFbxTimeMode, const char *pszFilename )
|
|
{
|
|
FbxManager *pFbxManager = GetFbxManager();
|
|
if ( !pFbxManager )
|
|
return NULL;
|
|
|
|
if ( Verbose1() )
|
|
{
|
|
Msg( "Reading FBX: %s\n", pszFilename );
|
|
}
|
|
|
|
// Get the file version number generate by the FBX SDK.
|
|
int nSDKMajor = 0;
|
|
int nSDKMinor = 0;
|
|
int nSDKRevision = 0;
|
|
FbxManager::GetFileFormatVersion( nSDKMajor, nSDKMinor, nSDKRevision );
|
|
|
|
if ( Verbose2() )
|
|
{
|
|
Msg( "FBX file version %d.%d.%d - SDK\n", nSDKMajor, nSDKMinor, nSDKRevision );
|
|
}
|
|
|
|
FbxIOSettings *pFbxIOSettings = FbxIOSettings::Create( pFbxManager, IOSROOT );
|
|
FbxImporter *pFbxImporter = FbxImporter::Create( pFbxManager, "" );
|
|
pFbxImporter->ParseForGlobalSettings( true );
|
|
|
|
// Initialize the importer by providing a filename.
|
|
const bool bImportStatus = pFbxImporter->Initialize( pszFilename, -1, pFbxIOSettings );
|
|
|
|
int nFileMajor = 0;
|
|
int nFileMinor = 0;
|
|
int nFileRevision = 0;
|
|
pFbxImporter->GetFileVersion( nFileMajor, nFileMinor, nFileRevision );
|
|
|
|
if ( !bImportStatus )
|
|
{
|
|
Warning( "Warning! Couldn't import specified file as FBX \"%s\": %s\n",
|
|
pszFilename, pFbxImporter->GetStatus().GetErrorString() );
|
|
|
|
if ( pFbxImporter->GetStatus().GetCode() == FbxStatus::eInvalidFileVersion )
|
|
{
|
|
Warning( "Warning! FBX file version mismatch SDK %d.%d.%d vs File %d.%d.%d\n",
|
|
nSDKMajor, nSDKMinor, nSDKRevision,
|
|
nFileMajor, nFileMinor, nFileRevision );
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if ( pFbxImporter->IsFBX() )
|
|
{
|
|
if ( Verbose2() )
|
|
{
|
|
Msg( "FBX file version %d.%d.%d - %s\n", nFileMajor, nFileMinor, nFileRevision, pszFilename );
|
|
|
|
// From this point, it is possible to access animation stack information without
|
|
// the expense of loading the entire file.
|
|
|
|
Msg( "Animation Stack Information\n");
|
|
|
|
const int nAnimStackCount = pFbxImporter->GetAnimStackCount();
|
|
|
|
Msg( " Number of Animation Stacks: %d\n", nAnimStackCount );
|
|
Msg( " Current Animation Stack: \"%s\"\n", pFbxImporter->GetActiveAnimStackName().Buffer() );
|
|
Msg( "\n" );
|
|
|
|
for ( int i = 0; i < nAnimStackCount; ++i )
|
|
{
|
|
FbxTakeInfo *pFbxTakeInfo = pFbxImporter->GetTakeInfo( i );
|
|
|
|
Msg( " Animation Stack %d\n", i );
|
|
Msg( " Name: \"%s\"\n", pFbxTakeInfo->mName.Buffer() );
|
|
Msg( " Description: \"%s\"\n", pFbxTakeInfo->mDescription.Buffer() );
|
|
|
|
// Change the value of the import name if the animation stack should be imported
|
|
// under a different name.
|
|
Msg( " Import Name: \"%s\"\n", pFbxTakeInfo->mImportName.Buffer() );
|
|
|
|
// Set the value of the import state to false if the animation stack should be not
|
|
// be imported.
|
|
Msg( " Import State: %s\n", pFbxTakeInfo->mSelect ? "true" : "false" );
|
|
Msg( "\n");
|
|
}
|
|
}
|
|
|
|
// Set the import states. By default, the import states are always set to
|
|
// true. The code below shows how to change these states.
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_MATERIAL, true );
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_TEXTURE, true );
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_LINK, true );
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_SHAPE, true );
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_GOBO, true );
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_ANIMATION, true );
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_GLOBAL_SETTINGS, true );
|
|
}
|
|
|
|
FbxScene *pFbxScene = FbxScene::Create( pFbxManager, "" );
|
|
|
|
if ( pFbxScene )
|
|
{
|
|
// Import the scene.
|
|
bool bStatus = pFbxImporter->Import( pFbxScene );
|
|
|
|
if ( bStatus == false && pFbxImporter->GetStatus().GetCode() == FbxStatus::ePasswordError )
|
|
{
|
|
Warning( "Warning! Password protected FBX files unsupported\n" );
|
|
|
|
pFbxScene->Destroy();
|
|
pFbxScene = NULL;
|
|
|
|
/* TODO: Handle password protected FBX files...
|
|
|
|
Msg( "Please enter password: ");
|
|
|
|
char szPassword[1024];
|
|
szPassword[0] = '\0';
|
|
|
|
FBXSDK_CRT_SECURE_NO_WARNING_BEGIN
|
|
scanf( "%s", szPassword );
|
|
FBXSDK_CRT_SECURE_NO_WARNING_END
|
|
|
|
FbxString lString(szPassword);
|
|
|
|
pFbxIOSettings->SetStringProp( IMP_FBX_PASSWORD, lString );
|
|
pFbxIOSettings->SetBoolProp( IMP_FBX_PASSWORD_ENABLE, true );
|
|
|
|
bStatus = pFbxImporter->Import( pFbxScene );
|
|
|
|
if ( bStatus == false && pFbxImporter->GetLastErrorID() == FbxIOBase::ePasswordError )
|
|
{
|
|
Msg( "\nPassword is wrong, import aborted.\n" );
|
|
pFbxScene->Destroy();
|
|
pFbxScene = NULL;
|
|
}
|
|
*/
|
|
}
|
|
|
|
eFbxTimeMode = FbxTime::eFrames30;
|
|
|
|
if ( !pFbxImporter->GetFrameRate( eFbxTimeMode ) )
|
|
{
|
|
eFbxTimeMode = FbxTime::eFrames30;
|
|
}
|
|
|
|
// Destroy the importer.
|
|
pFbxImporter->Destroy();
|
|
}
|
|
else
|
|
{
|
|
Warning( "Warning! Couldn't create FbxScene\n" );
|
|
}
|
|
|
|
return pFbxScene;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::LoadModelAndSkeleton_R(
|
|
FbxToDmxMap_t &fbxToDmxMap, CDmeModel *pDmeModel, CDmeDag *pDmeDagParent, FbxNode *pFbxNode, bool bAnimation, int nDepth ) const
|
|
{
|
|
FbxString sIndent;
|
|
for ( int i = 0; i < nDepth; ++i )
|
|
{
|
|
sIndent += " ";
|
|
}
|
|
|
|
CDmeDag *pDmeDag = NULL;
|
|
const char *pszFbxType = NULL;
|
|
const char *pszDmeType = NULL;
|
|
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
if ( pFbxNodeAttribute )
|
|
{
|
|
const FbxNodeAttribute::EType nAttributeType = pFbxNodeAttribute->GetAttributeType();
|
|
|
|
switch ( nAttributeType )
|
|
{
|
|
case FbxNodeAttribute::eNull:
|
|
pszFbxType = "Transform";
|
|
if ( pFbxNode->GetDstObjectCount( FbxCluster::ClassId ) > 0 )
|
|
{
|
|
pDmeDag = FbxNodeToDmeDag( pDmeDagParent, pFbxNode, "DmeJoint" );
|
|
}
|
|
else
|
|
{
|
|
pDmeDag = FbxNodeToDmeDag( pDmeDagParent, pFbxNode, "DmeDag" );
|
|
}
|
|
break;
|
|
case FbxNodeAttribute::eSkeleton:
|
|
pszFbxType = "Skeleton";
|
|
pDmeDag = FbxNodeToDmeDag( pDmeDagParent, pFbxNode, "DmeJoint" );
|
|
break;
|
|
case FbxNodeAttribute::eMesh:
|
|
{
|
|
pszFbxType = "Mesh";
|
|
pszDmeType = "DmeMesh";
|
|
FbxMatrix mScale;
|
|
pDmeDag = FbxNodeToDmeDag( pDmeDagParent, pFbxNode, "DmeDag", &mScale );
|
|
if ( !bAnimation )
|
|
{
|
|
FbxShapeToDmeMesh( pDmeDag, pFbxNode, mScale );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
Warning( "Warning! Ignoring Unsupported FBX Node Attribute Type: %s.%s(%s)\n",
|
|
pFbxNode->GetName(), pFbxNodeAttribute->GetName(), pFbxNodeAttribute->GetTypeName() );
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( Verbose2() && pDmeDag && pszFbxType )
|
|
{
|
|
Msg( "%s + %-8s %s\n",
|
|
sIndent.Buffer(), pszDmeType ? pszDmeType : pDmeDag->GetTypeString(), pDmeDag->GetName() );
|
|
}
|
|
|
|
if ( pDmeDag )
|
|
{
|
|
pDmeModel->AddJoint( pDmeDag );
|
|
fbxToDmxMap.Insert( pFbxNode, pDmeDag );
|
|
|
|
for ( int i = 0; i < pFbxNode->GetChildCount(); ++i )
|
|
{
|
|
LoadModelAndSkeleton_R( fbxToDmxMap, pDmeModel, pDmeDag, pFbxNode->GetChild( i ), bAnimation, nDepth + 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts an FbxMatrix to a Valve matrix3x4_t (transpose)
|
|
//-----------------------------------------------------------------------------
|
|
inline void MatrixFbxToValve( matrix3x4_t &mValve, const FbxMatrix &mFbx )
|
|
{
|
|
mValve[0][0] = mFbx[0][0]; mValve[0][1] = mFbx[1][0]; mValve[0][2] = mFbx[2][0]; mValve[0][3] = mFbx[3][0];
|
|
mValve[1][0] = mFbx[0][1]; mValve[1][1] = mFbx[1][1]; mValve[1][2] = mFbx[2][1]; mValve[1][3] = mFbx[3][1];
|
|
mValve[2][0] = mFbx[0][2]; mValve[2][1] = mFbx[1][2]; mValve[2][2] = mFbx[2][2]; mValve[2][3] = mFbx[3][2];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Valve matrix3x4_t to an FbxMatrix (transpose)
|
|
//-----------------------------------------------------------------------------
|
|
inline void MatrixValveToFbx( FbxMatrix &mFbx, const matrix3x4_t &mValve )
|
|
{
|
|
mFbx[0][0] = mValve[0][0]; mFbx[0][1] = mValve[1][0]; mFbx[0][2] = mValve[2][0]; mFbx[3][0] = 0.0;
|
|
mFbx[1][0] = mValve[0][1]; mFbx[1][1] = mValve[1][1]; mFbx[1][2] = mValve[2][1]; mFbx[3][1] = 0.0;
|
|
mFbx[2][0] = mValve[0][2]; mFbx[2][1] = mValve[1][2]; mFbx[2][2] = mValve[2][2]; mFbx[3][2] = 0.0;
|
|
mFbx[3][0] = mValve[0][3]; mFbx[3][1] = mValve[1][3]; mFbx[3][2] = mValve[2][3]; mFbx[3][3] = 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeDag *CDmFbxSerializer::FbxNodeToDmeDag( CDmeDag *pDmeDagParent, FbxNode *pFbxNode, const char *pszDmeType, FbxMatrix *pmOutScale /* = NULL */ ) const
|
|
{
|
|
const bool bRoot = pDmeDagParent->IsA( CDmeModel::GetStaticTypeSymbol() );
|
|
|
|
const FbxAMatrix &mFbxWorld = pFbxNode->EvaluateGlobalTransform();
|
|
|
|
const FbxVector4 vFbxTranslate = mFbxWorld.GetT();
|
|
const FbxQuaternion qFbxRotate = mFbxWorld.GetQ();
|
|
|
|
Assert( vFbxTranslate[3] == 0.0 || vFbxTranslate[3] == 1.0 );
|
|
|
|
CUtlString sName;
|
|
GetName( sName, pFbxNode );
|
|
|
|
Vector vDmeTranslate( vFbxTranslate[0], vFbxTranslate[1], vFbxTranslate[2] );
|
|
Quaternion qDmeRotate( qFbxRotate[0], qFbxRotate[1], qFbxRotate[2], qFbxRotate[3] );
|
|
|
|
DmElementHandle_t hElement = g_pDataModel->CreateElement( pszDmeType, sName.String(), pDmeDagParent->GetFileId() );
|
|
CDmeDag *pDmeDag = CastElement< CDmeDag >( g_pDataModel->GetElement( hElement ) );
|
|
|
|
CDmeTransform *pDmeTransform = pDmeDag->GetTransform();
|
|
pDmeTransform->SetName( pDmeDag->GetName() );
|
|
|
|
if ( !bRoot )
|
|
{
|
|
matrix3x4_t mDmeParentWorld;
|
|
pDmeDagParent->GetAbsTransform( mDmeParentWorld );
|
|
matrix3x4_t mDmeParentWorldInverse;
|
|
MatrixInvert( mDmeParentWorld, mDmeParentWorldInverse );
|
|
matrix3x4_t mDmeWorld;
|
|
AngleMatrix( RadianEuler( qDmeRotate ), vDmeTranslate, mDmeWorld );
|
|
matrix3x4_t mDmeLocal;
|
|
MatrixMultiply( mDmeParentWorldInverse, mDmeWorld, mDmeLocal );
|
|
MatrixAngles( mDmeLocal, qDmeRotate, vDmeTranslate );
|
|
}
|
|
else
|
|
{
|
|
CDmAttribute *pDmeRootNodeAttr = pDmeDag->AddAttribute( "__rootNode", AT_BOOL );
|
|
pDmeRootNodeAttr->AddFlag( FATTRIB_DONTSAVE );
|
|
pDmeRootNodeAttr->SetValue( bRoot );
|
|
}
|
|
|
|
pDmeTransform->SetOrientation( qDmeRotate );
|
|
pDmeTransform->SetPosition( vDmeTranslate );
|
|
|
|
pDmeDagParent->AddChild( pDmeDag );
|
|
|
|
if ( pmOutScale )
|
|
{
|
|
FbxMatrix mfWf = mFbxWorld;
|
|
FbxMatrix mfWv;
|
|
|
|
{
|
|
matrix3x4_t mvWv; // mvWv = World Matrix3x4 Valve
|
|
pDmeDag->GetAbsTransform( mvWv );
|
|
MatrixValveToFbx( mfWv, mvWv );
|
|
}
|
|
|
|
const FbxMatrix mfWv_ = mfWv.Inverse();
|
|
*pmOutScale = mfWv_ * mfWf;
|
|
}
|
|
|
|
return pDmeDag;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool AddPositionData( CDmeVertexData *pDmeVertexData, const CUtlVector< int > &nIndices, const FbxMesh *pFbxMesh, const FbxMatrix &mScale )
|
|
{
|
|
if ( !pFbxMesh || nIndices.Count() <= 0 )
|
|
return false;
|
|
|
|
const FbxVector4 *pvFbxData = pFbxMesh->GetControlPoints();
|
|
const int nDataCount = pFbxMesh->GetControlPointsCount();
|
|
|
|
CUtlVector< Vector > dmxData;
|
|
dmxData.SetCount( nDataCount );
|
|
|
|
for ( int i = 0; i < dmxData.Count(); ++i )
|
|
{
|
|
Vector &vDmxData = dmxData[i];
|
|
const FbxVector4 vFbxData = mScale.MultNormalize( pvFbxData[i] );
|
|
vDmxData.x = vFbxData[0];
|
|
vDmxData.y = vFbxData[1];
|
|
vDmxData.z = vFbxData[2];
|
|
|
|
Assert( vFbxData[3] == 0 || vFbxData[3] == 1 );
|
|
}
|
|
|
|
const FieldIndex_t nFieldIndex = pDmeVertexData->CreateField( CDmeVertexDataBase::FIELD_POSITION );
|
|
pDmeVertexData->AddVertexData( nFieldIndex, dmxData.Count() );
|
|
pDmeVertexData->SetVertexData( nFieldIndex, 0, dmxData.Count(), AT_VECTOR3, dmxData.Base() );
|
|
pDmeVertexData->AddVertexIndices( nIndices.Count() );
|
|
pDmeVertexData->SetVertexIndices( nFieldIndex, 0, nIndices.Count(), nIndices.Base() );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void AddUVData( CDmeVertexData *pDmeVertexData, const CUtlVector< int > &nIndices, const FbxGeometryElementUV *pFbxElement, int nSemanticIndex )
|
|
{
|
|
if ( !pFbxElement || nIndices.Count() <= 0 )
|
|
return;
|
|
|
|
const FbxLayerElementArrayTemplate< FbxVector2 > &fbxData = pFbxElement->GetDirectArray();
|
|
const int nDataCount = fbxData.GetCount();
|
|
|
|
CUtlVector< Vector2D > dmxData;
|
|
dmxData.SetCount( nDataCount );
|
|
|
|
for ( int i = 0; i < dmxData.Count(); ++i )
|
|
{
|
|
Vector2D &vDmxData = dmxData[i];
|
|
const FbxVector2 vFbxData = fbxData[i];
|
|
vDmxData.x = vFbxData[0];
|
|
vDmxData.y = vFbxData[1];
|
|
}
|
|
|
|
FieldIndex_t nFieldIndex = -1;
|
|
|
|
if ( nSemanticIndex == 0 )
|
|
{
|
|
nFieldIndex = pDmeVertexData->CreateField( CDmeVertexDataBase::FIELD_TEXCOORD );
|
|
}
|
|
#ifdef SOURCE2
|
|
else if ( nSemanticIndex == 1 )
|
|
{
|
|
nFieldIndex = pDmeVertexData->CreateField( CDmeVertexDataBase::FIELD_TEXCOORD2 );
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
// No FIELD_TEXCOORD3, no method to get the standard field name without the semantic index
|
|
// so magically we know it will be "texcoord$#" where # is the semantic index
|
|
nFieldIndex = pDmeVertexData->CreateField< Vector2D >( CFmtStr( "texcoord$%d", nSemanticIndex ).Get() );
|
|
}
|
|
pDmeVertexData->AddVertexData( nFieldIndex, dmxData.Count() );
|
|
pDmeVertexData->SetVertexData( nFieldIndex, 0, dmxData.Count(), AT_VECTOR2, dmxData.Base() );
|
|
pDmeVertexData->SetVertexIndices( nFieldIndex, 0, nIndices.Count(), nIndices.Base() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void AddNormalData( CDmeVertexData *pDmeVertexData, const CUtlVector< int > &nIndices, const FbxGeometryElementNormal *pFbxElement, const FbxMatrix &mScale )
|
|
{
|
|
if ( !pFbxElement || nIndices.Count() <= 0 )
|
|
return;
|
|
|
|
// Normals being FbxVector4's are a little weird but just using x, y, z is fine.
|
|
// There seems to be breakage when loading an FBX 2014 file in FBX 2013 SDK because they
|
|
// added a NormalsW layer which isn't actually put into the W component but this gets the
|
|
// right x, y, z values regardless if w is just ignored
|
|
|
|
const FbxLayerElementArrayTemplate< FbxVector4 > &fbxData = pFbxElement->GetDirectArray();
|
|
const int nDataCount = fbxData.GetCount();
|
|
|
|
CUtlVector< Vector > dmxData;
|
|
dmxData.SetCount( nDataCount );
|
|
|
|
if ( mScale == FbxMatrix() )
|
|
{
|
|
// If the scale is the identity matrix
|
|
|
|
for ( int i = 0; i < dmxData.Count(); ++i )
|
|
{
|
|
Vector &vDmxData = dmxData[i];
|
|
const FbxVector4 vFbxData = fbxData[i];
|
|
vDmxData.x = vFbxData[0];
|
|
vDmxData.y = vFbxData[1];
|
|
vDmxData.z = vFbxData[2];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const FbxMatrix mInvTranspose = mScale.Inverse().Transpose();
|
|
|
|
for ( int i = 0; i < dmxData.Count(); ++i )
|
|
{
|
|
Vector &vDmxData = dmxData[i];
|
|
FbxVector4 vFbxData = mInvTranspose.MultNormalize( fbxData[i] );
|
|
vFbxData.Normalize();
|
|
vDmxData.x = vFbxData[0];
|
|
vDmxData.y = vFbxData[1];
|
|
vDmxData.z = vFbxData[2];
|
|
}
|
|
}
|
|
|
|
const FieldIndex_t nFieldIndex = pDmeVertexData->CreateField( CDmeVertexDataBase::FIELD_NORMAL );
|
|
pDmeVertexData->AddVertexData( nFieldIndex, dmxData.Count() );
|
|
pDmeVertexData->SetVertexData( nFieldIndex, 0, dmxData.Count(), AT_VECTOR3, dmxData.Base() );
|
|
pDmeVertexData->SetVertexIndices( nFieldIndex, 0, nIndices.Count(), nIndices.Base() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::AddColorData( CDmeVertexData *pDmeVertexData, const CUtlVector< int > &nIndices, const FbxGeometryElementVertexColor *pFbxElement ) const
|
|
{
|
|
if ( !pFbxElement || nIndices.Count() <= 0 )
|
|
return;
|
|
|
|
const FbxLayerElementArrayTemplate< FbxColor > &fbxData = pFbxElement->GetDirectArray();
|
|
const int nDataCount = fbxData.GetCount();
|
|
|
|
if ( nDataCount <= 0 )
|
|
return;
|
|
|
|
const char *pszName = pFbxElement->GetName();
|
|
const char *pszChannelName = pszName;
|
|
|
|
bool bUseChannelName = false;
|
|
DmAttributeType_t dmAttributeType = AT_COLOR;
|
|
|
|
if ( StringHasPrefix( pszName, "export_" ) )
|
|
{
|
|
pszChannelName = StringAfterPrefix( pszName, "export_" );
|
|
if ( V_strlen( pszChannelName ) > 0 )
|
|
{
|
|
bUseChannelName = true;
|
|
|
|
// Currently "foliageanimation" is a special case which gets converted to a Vector3
|
|
if ( !V_stricmp( pszChannelName, "foliageanimation" ) )
|
|
{
|
|
dmAttributeType = AT_VECTOR3;
|
|
pszChannelName = "foliageanimation"; // Make it lowercase for certain
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pszChannelName = pszName;
|
|
}
|
|
}
|
|
|
|
FieldIndex_t nFieldIndex = -1;
|
|
|
|
if ( bUseChannelName )
|
|
{
|
|
nFieldIndex = pDmeVertexData->CreateField( pszChannelName, ValueTypeToArrayType( dmAttributeType ) );
|
|
}
|
|
else
|
|
{
|
|
CFmtStr sFieldName;
|
|
int nSemanticIndex = 0;
|
|
|
|
for ( ;; )
|
|
{
|
|
sFieldName.sprintf( "color$%d", nSemanticIndex );
|
|
FieldIndex_t nTmpField = pDmeVertexData->FindFieldIndex( sFieldName.Get() );
|
|
if ( nTmpField < 0 )
|
|
break;
|
|
|
|
++nSemanticIndex;
|
|
}
|
|
|
|
nFieldIndex = pDmeVertexData->CreateField( sFieldName.Get(), ValueTypeToArrayType( dmAttributeType ) );
|
|
}
|
|
|
|
if ( nFieldIndex < 0 )
|
|
{
|
|
AddConversionError( pDmeVertexData->GetFileId(), CFmtStr( "Couldn't convert color field: %s\n", pszName ).Get() );
|
|
return;
|
|
}
|
|
|
|
if ( dmAttributeType == AT_VECTOR3 )
|
|
{
|
|
CUtlVector< Vector > dmxData;
|
|
dmxData.SetCount( nDataCount );
|
|
|
|
for ( int i = 0; i < dmxData.Count(); ++i )
|
|
{
|
|
Vector &vDmxData = dmxData[i];
|
|
const FbxColor vFbxData = fbxData[i];
|
|
vDmxData[0] = vFbxData[0];
|
|
vDmxData[1] = vFbxData[1];
|
|
vDmxData[2] = vFbxData[2];
|
|
// Alpha gets discarded when converting to Vector3, all FBX color channels are RGBA
|
|
}
|
|
|
|
pDmeVertexData->AddVertexData( nFieldIndex, dmxData.Count() );
|
|
pDmeVertexData->SetVertexData( nFieldIndex, 0, dmxData.Count(), dmAttributeType, dmxData.Base() );
|
|
}
|
|
else
|
|
{
|
|
Assert( dmAttributeType == AT_COLOR );
|
|
|
|
CUtlVector< Color > dmxData;
|
|
dmxData.SetCount( nDataCount );
|
|
|
|
for ( int i = 0; i < dmxData.Count(); ++i )
|
|
{
|
|
Color &vDmxData = dmxData[i];
|
|
const FbxColor vFbxData = fbxData[i];
|
|
vDmxData.SetColor(
|
|
clamp( static_cast< uint8 >( floor( vFbxData[0] * 255.0 ) ), 0, 255 ),
|
|
clamp( static_cast< uint8 >( floor( vFbxData[1] * 255.0 ) ), 0, 255 ),
|
|
clamp( static_cast< uint8 >( floor( vFbxData[2] * 255.0 ) ), 0, 255 ),
|
|
clamp( static_cast< uint8 >( floor( vFbxData[3] * 255.0 ) ), 0, 255 ) );
|
|
}
|
|
|
|
pDmeVertexData->AddVertexData( nFieldIndex, dmxData.Count() );
|
|
pDmeVertexData->SetVertexData( nFieldIndex, 0, dmxData.Count(), dmAttributeType, dmxData.Base() );
|
|
}
|
|
|
|
pDmeVertexData->SetVertexIndices( nFieldIndex, 0, nIndices.Count(), nIndices.Base() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// UV Color data is a special case for 3DSMax
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::AddUVColorData( CDmeVertexData *pDmeVertexData, const UVColorChannelData_t &uvColorData ) const
|
|
{
|
|
// Normally UVColor data is exported as a VECTOR3 data in DMX, set this to true to also export as a color map
|
|
const bool bExportColor = false;
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( uvColorData.m_uvChannelData ); ++i )
|
|
{
|
|
if ( !uvColorData.m_uvChannelData[i].m_pFbxElementUV || uvColorData.m_uvChannelData[i].m_nIndices.IsEmpty() )
|
|
return;
|
|
}
|
|
|
|
CUtlVector< Color > dmxColorData;
|
|
CUtlVector< Vector > dmxData;
|
|
CUtlVector< int > indices;
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( uvColorData.m_uvChannelData ); ++i )
|
|
{
|
|
const CUtlVector< int > &srcIndices = uvColorData.m_uvChannelData[i].m_nIndices;
|
|
|
|
if ( indices.IsEmpty() )
|
|
{
|
|
const int nIndexCount = srcIndices.Count();
|
|
|
|
indices.SetCount( nIndexCount );
|
|
dmxColorData.SetCount( nIndexCount );
|
|
dmxData.SetCount( nIndexCount );
|
|
|
|
for ( int j = 0; j < nIndexCount; ++j )
|
|
{
|
|
indices[j] = j;
|
|
}
|
|
|
|
if ( bExportColor )
|
|
{
|
|
for ( int j = 0; j < nIndexCount; ++j )
|
|
{
|
|
dmxColorData[j] = Color( 0, 0, 0, 255 );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( indices.Count() != srcIndices.Count() )
|
|
{
|
|
Warning( "Warning! Fbx 3DS Max index mismatch for channel \"%s\", got %d expected %d\n", uvColorData.m_uvChannelData[i].m_pFbxElementUV->GetName(), srcIndices.Count(), indices.Count() );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( uvColorData.m_uvChannelData ); ++i )
|
|
{
|
|
const FbxLayerElementArrayTemplate< FbxVector2 > &fbxData = uvColorData.m_uvChannelData[i].m_pFbxElementUV->GetDirectArray();
|
|
const int nDataCount = fbxData.GetCount();
|
|
|
|
if ( nDataCount <= 0 )
|
|
return;
|
|
|
|
const CUtlVector< int > &fbxIndices = uvColorData.m_uvChannelData[i].m_nIndices;
|
|
|
|
for ( int j = 0; j < indices.Count(); ++j )
|
|
{
|
|
const int nDmxDataIndex = indices[j]; Assert( nDmxDataIndex == j );
|
|
const int nFbxDataIndex = fbxIndices[nDmxDataIndex];
|
|
|
|
const FbxVector2 &vFbxData = fbxData[nFbxDataIndex];
|
|
|
|
Vector &vDmxData = dmxData[nDmxDataIndex];
|
|
vDmxData[i] = vFbxData[0]; // Always use value 0
|
|
|
|
if ( bExportColor )
|
|
{
|
|
Color &vDmxColorData = dmxColorData[nDmxDataIndex];
|
|
vDmxColorData[i] = clamp( static_cast< uint8 >( floor( vFbxData[0] * 255.0 ) ), 0, 255 ); // Always use value 0
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
const DmAttributeType_t dmAttributeType = AT_VECTOR3;
|
|
const FieldIndex_t nFieldIndex = pDmeVertexData->CreateField( uvColorData.m_sChannelName.Get(), ValueTypeToArrayType( dmAttributeType ) );
|
|
|
|
pDmeVertexData->AddVertexData( nFieldIndex, dmxData.Count() );
|
|
pDmeVertexData->SetVertexData( nFieldIndex, 0, dmxData.Count(), dmAttributeType, dmxData.Base() );
|
|
pDmeVertexData->SetVertexIndices( nFieldIndex, 0, indices.Count(), indices.Base() );
|
|
|
|
pDmeVertexData->Resolve();
|
|
}
|
|
|
|
if ( bExportColor )
|
|
{
|
|
CFmtStr sFieldName;
|
|
int nSemanticIndex = 0;
|
|
|
|
for ( ;; )
|
|
{
|
|
sFieldName.sprintf( "color$%d", nSemanticIndex );
|
|
FieldIndex_t nTmpField = pDmeVertexData->FindFieldIndex( sFieldName.Get() );
|
|
if ( nTmpField < 0 )
|
|
break;
|
|
|
|
++nSemanticIndex;
|
|
}
|
|
|
|
const DmAttributeType_t dmAttributeType = AT_COLOR;
|
|
const FieldIndex_t nFieldIndex = pDmeVertexData->CreateField( sFieldName.Get(), ValueTypeToArrayType( dmAttributeType ) );
|
|
|
|
pDmeVertexData->AddVertexData( nFieldIndex, dmxColorData.Count() );
|
|
pDmeVertexData->SetVertexData( nFieldIndex, 0, dmxColorData.Count(), dmAttributeType, dmxColorData.Base() );
|
|
pDmeVertexData->SetVertexIndices( nFieldIndex, 0, indices.Count(), indices.Base() );
|
|
|
|
pDmeVertexData->Resolve();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template < FbxLayerElement::EMappingMode M, FbxLayerElement::EReferenceMode R >
|
|
void HandleUV( CUtlVector< int > &uvIndices, FbxMesh *pFbxMesh, FbxGeometryElementUV *peUV, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
// Do Nothing
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleUV< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eDirect >(
|
|
CUtlVector< int > &uvIndices, FbxMesh *pFbxMesh, FbxGeometryElementUV *peUV, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
uvIndices.AddToTail( nControlPointIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleUV< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eIndexToDirect >(
|
|
CUtlVector< int > &uvIndices, FbxMesh *pFbxMesh, FbxGeometryElementUV *peUV, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
const int nUVId = peUV->GetIndexArray().GetAt( nControlPointIndex );
|
|
uvIndices.AddToTail( nUVId );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleUV< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eDirect >(
|
|
CUtlVector< int > &uvIndices, FbxMesh *pFbxMesh, FbxGeometryElementUV *peUV, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
uvIndices.AddToTail( nPolygonVertexIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleUV< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eIndexToDirect >(
|
|
CUtlVector< int > &uvIndices, FbxMesh *pFbxMesh, FbxGeometryElementUV *peUV, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
const int nUVId = peUV->GetIndexArray().GetAt( nPolygonVertexIndex );
|
|
uvIndices.AddToTail( nUVId );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmFbxSerializer::HandleUVFunc_t GetHandleUVFunc( FbxGeometryElementUV *pFbxElementUV )
|
|
{
|
|
if ( pFbxElementUV )
|
|
{
|
|
const FbxLayerElement::EMappingMode nMappingMode = pFbxElementUV->GetMappingMode();
|
|
const FbxLayerElement::EReferenceMode nReferenceMode = pFbxElementUV->GetReferenceMode();
|
|
|
|
if ( nMappingMode == FbxGeometryElement::eByControlPoint && nReferenceMode == FbxGeometryElement::eDirect )
|
|
{
|
|
return HandleUV< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByControlPoint && nReferenceMode == FbxGeometryElement::eIndexToDirect )
|
|
{
|
|
return HandleUV< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eIndexToDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByPolygonVertex && nReferenceMode == FbxGeometryElement::eDirect )
|
|
{
|
|
return HandleUV< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByPolygonVertex && nReferenceMode == FbxGeometryElement::eIndexToDirect )
|
|
{
|
|
return HandleUV < FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eIndexToDirect > ;
|
|
}
|
|
else
|
|
{
|
|
Warning( "Warning! Unsupported FBX UV Mapping/Reference Mode %d/%d\n", nMappingMode, nReferenceMode );
|
|
}
|
|
}
|
|
|
|
return HandleUV< FbxGeometryElement::eNone, FbxGeometryElement::eDirect >;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template < FbxLayerElement::EMappingMode M, FbxLayerElement::EReferenceMode R >
|
|
void HandleNormal(
|
|
CUtlVector< int > &nNormalIndices, FbxMesh *pFbxMesh, FbxGeometryElementNormal *pFbxElementNormal, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
// Do Nothing
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleNormal< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eDirect >(
|
|
CUtlVector< int > &nNormalIndices, FbxMesh *pFbxMesh, FbxGeometryElementNormal *pFbxElementNormal, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
nNormalIndices.AddToTail( nControlPointIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleNormal< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eDirect >(
|
|
CUtlVector< int > &nNormalIndices, FbxMesh *pFbxMesh, FbxGeometryElementNormal *pFbxElementNormal, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
nNormalIndices.AddToTail( nPolygonVertexIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleNormal< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eIndexToDirect >(
|
|
CUtlVector< int > &nNormalIndices, FbxMesh *pFbxMesh, FbxGeometryElementNormal *pFbxElementNormal, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
const int nNormalIndex = pFbxElementNormal->GetIndexArray().GetAt( nPolygonVertexIndex );
|
|
nNormalIndices.AddToTail( nNormalIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
typedef void (*HandleNormalFunc_t)( CUtlVector< int > &, FbxMesh *, FbxGeometryElementNormal *, int, int );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
HandleNormalFunc_t GetHandleNormalFunc( FbxGeometryElementNormal *pFbxElementNormal )
|
|
{
|
|
if ( pFbxElementNormal )
|
|
{
|
|
const FbxLayerElement::EMappingMode nMappingMode = pFbxElementNormal->GetMappingMode();
|
|
const FbxLayerElement::EReferenceMode nReferenceMode = pFbxElementNormal->GetReferenceMode();
|
|
|
|
if ( nMappingMode == FbxGeometryElement::eByControlPoint && nReferenceMode == FbxGeometryElement::eDirect )
|
|
{
|
|
return HandleNormal< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByPolygonVertex && nReferenceMode == FbxGeometryElement::eDirect )
|
|
{
|
|
return HandleNormal< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByPolygonVertex && nReferenceMode == FbxGeometryElement::eIndexToDirect )
|
|
{
|
|
return HandleNormal< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eIndexToDirect >;
|
|
}
|
|
else
|
|
{
|
|
Warning( "Warning! Unsupported FBX Normal Mapping/Reference Mode %d/%d\n", nMappingMode, nReferenceMode );
|
|
}
|
|
}
|
|
|
|
return HandleNormal< FbxGeometryElement::eNone, FbxGeometryElement::eDirect >;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template < FbxLayerElement::EMappingMode M, FbxLayerElement::EReferenceMode R >
|
|
void HandleVertexColor(
|
|
CUtlVector< int > &vertexColorIndices, FbxMesh *pFbxMesh, FbxGeometryElementVertexColor *peVertexColor, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
// Do Nothing
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleVertexColor< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eDirect >(
|
|
CUtlVector< int > &vertexColorIndices, FbxMesh *pFbxMesh, FbxGeometryElementVertexColor *peVertexColor, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
vertexColorIndices.AddToTail( nControlPointIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleVertexColor< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eIndexToDirect >(
|
|
CUtlVector< int > &vertexColorIndices, FbxMesh *pFbxMesh, FbxGeometryElementVertexColor *peVertexColor, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
const int nVertexColorId = peVertexColor->GetIndexArray().GetAt( nControlPointIndex );
|
|
vertexColorIndices.AddToTail( nVertexColorId );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleVertexColor< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eDirect >(
|
|
CUtlVector< int > &vertexColorIndices, FbxMesh *pFbxMesh, FbxGeometryElementVertexColor *peVertexColor, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
vertexColorIndices.AddToTail( nPolygonVertexIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
void HandleVertexColor< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eIndexToDirect >(
|
|
CUtlVector< int > &vertexColorIndices, FbxMesh *pFbxMesh, FbxGeometryElementVertexColor *peVertexColor, int nControlPointIndex, int nPolygonVertexIndex )
|
|
{
|
|
const int nVertexColorId = peVertexColor->GetIndexArray().GetAt( nPolygonVertexIndex );
|
|
vertexColorIndices.AddToTail( nVertexColorId );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
typedef void (*HandleVertexColorFunc_t)( CUtlVector< int > &, FbxMesh *, FbxGeometryElementVertexColor *, int, int );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
HandleVertexColorFunc_t GetHandleVertexColorFunc( FbxGeometryElementVertexColor *pFbxElementVertexColor )
|
|
{
|
|
if ( pFbxElementVertexColor )
|
|
{
|
|
const FbxLayerElement::EMappingMode nMappingMode = pFbxElementVertexColor->GetMappingMode();
|
|
const FbxLayerElement::EReferenceMode nReferenceMode = pFbxElementVertexColor->GetReferenceMode();
|
|
|
|
if ( nMappingMode == FbxGeometryElement::eByControlPoint && nReferenceMode == FbxGeometryElement::eDirect )
|
|
{
|
|
return HandleVertexColor< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByControlPoint && nReferenceMode == FbxGeometryElement::eIndexToDirect )
|
|
{
|
|
return HandleVertexColor< FbxGeometryElement::eByControlPoint, FbxGeometryElement::eIndexToDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByPolygonVertex && nReferenceMode == FbxGeometryElement::eDirect )
|
|
{
|
|
return HandleVertexColor< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eDirect >;
|
|
}
|
|
else if ( nMappingMode == FbxGeometryElement::eByPolygonVertex && nReferenceMode == FbxGeometryElement::eIndexToDirect )
|
|
{
|
|
return HandleVertexColor< FbxGeometryElement::eByPolygonVertex, FbxGeometryElement::eIndexToDirect >;
|
|
}
|
|
else
|
|
{
|
|
Warning( "Warning! Unsupported FBX VertexColor Mapping/Reference Mode %d/%d\n", nMappingMode, nReferenceMode );
|
|
}
|
|
}
|
|
|
|
return HandleVertexColor< FbxGeometryElement::eNone, FbxGeometryElement::eDirect >;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
struct ColorChannelData_t
|
|
{
|
|
public:
|
|
ColorChannelData_t()
|
|
: m_pFbxElementVertexColor( NULL )
|
|
, m_pFunc( NULL )
|
|
{
|
|
}
|
|
|
|
FbxGeometryElementVertexColor *m_pFbxElementVertexColor;
|
|
HandleVertexColorFunc_t m_pFunc;
|
|
CUtlVector< int > m_nIndices;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// This converts an FbxMesh into a DmeMesh where the vertex data indices for
|
|
// the DmeMesh will be full expanded to be per polygon per vertex values
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeMesh *CDmFbxSerializer::FbxShapeToDmeMesh( CDmeDag *pDmeDag, FbxNode *pFbxNode, const FbxMatrix &mScale ) const
|
|
{
|
|
bool bReverse = false;
|
|
|
|
{
|
|
FbxVector4 vTTmp;
|
|
FbxQuaternion qRTmp;
|
|
FbxVector4 vShTmp;
|
|
FbxVector4 vScTmp;
|
|
|
|
double flSign = 1.0; // Sign of the determinant of the scale matrix, if negative, odd number of scales and faces need reversing
|
|
mScale.GetElements( vTTmp, qRTmp, vShTmp, vScTmp, flSign );
|
|
|
|
bReverse = ( flSign < 0.0 );
|
|
}
|
|
|
|
if ( !pDmeDag || !pFbxNode )
|
|
return NULL;
|
|
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
if ( !pFbxNodeAttribute || pFbxNodeAttribute->GetAttributeType() != FbxNodeAttribute::eMesh )
|
|
return NULL;
|
|
|
|
FbxMesh *pFbxMesh = reinterpret_cast< FbxMesh * >( pFbxNodeAttribute );
|
|
if ( !pFbxMesh )
|
|
return NULL;
|
|
|
|
CUtlString sName;
|
|
GetName( sName, pFbxNode );
|
|
|
|
CDmeMesh *pDmeMesh = CreateElement< CDmeMesh >( sName.String(), pDmeDag->GetFileId() );
|
|
if ( !pDmeMesh )
|
|
{
|
|
Warning( "Warning! Couldn't create DmeMesh for FbxMesh \"%s\"\n", pFbxMesh->GetName() );
|
|
return NULL;
|
|
}
|
|
|
|
CUtlVector< int > nPolygonToFaceSetMap;
|
|
FbxMeshToDmeFaceSets( pDmeDag, pDmeMesh, pFbxMesh, nPolygonToFaceSetMap );
|
|
|
|
const int nNormalCount = pFbxMesh->GetElementNormalCount();
|
|
FbxGeometryElementNormal *pFbxElementNormal = nNormalCount > 0 ? pFbxMesh->GetElementNormal( 0 ) : NULL;
|
|
HandleNormalFunc_t pHandleNormalFunc = GetHandleNormalFunc( pFbxElementNormal );
|
|
|
|
CUtlVector< int > nPositionIndices;
|
|
CUtlVector< int > nNormalIndices;
|
|
|
|
CUtlVector< ColorChannelData_t > colorChannelDataList;
|
|
|
|
const int nColorCount = pFbxMesh->GetElementVertexColorCount();
|
|
for ( int nColor = 0; nColor < nColorCount; ++nColor )
|
|
{
|
|
FbxGeometryElementVertexColor *pFbxElementVertexColor = pFbxMesh->GetElementVertexColor( nColor );
|
|
if ( !pFbxElementVertexColor )
|
|
continue;
|
|
|
|
ColorChannelData_t &colorChannelData = colorChannelDataList[colorChannelDataList.AddToTail()];
|
|
colorChannelData.m_pFbxElementVertexColor = pFbxElementVertexColor;
|
|
colorChannelData.m_pFunc = GetHandleVertexColorFunc( pFbxElementVertexColor );
|
|
}
|
|
|
|
|
|
CUtlVector< UVColorChannelData_t > uvColorChannelDataList;
|
|
|
|
int nUVElementCount = pFbxMesh->GetElementUVCount();
|
|
|
|
CUtlVector< UVChannelData_t > uvChannelList;
|
|
|
|
if ( nUVElementCount > 0 )
|
|
{
|
|
CUtlVector< FbxGeometryElementUV * > uvElementList;
|
|
|
|
uvElementList.SetCount( nUVElementCount );
|
|
for ( int nUV = 0; nUV < nUVElementCount; ++nUV )
|
|
{
|
|
uvElementList[nUV] = pFbxMesh->GetElementUV( nUV );
|
|
}
|
|
|
|
if ( nUVElementCount >= 4 )
|
|
{
|
|
// For 3DS Max, there seems to be a bug in how 3DS Max exports extra vertex color information, it's sticking it into UVs
|
|
// See if there are three UV channels:
|
|
// "export_foliageanimation_r",
|
|
// "export_foliageanimation_g",
|
|
// "export_foliageanimation_b"
|
|
|
|
const char *szChannelNames[3] = { "r", "g", "b" };
|
|
FbxGeometryElementUV *pUVs[3] = { NULL, NULL, NULL };
|
|
int nUVFoundCount = 0;
|
|
bool bValid = true;
|
|
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( szChannelNames ) == ARRAYSIZE( pUVs ) );
|
|
|
|
const char *pszPrefix = "export_foliageanimation_";
|
|
const char *pszChannelName = "foliageanimation";
|
|
|
|
for ( int nUV = 0; bValid && nUV < nUVElementCount; ++nUV )
|
|
{
|
|
FbxGeometryElementUV *pUV = pFbxMesh->GetElementUV( nUV );
|
|
const char *pszUVName = pUV->GetName();
|
|
if ( StringHasPrefix( pszUVName, pszPrefix ) )
|
|
{
|
|
const char *pszChannel = StringAfterPrefix( pszUVName, pszPrefix );
|
|
|
|
bool bUVFound = false;
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( szChannelNames ); ++i )
|
|
{
|
|
if ( !V_stricmp( pszChannel, szChannelNames[i] ) )
|
|
{
|
|
bUVFound = true;
|
|
|
|
if ( pUVs[i] == NULL )
|
|
{
|
|
pUVs[i] = pUV;
|
|
++nUVFoundCount;
|
|
}
|
|
else
|
|
{
|
|
Warning( "Warning! Fbx 3DSMax UV encoded VertexPaint channel \"%s\", specified multiple times on mesh \"%s\"\n", pszUVName, pFbxMesh->GetName() );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bValid && !bUVFound )
|
|
{
|
|
Warning( "Warning! Fbx 3DSMax UV encoded VertexPaint channel \"%s\", unexpected, expecting ending of [ r, g or b ], on mesh \"%s\"\n", pszUVName, pFbxMesh->GetName() );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bValid && nUVFoundCount == 3 )
|
|
{
|
|
UVColorChannelData_t &uvEncodedColorChannelData = uvColorChannelDataList[uvColorChannelDataList.AddToTail()];
|
|
|
|
uvEncodedColorChannelData.m_sChannelName = pszChannelName;
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( pUVs ); ++i )
|
|
{
|
|
uvEncodedColorChannelData.m_uvChannelData[i].m_pFbxElementUV = pUVs[i];
|
|
uvEncodedColorChannelData.m_uvChannelData[i].m_pFunc = GetHandleUVFunc( pUVs[i] );
|
|
uvElementList.FindAndRemove( pUVs[i] ); // Remove these funky 3ds max channels from the normal UV channels
|
|
}
|
|
}
|
|
else if ( nUVFoundCount > 0 )
|
|
{
|
|
Warning( "Warning! Fbx 3DSMax UV encoded VertexPaint \"%s\" invalid, expected %llu maps, found %d, on mesh \"%s\"\n", pszPrefix, static_cast< uint64 >( ARRAYSIZE( szChannelNames ) ), nUVFoundCount, pFbxMesh->GetName() );
|
|
}
|
|
}
|
|
|
|
// Add the non-3DsMax UV encoded color channels to the actual UV channel list
|
|
nUVElementCount = uvElementList.Count();
|
|
|
|
for ( int nUV = 0; nUV < nUVElementCount; ++nUV )
|
|
{
|
|
FbxGeometryElementUV *pFbxElementUV = pFbxMesh->GetElementUV( nUV );
|
|
if ( !pFbxElementUV )
|
|
continue;
|
|
|
|
HandleUVFunc_t pHandleUVFunc = GetHandleUVFunc( pFbxElementUV );
|
|
if ( !pHandleUVFunc )
|
|
continue;
|
|
|
|
UVChannelData_t &uvChannelData = uvChannelList[uvChannelList.AddToTail()];
|
|
uvChannelData.m_pFbxElementUV = pFbxElementUV;
|
|
uvChannelData.m_pFunc = pHandleUVFunc;
|
|
}
|
|
|
|
nUVElementCount = uvChannelList.Count();
|
|
}
|
|
|
|
const int nUVColorCount = uvColorChannelDataList.Count();
|
|
|
|
CUtlVector< int > nFaceSetIndices;
|
|
|
|
const int nPolygonCount = pFbxMesh->GetPolygonCount();
|
|
int nPolygonVertexIndex = 0;
|
|
|
|
for ( int nPolygon = 0; nPolygon < nPolygonCount; ++nPolygon )
|
|
{
|
|
const int nFaceSet = nPolygonToFaceSetMap[nPolygon];
|
|
CDmeFaceSet *pDmeFaceSet = pDmeMesh->GetFaceSet( nFaceSet );
|
|
|
|
const int nPolygonVertCount = pFbxMesh->GetPolygonSize( nPolygon );
|
|
nFaceSetIndices.SetCount( nPolygonVertCount + 1 );
|
|
|
|
for ( int nPolygonVert = 0; nPolygonVert < nPolygonVertCount; ++nPolygonVert )
|
|
{
|
|
const int nControlPointIndex = pFbxMesh->GetPolygonVertex( nPolygon, nPolygonVert );
|
|
|
|
nFaceSetIndices[nPolygonVert] = nPositionIndices.Count();
|
|
|
|
nPositionIndices.AddToTail( nControlPointIndex );
|
|
for ( int nUV = 0; nUV < nUVElementCount; ++nUV )
|
|
{
|
|
UVChannelData_t &uvChannelData = uvChannelList[nUV];
|
|
( *( uvChannelData.m_pFunc ) )( uvChannelData.m_nIndices, pFbxMesh, uvChannelData.m_pFbxElementUV, nControlPointIndex, nPolygonVertexIndex );
|
|
}
|
|
( *pHandleNormalFunc )( nNormalIndices, pFbxMesh, pFbxElementNormal, nControlPointIndex, nPolygonVertexIndex );
|
|
|
|
for ( int nColor = 0; nColor < nColorCount; ++nColor )
|
|
{
|
|
ColorChannelData_t &colorChannelData = colorChannelDataList[nColor];
|
|
(*colorChannelData.m_pFunc)( colorChannelData.m_nIndices, pFbxMesh, colorChannelData.m_pFbxElementVertexColor, nControlPointIndex, nPolygonVertexIndex );
|
|
}
|
|
|
|
for ( int nUVColor = 0; nUVColor < nUVColorCount; ++nUVColor )
|
|
{
|
|
UVColorChannelData_t &uvColorChannelData = uvColorChannelDataList[nUVColor];
|
|
for ( int nUVChannel = 0; nUVChannel < ARRAYSIZE( uvColorChannelData.m_uvChannelData ); ++nUVChannel )
|
|
{
|
|
( *( uvColorChannelData.m_uvChannelData[nUVChannel].m_pFunc ) )( uvColorChannelData.m_uvChannelData[nUVChannel].m_nIndices, pFbxMesh, uvColorChannelData.m_uvChannelData[nUVChannel].m_pFbxElementUV, nControlPointIndex, nPolygonVertexIndex );
|
|
}
|
|
}
|
|
|
|
++nPolygonVertexIndex;
|
|
}
|
|
|
|
nFaceSetIndices[nPolygonVertCount] = -1;
|
|
|
|
const int nStartIndex = pDmeFaceSet->NumIndices();
|
|
|
|
pDmeFaceSet->AddIndices( nFaceSetIndices.Count() );
|
|
|
|
if ( bReverse )
|
|
{
|
|
int nCurrentIndex = nStartIndex;
|
|
// Add indices for this face in reverse order, leaving the -1 as the last index (face terminator)
|
|
for ( int nReverseIndex = nFaceSetIndices.Count() - 2; nReverseIndex >= 0; --nReverseIndex )
|
|
{
|
|
pDmeFaceSet->SetIndex( nCurrentIndex, nFaceSetIndices[nReverseIndex] );
|
|
++nCurrentIndex;
|
|
}
|
|
|
|
pDmeFaceSet->SetIndex( nCurrentIndex, nFaceSetIndices.Tail() ); // Add the -1
|
|
}
|
|
else
|
|
{
|
|
pDmeFaceSet->SetIndices( nStartIndex, nFaceSetIndices.Count(), nFaceSetIndices.Base() );
|
|
}
|
|
}
|
|
|
|
CDmeVertexData *pDmeVertexData = pDmeMesh->FindOrCreateBaseState( "bind" );
|
|
pDmeVertexData->FlipVCoordinate( true );
|
|
pDmeMesh->SetBindBaseState( pDmeVertexData );
|
|
pDmeMesh->SetCurrentBaseState( "bind" );
|
|
|
|
if ( !AddPositionData( pDmeVertexData, nPositionIndices, pFbxMesh, mScale ) )
|
|
{
|
|
Warning( "Warning! Couldn't convert FbxMesh \"%s\"\n", pFbxMesh->GetName() );
|
|
g_pDataModel->DestroyElement( pDmeMesh->GetHandle() );
|
|
return NULL;
|
|
}
|
|
|
|
for ( int nUV = 0; nUV < nUVElementCount; ++nUV )
|
|
{
|
|
const UVChannelData_t &uvChannelData = uvChannelList[nUV];
|
|
AddUVData( pDmeVertexData, uvChannelData.m_nIndices, uvChannelData.m_pFbxElementUV, nUV );
|
|
}
|
|
|
|
AddNormalData( pDmeVertexData, nNormalIndices, pFbxElementNormal, mScale );
|
|
|
|
for ( int nColor = 0; nColor < nColorCount; ++nColor )
|
|
{
|
|
ColorChannelData_t &colorChannelData = colorChannelDataList[nColor];
|
|
AddColorData( pDmeVertexData, colorChannelData.m_nIndices, colorChannelData.m_pFbxElementVertexColor );
|
|
}
|
|
|
|
for ( int nUVColor = 0; nUVColor < uvColorChannelDataList.Count(); ++nUVColor )
|
|
{
|
|
UVColorChannelData_t &uvColorChannelData = uvColorChannelDataList[nUVColor];
|
|
AddUVColorData( pDmeVertexData, uvColorChannelData );
|
|
}
|
|
|
|
pDmeDag->SetShape( pDmeMesh );
|
|
|
|
return pDmeMesh;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmFbxSerializer::FbxMeshToDmeFaceSets( CDmeDag *pDmeDag, CDmeMesh *pDmeMesh, FbxMesh *pFbxMesh, CUtlVector< int > &nPolygonToFaceSetMap ) const
|
|
{
|
|
const int nPolygonCount = pFbxMesh->GetPolygonCount();
|
|
const int nMaterialCount = pFbxMesh->GetNode()->GetMaterialCount();
|
|
const int nElementMaterialCount = pFbxMesh->GetElementMaterialCount();
|
|
|
|
FbxGeometryElementMaterial *pMatElement = NULL;
|
|
|
|
if ( nMaterialCount > 0 && nElementMaterialCount > 0 )
|
|
{
|
|
pMatElement = pFbxMesh->GetElementMaterial( 0 );
|
|
}
|
|
|
|
CUtlString sFallbackMaterialPath;
|
|
|
|
#ifdef SOURCE2
|
|
{
|
|
// Generate a fallback material path based on the mesh name, only used if material cannot be located
|
|
char szResourceName[MAX_PATH] = {};
|
|
if ( !FixupResourceName( pDmeMesh->GetName(), RESOURCE_TYPE_MATERIAL, szResourceName, ARRAYSIZE( szResourceName ) ) )
|
|
{
|
|
SetResourceFileNameExtension( pDmeMesh->GetName(), RESOURCE_TYPE_MATERIAL, szResourceName, ARRAYSIZE( szResourceName ) );
|
|
}
|
|
sFallbackMaterialPath = szResourceName;
|
|
}
|
|
#endif
|
|
CUtlString sMaterialPath = sFallbackMaterialPath;
|
|
|
|
// Looking for UserData on a mesh ending in .vmat
|
|
static const char szSuffix[] = "_vmat";
|
|
const int nSuffixCount = ARRAYSIZE( szSuffix ) - 1;
|
|
COMPILE_TIME_ASSERT( nSuffixCount == 5 );
|
|
|
|
typedef FbxMap< FbxString, FbxLayerElementArrayTemplate< void * > * > HoudiniMatDataMap_t; // data to figure out material assignments from houdini
|
|
HoudiniMatDataMap_t houdiniMatData;
|
|
|
|
for ( int i = 0; i < pFbxMesh->GetElementUserDataCount(); ++i )
|
|
{
|
|
FbxGeometryElementUserData *pFbxUserData = pFbxMesh->GetElementUserData( i );;
|
|
|
|
for ( int j = 0; j < pFbxUserData->GetDirectArrayCount(); ++j )
|
|
{
|
|
if ( pFbxUserData->GetDataType( j ).GetType() == eFbxInt )
|
|
{
|
|
const char *pszDataName = pFbxUserData->GetDataName( j );
|
|
FbxString sDataName( pszDataName );
|
|
|
|
// Look if string ends in "_vmat"
|
|
if ( sDataName.FindAndReplace( szSuffix, ".vmat", sDataName.GetLen() - nSuffixCount ) )
|
|
{
|
|
bool bArray = false;
|
|
FbxLayerElementArrayTemplate< void * > *pDirectArrayVoid = pFbxUserData->GetDirectArrayVoid( j, &bArray );
|
|
if ( bArray && nPolygonCount == pDirectArrayVoid->GetCount() )
|
|
{
|
|
houdiniMatData.Insert( sDataName, pDirectArrayVoid );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pMatElement )
|
|
{
|
|
if ( pMatElement->GetMappingMode() == FbxGeometryElement::eByPolygon )
|
|
{
|
|
nPolygonToFaceSetMap.RemoveAll();
|
|
nPolygonToFaceSetMap.EnsureCapacity( nPolygonCount );
|
|
|
|
CUtlVector< FbxString > materialList;
|
|
materialList.SetCount( nMaterialCount );
|
|
|
|
if ( houdiniMatData.Empty() )
|
|
{
|
|
for ( int i = 0; i < nPolygonCount; ++i )
|
|
{
|
|
nPolygonToFaceSetMap.AddToTail( pMatElement->GetIndexArray().GetAt( i ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < nPolygonCount; ++i )
|
|
{
|
|
const int nPolygonMaterialIndex = pMatElement->GetIndexArray().GetAt( i );
|
|
nPolygonToFaceSetMap.AddToTail( nPolygonMaterialIndex );
|
|
|
|
if ( materialList[nPolygonMaterialIndex].IsEmpty() )
|
|
{
|
|
bool bFoundMat = false;
|
|
|
|
for ( HoudiniMatDataMap_t::Iterator hmdIt = houdiniMatData.Begin(); hmdIt != houdiniMatData.End(); ++hmdIt )
|
|
{
|
|
FbxLayerElementArrayTemplate< void * > *pDirectArrayVoid = hmdIt->GetValue();
|
|
int *pDirectArrayInt = NULL;
|
|
|
|
pDirectArrayInt = pDirectArrayVoid->GetLocked( pDirectArrayInt, FbxLayerElementArray::eReadLock );
|
|
if ( pDirectArrayInt[i] != 0 )
|
|
{
|
|
materialList[nPolygonMaterialIndex] = hmdIt->GetKey();
|
|
bFoundMat = true;
|
|
}
|
|
pDirectArrayVoid->Release( reinterpret_cast< void ** >( &pDirectArrayInt ) );
|
|
|
|
if ( bFoundMat )
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < nMaterialCount; ++i )
|
|
{
|
|
CUtlString sByPolygonMaterialPath;
|
|
CUtlVector< CUtlString > materialSearchErrorList;
|
|
|
|
if ( materialList[i].IsEmpty() )
|
|
{
|
|
FbxSurfaceMaterial *pFbxMaterial = pFbxMesh->GetNode()->GetMaterial( i );
|
|
// If there's actually a material, change the fallback to the material name instead of the mesh name
|
|
if ( pFbxMaterial )
|
|
{
|
|
sByPolygonMaterialPath = pFbxMaterial->GetName();
|
|
}
|
|
else
|
|
{
|
|
sByPolygonMaterialPath = sFallbackMaterialPath;
|
|
}
|
|
|
|
if ( !GetFbxMaterialPath( sByPolygonMaterialPath, pFbxMaterial, materialSearchErrorList ) )
|
|
{
|
|
#ifdef SOURCE2
|
|
AddConversionError( pDmeMesh->GetFileId(), CFmtStrMax( "GetFbxMaterialPath Failed! FbxMesh: %s FbxMaterial[%d]: %s, using: %s", pDmeMesh->GetName(), i, pFbxMaterial ? pFbxMaterial->GetName() : "nil", sByPolygonMaterialPath.Get() ).Get() );
|
|
|
|
if ( !materialSearchErrorList.IsEmpty() )
|
|
{
|
|
AddConversionError( pDmeMesh->GetFileId(), " + Searched:" );
|
|
|
|
for ( int e = 0; e < materialSearchErrorList.Count(); ++e )
|
|
{
|
|
AddConversionError( pDmeMesh->GetFileId(), CFmtStr( " + %s", materialSearchErrorList[e].Get() ).Get() );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sByPolygonMaterialPath = materialList[i].Buffer();
|
|
}
|
|
|
|
const CUtlString sByPolygonMaterialName = sByPolygonMaterialPath.GetBaseFilename();
|
|
|
|
CDmeFaceSet *pDmeFaceSet = CreateElement< CDmeFaceSet >( sByPolygonMaterialName.String(), pDmeMesh->GetFileId() );
|
|
CDmeMaterial *pDmeMaterial = CreateElement< CDmeMaterial >( sByPolygonMaterialName.String(), pDmeMesh->GetFileId() );
|
|
pDmeMaterial->SetMaterial( sByPolygonMaterialPath.Get() );
|
|
pDmeFaceSet->SetMaterial( pDmeMaterial );
|
|
pDmeMesh->AddFaceSet( pDmeFaceSet );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if ( pMatElement->GetMappingMode() == FbxGeometryElement::eAllSame )
|
|
{
|
|
CUtlVector< CUtlString > materialSearchErrorList;
|
|
|
|
FbxSurfaceMaterial *pFbxMaterial = pFbxMesh->GetNode()->GetMaterial( 0 );
|
|
if ( pFbxMaterial )
|
|
{
|
|
// If there's actually a material, change the fallback to the material name instead of the mesh name
|
|
sMaterialPath = pFbxMaterial->GetName();
|
|
}
|
|
|
|
if ( !GetFbxMaterialPath( sMaterialPath, pFbxMaterial, materialSearchErrorList ) )
|
|
{
|
|
#ifdef SOURCE2
|
|
AddConversionError( pDmeMesh->GetFileId(), CFmtStrMax( "GetFbxMaterialPath Failed! FbxMesh: %s FbxMaterial: %s, using: %s", pDmeMesh->GetName(), pFbxMaterial ? pFbxMaterial->GetName() : "nil", sMaterialPath.Get() ).Get() );
|
|
|
|
if ( !materialSearchErrorList.IsEmpty() )
|
|
{
|
|
AddConversionError( pDmeMesh->GetFileId(), " + Searched:" );
|
|
|
|
for ( int e = 0; e < materialSearchErrorList.Count(); ++e )
|
|
{
|
|
AddConversionError( pDmeMesh->GetFileId(), CFmtStr( " + %s", materialSearchErrorList[e].Get() ).Get() );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if ( houdiniMatData.GetSize() == 1 )
|
|
{
|
|
sMaterialPath = houdiniMatData.Begin()->GetKey();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddConversionError( pDmeMesh->GetFileId(), CFmtStrMax( "GetFbxMaterialPath Failed! FbxMesh: %s, Unsupported material mapping mode, using: %s", pDmeMesh->GetName(), sMaterialPath.Get() ).Get() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddConversionError( pDmeMesh->GetFileId(), CFmtStrMax( "GetFbxMaterialPath Failed! FbxMesh: %s, No FbxMaterial assigned, using: %s", pDmeMesh->GetName(), sMaterialPath.Get() ).Get() );
|
|
}
|
|
|
|
// Either a single material or no material on the mesh
|
|
static const int nZero = 0;
|
|
|
|
nPolygonToFaceSetMap.SetCount( nPolygonCount );
|
|
nPolygonToFaceSetMap.FillWithValue( nZero );
|
|
|
|
const CUtlString sMaterialName = sMaterialPath.GetBaseFilename();
|
|
|
|
CDmeFaceSet *pDmeFaceSet = CreateElement< CDmeFaceSet >( sMaterialName.String(), pDmeMesh->GetFileId() );
|
|
CDmeMaterial *pDmeMaterial = CreateElement< CDmeMaterial >( sMaterialName.String(), pDmeMesh->GetFileId() );
|
|
pDmeMaterial->SetMaterial( sMaterialPath.String() );
|
|
pDmeFaceSet->SetMaterial( pDmeMaterial );
|
|
pDmeMesh->AddFaceSet( pDmeFaceSet );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Search for a material by name by generating resource names and seeing if
|
|
// the resource exists on disk in content and then game and then on user
|
|
// specified material search paths
|
|
//
|
|
// If a material file cannot be found, the original name is copied and false
|
|
// is returned
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmFbxSerializer::FindMaterialResource( CUtlString &sOutMaterialPath, const char *pszInMaterialName, CUtlVector< CUtlString > &materialSearchErrorList ) const
|
|
{
|
|
#ifdef SOURCE2
|
|
char szResourceName[MAX_PATH] = { 0 };
|
|
char szResourceFullPath[MAX_PATH] = { 0 };
|
|
char szMaterialPath[MAX_PATH] = { 0 };
|
|
|
|
ResourcePathGenerationType_t pSearchPaths[] =
|
|
{
|
|
RESOURCE_PATH_CONTENT,
|
|
RESOURCE_PATH_GAME
|
|
};
|
|
|
|
const char *szSearchPaths[] =
|
|
{
|
|
"CONTENT",
|
|
"GAME"
|
|
};
|
|
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( pSearchPaths ) == ARRAYSIZE( szSearchPaths ) );
|
|
|
|
FixupResourceName( pszInMaterialName, RESOURCE_TYPE_MATERIAL, szResourceName, ARRAYSIZE( szResourceName ) );
|
|
|
|
for ( int s = 0; s < ARRAYSIZE( pSearchPaths ); ++s )
|
|
{
|
|
// Check if current material is valid
|
|
if ( GenerateStandardFullPathForResourceName( szResourceName, pSearchPaths[s], szResourceFullPath, ARRAYSIZE( szResourceFullPath ) ) )
|
|
{
|
|
sOutMaterialPath = szResourceName;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
materialSearchErrorList.AddToTail( CFmtStr( "%-7s %s", szSearchPaths[s], szResourceName ).Get() );
|
|
}
|
|
}
|
|
|
|
// Loop through material search paths and try to find the material
|
|
for ( int s = 0; s < ARRAYSIZE( pSearchPaths ); s++ )
|
|
{
|
|
for ( int i = 0; i < m_sOptMaterialSearchPathList.Count(); ++i )
|
|
{
|
|
V_ComposeFileName( m_sOptMaterialSearchPathList[i].Get(), pszInMaterialName, szMaterialPath, ARRAYSIZE( szMaterialPath ) );
|
|
FixupResourceName( szMaterialPath, RESOURCE_TYPE_MATERIAL, szResourceName, ARRAYSIZE( szResourceName ) );
|
|
|
|
if ( GenerateStandardFullPathForResourceName( szResourceName, pSearchPaths[s], szResourceFullPath, ARRAYSIZE( szResourceFullPath ) ) )
|
|
{
|
|
sOutMaterialPath = szResourceName;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
materialSearchErrorList.AddToTail( CFmtStr( "%-7s %s", szSearchPaths[s], szResourceName ).Get() );
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
#else
|
|
//sOutMaterialPath = CUtlString( pszInMaterialName ).UnqualifiedFilename();
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmFbxSerializer::GetFbxMaterialPathFromFbxFileTexture( CUtlString &sMaterialPath, FbxFileTexture *pFileTexture, CUtlVector< CUtlString > &materialSearchErrorList ) const
|
|
{
|
|
const char *pszFileName = pFileTexture->GetFileName();
|
|
if ( !pszFileName || *pszFileName == '\0' )
|
|
return false;
|
|
|
|
#ifdef SOURCE2
|
|
char szResourceName[ MAX_PATH ];
|
|
GenerateResourceNameFromFileName( pszFileName, RESOURCE_TYPE_MATERIAL, szResourceName, ARRAYSIZE( szResourceName ) );
|
|
#else
|
|
sMaterialPath = CUtlString( pszFileName ).UnqualifiedFilename();
|
|
return true;
|
|
|
|
const char *szResourceName;
|
|
szResourceName = pszFileName;
|
|
#endif
|
|
|
|
if ( FindMaterialResource( sMaterialPath, szResourceName, materialSearchErrorList ) )
|
|
return true;
|
|
|
|
// See if the texture ends in any well known suffixes
|
|
|
|
const char *szSuffixes[] = { "_color." };
|
|
|
|
FbxString sTmpResourceName = szResourceName;
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( szSuffixes ); ++i )
|
|
{
|
|
if ( sTmpResourceName.FindAndReplace( szSuffixes[ i ], "." ) )
|
|
{
|
|
if ( FindMaterialResource( sMaterialPath, sTmpResourceName.Buffer(), materialSearchErrorList ) )
|
|
return true;
|
|
|
|
if ( !V_strcmp( szSuffixes[i], "_color." ) )
|
|
{
|
|
// If we got here, probably just use this one, likely the file wasn't put onto disk yet
|
|
sMaterialPath = sTmpResourceName.Buffer();
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmFbxSerializer::GetFbxMaterialPath( CUtlString &sMaterialPath, FbxSurfaceMaterial *pFbxMat, CUtlVector< CUtlString > &materialSearchErrorList ) const
|
|
{
|
|
if ( !pFbxMat )
|
|
{
|
|
materialSearchErrorList.AddToTail( CFmtStr( "GetFbxMaterialPath Failed: No Fbx material" ).Get() );
|
|
return false;
|
|
}
|
|
|
|
// See if FBX_vmatPath is explicitly set, if it is, then just use it and return
|
|
static const char *szExplitPaths[] = { "vmatPath", "FBX_vmatPath" };
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( szExplitPaths ); ++i )
|
|
{
|
|
const char *pszExplicitPath = szExplitPaths[i];
|
|
|
|
FbxProperty fbx_vmatPath = pFbxMat->FindProperty( pszExplicitPath );
|
|
if ( fbx_vmatPath.IsValid() )
|
|
{
|
|
const EFbxType eFbxType = fbx_vmatPath.GetPropertyDataType().GetType();
|
|
if ( eFbxType == eFbxString )
|
|
{
|
|
const FbxString sVMatPath = fbx_vmatPath.Get< FbxString >();
|
|
if ( !sVMatPath.IsEmpty() )
|
|
{
|
|
sMaterialPath = sVMatPath.Buffer();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
materialSearchErrorList.AddToTail( CFmtStr( "FBXSurfaceMaterial( %s ).FBX_vmatPath found but empty", pFbxMat->GetName() ).Get() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
materialSearchErrorList.AddToTail( CFmtStr( "FBXSurfaceMaterial( %s ).FBX_vmatPath found but not a string attribute", pFbxMat->GetName() ).Get() );
|
|
}
|
|
}
|
|
}
|
|
|
|
// See if the name of the material maps directly to a material file
|
|
if ( FindMaterialResource( sMaterialPath, pFbxMat->GetNameOnly(), materialSearchErrorList ) )
|
|
return true;
|
|
|
|
// Look to see if a texture can map to a .vmat
|
|
FbxProperty fbxProperty = pFbxMat->FindProperty( FbxSurfaceMaterial::sDiffuse );
|
|
|
|
const int nLayeredTextureCount = fbxProperty.GetSrcObjectCount( FbxLayeredTexture::ClassId );
|
|
if ( nLayeredTextureCount > 0 )
|
|
{
|
|
for ( int j = 0; j < nLayeredTextureCount; ++j )
|
|
{
|
|
FbxLayeredTexture *pLayeredTexture = FbxCast< FbxLayeredTexture >( fbxProperty.GetSrcObject( FbxLayeredTexture::ClassId, j ) );
|
|
const int nTexCount = pLayeredTexture->GetSrcObjectCount( FbxTexture::ClassId );
|
|
|
|
for ( int k = 0; k < nTexCount; ++k )
|
|
{
|
|
FbxFileTexture *pFileTexture = FbxCast< FbxFileTexture >( pLayeredTexture->GetSrcObject( FbxTexture::ClassId, k ) );
|
|
|
|
if ( pFileTexture )
|
|
{
|
|
if ( GetFbxMaterialPathFromFbxFileTexture( sMaterialPath, pFileTexture, materialSearchErrorList ) )
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//no layered texture simply get on the property
|
|
const int nTexCount = fbxProperty.GetSrcObjectCount( FbxTexture::ClassId );
|
|
|
|
if ( nTexCount > 0 )
|
|
{
|
|
for ( int j = 0; j < nTexCount; ++j )
|
|
{
|
|
FbxFileTexture *pFileTexture = FbxCast< FbxFileTexture >( fbxProperty.GetSrcObject( FbxTexture::ClassId, j ) );
|
|
|
|
if ( pFileTexture )
|
|
{
|
|
if ( GetFbxMaterialPathFromFbxFileTexture( sMaterialPath, pFileTexture, materialSearchErrorList ) )
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::SkinMeshes_R(
|
|
const FbxToDmxMap_t &fbxToDmxMap, CDmeModel *pDmeModel, FbxNode *pFbxNode ) const
|
|
{
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
|
|
if ( pFbxNodeAttribute )
|
|
{
|
|
const FbxNodeAttribute::EType nAttributeType = pFbxNodeAttribute->GetAttributeType();
|
|
if ( nAttributeType == FbxNodeAttribute::eMesh )
|
|
{
|
|
FbxToDmxMap_t::IndexType_t nDmxIndex = fbxToDmxMap.Find( pFbxNode );
|
|
if ( fbxToDmxMap.IsValidIndex( nDmxIndex ) )
|
|
{
|
|
SkinMesh( fbxToDmxMap.Element( nDmxIndex ), fbxToDmxMap, pDmeModel, pFbxNode );
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < pFbxNode->GetChildCount(); ++i )
|
|
{
|
|
SkinMeshes_R( fbxToDmxMap, pDmeModel, pFbxNode->GetChild( i ) );
|
|
}
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
class CVertexSkin
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
kMaxWeights = 3
|
|
};
|
|
|
|
enum SkinError_t
|
|
{
|
|
kSkinErrorNone = 0,
|
|
kSkinErrorTooManyWeights,
|
|
kSkinErrorZeroWeight,
|
|
kSkinErrorNegativeWeight
|
|
};
|
|
|
|
bool AddWeight( int nJointIndex, float flJointWeight )
|
|
{
|
|
// Ignore 0 weights
|
|
if ( flJointWeight < m_flEps )
|
|
return false;
|
|
|
|
IndexWeightPair_t &indexWeightPair = m_weights[ m_weights.AddToTail() ];
|
|
indexWeightPair.m_nIndex = nJointIndex;
|
|
indexWeightPair.m_flWeight = flJointWeight;
|
|
|
|
return true;
|
|
}
|
|
|
|
int GetIndex( int nIndex ) const
|
|
{
|
|
if ( nIndex >= kMaxWeights || nIndex >= m_weights.Count() )
|
|
return -1;
|
|
|
|
return m_weights[nIndex].m_nIndex;
|
|
}
|
|
|
|
float GetWeight( int nIndex ) const
|
|
{
|
|
if ( nIndex >= kMaxWeights || nIndex >= m_weights.Count() )
|
|
return 0.0f;
|
|
|
|
return m_weights[nIndex].m_flWeight;
|
|
}
|
|
|
|
SkinError_t Renormalize();
|
|
|
|
protected:
|
|
static int VertexWeightLessFunc( const void *pLhs, const void *pRhs );
|
|
static const float m_flEps;
|
|
|
|
struct IndexWeightPair_t
|
|
{
|
|
int m_nIndex;
|
|
float m_flWeight;
|
|
};
|
|
|
|
CUtlVector< IndexWeightPair_t > m_weights;
|
|
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
const float CVertexSkin::m_flEps = 1.0e-4;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used by HandleVertexWeights, sorts vertex weights by weight
|
|
//-----------------------------------------------------------------------------
|
|
int CVertexSkin::VertexWeightLessFunc( const void *pLhs, const void *pRhs )
|
|
{
|
|
const IndexWeightPair_t *pVertexWeightL = reinterpret_cast< const IndexWeightPair_t * >( pLhs );
|
|
const IndexWeightPair_t *pVertexWeightR = reinterpret_cast< const IndexWeightPair_t * >( pRhs );
|
|
|
|
if ( pVertexWeightL->m_nIndex < 0 )
|
|
{
|
|
if ( pVertexWeightR->m_nIndex < 0 )
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
else if ( pVertexWeightR->m_nIndex < 0 )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ( pVertexWeightL->m_flWeight > pVertexWeightR->m_flWeight )
|
|
{
|
|
return -1;
|
|
}
|
|
else if ( pVertexWeightL->m_flWeight < pVertexWeightR->m_flWeight )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Returns: kSkinErrorNone if all ok
|
|
// kSkinErrorTooManyWeights if more than kMaxWeights
|
|
// kSkinErrorZeroWeight if total weight is 0 for this vertex
|
|
// kSkinErrorNegativeWeight if total weight is < 0 for this vertex
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CVertexSkin::SkinError_t CVertexSkin::Renormalize()
|
|
{
|
|
SkinError_t nErr = kSkinErrorNone;
|
|
|
|
// Sort by weight, largest weights first
|
|
qsort( m_weights.Base(), m_weights.Count(), sizeof( IndexWeightPair_t ), VertexWeightLessFunc );
|
|
|
|
// Remove any weights > kMaxWeights
|
|
if ( m_weights.Count() > kMaxWeights )
|
|
{
|
|
m_weights.RemoveMultipleFromTail( m_weights.Count() - kMaxWeights );
|
|
nErr = kSkinErrorTooManyWeights;
|
|
}
|
|
|
|
float flTotalWeight = 0.0f;
|
|
for ( int i = 0; i < m_weights.Count(); ++i )
|
|
{
|
|
flTotalWeight += m_weights[i].m_flWeight;
|
|
}
|
|
|
|
if ( fabs( flTotalWeight ) < m_flEps )
|
|
{
|
|
nErr = kSkinErrorZeroWeight;
|
|
}
|
|
else
|
|
{
|
|
if ( flTotalWeight < 0.0f )
|
|
{
|
|
nErr = kSkinErrorNegativeWeight;
|
|
}
|
|
|
|
if ( fabs( fabs( flTotalWeight ) - 1.0f ) > m_flEps )
|
|
{
|
|
for ( int i = 0; i < m_weights.Count(); ++i )
|
|
{
|
|
m_weights[i].m_flWeight /= flTotalWeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nErr;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::SkinMesh( CDmeDag *pDmeDag, const FbxToDmxMap_t &fbxToDmxMap, CDmeModel *pDmeModel, FbxNode *pFbxNode ) const
|
|
{
|
|
static const char *szClusterModes[] = { "Normalize", "Additive", "Total1" };
|
|
|
|
if ( !pDmeDag )
|
|
return;
|
|
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
if ( !pFbxNodeAttribute || pFbxNodeAttribute->GetAttributeType() != FbxNodeAttribute::eMesh )
|
|
return;
|
|
|
|
FbxMesh *pFbxMesh = reinterpret_cast< FbxMesh * >( pFbxNodeAttribute );
|
|
if ( !pFbxMesh )
|
|
return;
|
|
|
|
CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( pDmeDag->GetShape() );
|
|
if ( !pDmeMesh )
|
|
return;
|
|
|
|
CDmeVertexData *pDmeVertexData = pDmeMesh->GetBindBaseState();
|
|
if ( !pDmeVertexData )
|
|
{
|
|
Warning( "Warning! No DmeVertexData on DmeMesh (%s)\n", pDmeMesh->GetName() );
|
|
return;
|
|
}
|
|
|
|
const int nPositionCount = pDmeVertexData->GetPositionData().Count();
|
|
if ( nPositionCount <= 0 )
|
|
{
|
|
Warning( "Warning! Invalid position count (%d) on DmeMesh (%s)\n", nPositionCount, pDmeMesh->GetName() );
|
|
return;
|
|
}
|
|
|
|
const int nDeformerCount = pFbxMesh->GetDeformerCount( FbxDeformer::eSkin );
|
|
if ( nDeformerCount <= 0 )
|
|
return;
|
|
|
|
if ( Verbose2() )
|
|
{
|
|
Msg( " * Skinning Mesh: %s\n", pDmeDag->GetName() );
|
|
}
|
|
|
|
int nJointCount = 0;
|
|
|
|
CUtlVector< CVertexSkin > vertexSkinWeights;
|
|
vertexSkinWeights.SetCount( nPositionCount );
|
|
|
|
CDmElement *pDmRoot = pDmeModel->GetValueElement< CDmElement >( "__rootElement" );
|
|
|
|
for ( int i = 0; i < nDeformerCount; ++i )
|
|
{
|
|
FbxSkin *pFbxSkin = FbxCast< FbxSkin >( pFbxMesh->GetDeformer( i, FbxDeformer::eSkin ) );
|
|
if ( !pFbxSkin )
|
|
continue;
|
|
|
|
const int nClusterCount = pFbxSkin->GetClusterCount();
|
|
for ( int j = 0; j < nClusterCount; ++j )
|
|
{
|
|
FbxCluster *pFbxCluster = pFbxSkin->GetCluster( j );
|
|
FbxNode *pFbxLinkNode = pFbxCluster->GetLink();
|
|
|
|
if ( !pFbxLinkNode )
|
|
continue;
|
|
|
|
const FbxToDmxMap_t::IndexType_t nDmxIndex = fbxToDmxMap.Find( pFbxLinkNode );
|
|
if ( !fbxToDmxMap.IsValidIndex( nDmxIndex ) )
|
|
{
|
|
Warning( "Warning! FBX mesh (%s) skinned to unmapped node (%s)\n", pFbxNode->GetName(), pFbxLinkNode->GetName() );
|
|
continue;
|
|
}
|
|
|
|
CDmeJoint *pDmeJoint = CastElement< CDmeJoint >( fbxToDmxMap.Element( nDmxIndex ) );
|
|
if ( !pDmeJoint )
|
|
{
|
|
Warning( "Warning! FBX mesh (%s) skinned to non-joint (%s)\n", pFbxNode->GetName(), pFbxLinkNode->GetName() );
|
|
continue;
|
|
}
|
|
|
|
const int nJointIndex = pDmeModel->GetJointIndex( pDmeJoint );
|
|
if ( nJointIndex < 0 )
|
|
{
|
|
Warning( "Warning! FBX mesh (%s) skinned to joint (%s) which isn't in DmeModel\n", pFbxNode->GetName(), pDmeJoint->GetName() );
|
|
continue;
|
|
}
|
|
|
|
const FbxCluster::ELinkMode nLinkMode = pFbxCluster->GetLinkMode();
|
|
if ( nLinkMode != FbxCluster::eNormalize && nLinkMode != FbxCluster::eTotalOne )
|
|
{
|
|
Warning( "Warning! FBX mesh (%s) skinned to joint (%s) but mode %s isn't supported, only %s & %s\n", pFbxNode->GetName(), pDmeJoint->GetName(), szClusterModes[nLinkMode], szClusterModes[FbxCluster::eNormalize], szClusterModes[FbxCluster::eTotalOne] );
|
|
continue;
|
|
}
|
|
|
|
const int nIndexCount = pFbxCluster->GetControlPointIndicesCount();
|
|
const int *pnIndices = pFbxCluster->GetControlPointIndices();
|
|
const double *pfWeights = pFbxCluster->GetControlPointWeights();
|
|
|
|
if ( nIndexCount > 0 )
|
|
{
|
|
++nJointCount;
|
|
|
|
if ( Verbose2() )
|
|
{
|
|
Msg( " + DmeJoint[%3d] %5d Vertices - %s\n",
|
|
nJointIndex, nIndexCount, pDmeJoint->GetName() );
|
|
}
|
|
}
|
|
|
|
for ( int k = 0; k < nIndexCount; ++k )
|
|
{
|
|
const int nVertexIndex = pnIndices[k];
|
|
Assert( nVertexIndex >= 0 && nVertexIndex <= vertexSkinWeights.Count() );
|
|
CVertexSkin &vertexSkinWeight = vertexSkinWeights[ nVertexIndex ];
|
|
vertexSkinWeight.AddWeight( nJointIndex, pfWeights[k] );
|
|
}
|
|
}
|
|
|
|
CUtlVector< CVertexSkin::SkinError_t > errorsAdded;
|
|
|
|
// Clean up skin weights
|
|
for ( int j = 0; j < vertexSkinWeights.Count(); ++j )
|
|
{
|
|
const CVertexSkin::SkinError_t nErr = vertexSkinWeights[j].Renormalize();
|
|
|
|
if ( nErr == CVertexSkin::kSkinErrorNone )
|
|
continue;
|
|
|
|
// Do a linear search, maximum of 3 elements and exit early if this error is already added, AddConversionError does a string compare to an array
|
|
if ( errorsAdded.HasElement( nErr ) )
|
|
continue;
|
|
|
|
errorsAdded.AddToTail( nErr );
|
|
|
|
switch ( nErr )
|
|
{
|
|
case CVertexSkin::kSkinErrorTooManyWeights:
|
|
AddConversionError( pDmRoot->GetFileId(), CFmtStr( "Too many skin weights on some vertices, maximum is %d weights per vertex, will renormalize and discard smallest weights", CVertexSkin::kMaxWeights ).Access() );
|
|
break;
|
|
case CVertexSkin::kSkinErrorZeroWeight:
|
|
AddConversionError( pDmRoot->GetFileId(), "Zero skin weights on one or more vertices" );
|
|
break;
|
|
case CVertexSkin::kSkinErrorNegativeWeight:
|
|
AddConversionError( pDmRoot->GetFileId(), "Negative total skin weights on one or more vertices" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
CUtlVector< int > jointIndices;
|
|
jointIndices.EnsureCapacity( CVertexSkin::kMaxWeights * nPositionCount );
|
|
|
|
CUtlVector< float > jointWeights;
|
|
jointWeights.EnsureCapacity( CVertexSkin::kMaxWeights * nPositionCount );
|
|
|
|
for ( int j = 0; j < vertexSkinWeights.Count(); ++j )
|
|
{
|
|
const CVertexSkin &vertexSkinWeight = vertexSkinWeights[ j ];
|
|
|
|
for ( int k = 0; k < CVertexSkin::kMaxWeights; ++k )
|
|
{
|
|
jointIndices.AddToTail( vertexSkinWeight.GetIndex( k ) );
|
|
jointWeights.AddToTail( vertexSkinWeight.GetWeight( k ) );
|
|
}
|
|
}
|
|
|
|
FieldIndex_t nJointWeightsIndex;
|
|
FieldIndex_t nJointIndicesIndex;
|
|
|
|
pDmeVertexData->CreateJointWeightsAndIndices( CVertexSkin::kMaxWeights, &nJointWeightsIndex, &nJointIndicesIndex );
|
|
Assert( jointIndices.Count() == CVertexSkin::kMaxWeights * nPositionCount );
|
|
Assert( jointWeights.Count() == CVertexSkin::kMaxWeights * nPositionCount );
|
|
|
|
pDmeVertexData->AddVertexData( nJointIndicesIndex, jointIndices.Count() );
|
|
pDmeVertexData->SetVertexData( nJointIndicesIndex, 0, jointIndices.Count(), AT_INT, jointIndices.Base() );
|
|
|
|
pDmeVertexData->AddVertexData( nJointWeightsIndex, jointWeights.Count() );
|
|
pDmeVertexData->SetVertexData( nJointWeightsIndex, 0, jointWeights.Count(), AT_FLOAT, jointWeights.Base() );
|
|
|
|
break; // Only do the first skin deformer
|
|
}
|
|
|
|
if ( Verbose1() && !Verbose2() && nJointCount )
|
|
{
|
|
Msg( " * Skinning Mesh Joints %3d: %s\n", nJointCount, pDmeDag->GetName() );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::AddBlendShapes_R( const FbxToDmxMap_t &fbxToDmxMap, CDmElement *pDmeRoot, FbxNode *pFbxNode ) const
|
|
{
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
|
|
if ( pFbxNodeAttribute )
|
|
{
|
|
const FbxNodeAttribute::EType nAttributeType = pFbxNodeAttribute->GetAttributeType();
|
|
if ( nAttributeType == FbxNodeAttribute::eMesh )
|
|
{
|
|
FbxToDmxMap_t::IndexType_t nDmxIndex = fbxToDmxMap.Find( pFbxNode );
|
|
if ( fbxToDmxMap.IsValidIndex( nDmxIndex ) )
|
|
{
|
|
AddBlendShape( fbxToDmxMap.Element( nDmxIndex ), fbxToDmxMap, pDmeRoot, pFbxNode );
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < pFbxNode->GetChildCount(); ++i )
|
|
{
|
|
AddBlendShapes_R( fbxToDmxMap, pDmeRoot, pFbxNode->GetChild( i ) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::AddBlendShape( CDmeDag *pDmeDag, const FbxToDmxMap_t &fbxToDmxMap, CDmElement *pDmeRoot, FbxNode *pFbxNode ) const
|
|
{
|
|
if ( !pDmeDag )
|
|
return;
|
|
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
if ( !pFbxNodeAttribute || pFbxNodeAttribute->GetAttributeType() != FbxNodeAttribute::eMesh )
|
|
return;
|
|
|
|
FbxMesh *pFbxMesh = reinterpret_cast< FbxMesh * >( pFbxNodeAttribute );
|
|
if ( !pFbxMesh )
|
|
return;
|
|
|
|
CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( pDmeDag->GetShape() );
|
|
if ( !pDmeMesh )
|
|
return;
|
|
|
|
CDmeVertexData *pDmeVertexData = pDmeMesh->GetBindBaseState();
|
|
if ( !pDmeVertexData )
|
|
{
|
|
Warning( "Warning! No DmeVertexData on DmeMesh (%s)\n", pDmeMesh->GetName() );
|
|
return;
|
|
}
|
|
|
|
const CUtlVector< Vector > &positionData = pDmeVertexData->GetPositionData();
|
|
const int nPositionCount = positionData.Count();
|
|
if ( nPositionCount <= 0 )
|
|
{
|
|
Warning( "Warning! Invalid position count (%d) on DmeMesh (%s)\n", nPositionCount, pDmeMesh->GetName() );
|
|
return;
|
|
}
|
|
|
|
const int nBlendShapeCount = pFbxMesh->GetDeformerCount( FbxDeformer::eBlendShape );
|
|
if ( nBlendShapeCount <= 0 )
|
|
return;
|
|
|
|
|
|
CUtlVector< Vector > vDeltas;
|
|
CUtlVector< int > nDeltaIndices;
|
|
|
|
CDmeCombinationOperator *pDmeComboOp = FindOrCreateComboOp( pDmeRoot );
|
|
if ( !pDmeComboOp )
|
|
{
|
|
Warning( "Warning! Couldn't create DmeComboOp for FbxMesh %s\n", pFbxNode->GetName() );
|
|
return;
|
|
}
|
|
|
|
for ( int nBlendShapeIndex = 0; nBlendShapeIndex < nBlendShapeCount; ++nBlendShapeIndex )
|
|
{
|
|
FbxBlendShape *pFbxBlendShape = FbxCast< FbxBlendShape >( pFbxMesh->GetDeformer(nBlendShapeIndex, FbxDeformer::eBlendShape) );
|
|
const int nBlendShapeChannelCount = pFbxBlendShape->GetBlendShapeChannelCount();
|
|
|
|
if ( Verbose1() )
|
|
{
|
|
if ( nBlendShapeCount > 1 )
|
|
{
|
|
Msg( " * BlendShape Mesh: Shapes %3d - BlendShape %3d/%3d - %s\n",
|
|
nBlendShapeChannelCount, nBlendShapeIndex + 1, nBlendShapeCount, pDmeMesh->GetName() );
|
|
}
|
|
else
|
|
{
|
|
Msg( " * BlendShape Mesh: Shapes %3d - %s\n",
|
|
nBlendShapeChannelCount, pDmeMesh->GetName() );
|
|
}
|
|
}
|
|
|
|
for ( int nBlendShapeChannelIndex = 0; nBlendShapeChannelIndex < nBlendShapeChannelCount; ++nBlendShapeChannelIndex )
|
|
{
|
|
FbxBlendShapeChannel *pFbxBlendShapeChannel = pFbxBlendShape->GetBlendShapeChannel( nBlendShapeChannelIndex );
|
|
const char *pszDeltaName = pFbxBlendShapeChannel->GetName();
|
|
const char *pszExt = V_GetFileExtension( pszDeltaName ); // FBX will probably name this blendShape.<THING> we just want <THING>
|
|
if ( pszExt )
|
|
{
|
|
pszDeltaName = pszExt;
|
|
}
|
|
|
|
CUtlString sDeltaName;
|
|
CleanupName( sDeltaName, pszDeltaName );
|
|
|
|
const int nTargetShapeCount = pFbxBlendShapeChannel->GetTargetShapeCount();
|
|
|
|
for ( int nTargetShapeIndex = 0; nTargetShapeIndex < nTargetShapeCount; ++nTargetShapeIndex )
|
|
{
|
|
FbxShape *pFbxShape = pFbxBlendShapeChannel->GetTargetShape( nTargetShapeIndex );
|
|
|
|
const int nControlPointsCount = pFbxShape->GetControlPointsCount();
|
|
const FbxVector4 *pvControlPoints = pFbxShape->GetControlPoints();
|
|
|
|
const int nControlPointIndicesCount = pFbxShape->GetControlPointIndicesCount();
|
|
const int *pnControlPointIndices = pFbxShape->GetControlPointIndices();
|
|
|
|
// pvControlPoints has as many values as the original mesh but only the vertices indexed by pnControlPointIndices are deltas
|
|
Assert( nControlPointsCount == nPositionCount );
|
|
|
|
if ( nControlPointsCount == nPositionCount )
|
|
{
|
|
vDeltas.SetCount( nControlPointIndicesCount );
|
|
nDeltaIndices.SetCount( nControlPointIndicesCount );
|
|
|
|
for ( int i = 0; i < nControlPointIndicesCount; ++i )
|
|
{
|
|
const int nDeltaIndex = pnControlPointIndices[i];
|
|
|
|
const Vector &vDme = positionData[ nDeltaIndex ];
|
|
const FbxVector4 &vFbxSrc = pvControlPoints[ nDeltaIndex ];
|
|
vDeltas[i] = Vector( vFbxSrc[0] - vDme.x, vFbxSrc[1] - vDme.y, vFbxSrc[2] - vDme.z );
|
|
nDeltaIndices[i] = nDeltaIndex;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Warning( "Warning! FbxMesh %s Has Unhandled FbxBlendShapeChannel %s\n", pFbxNode->GetName(), pszDeltaName );
|
|
}
|
|
|
|
CDmeVertexDeltaData *pDmeVertexDeltaData = pDmeMesh->FindOrCreateDeltaState( pszDeltaName, m_bOptUnderscoreForCorrectors );
|
|
pszDeltaName = pDmeVertexDeltaData->GetName(); // The delta name could be changed if m_bOptUnderscoreForCorrectors is on, i.e. B_A becomes A_B
|
|
pDmeVertexDeltaData->FlipVCoordinate( true );
|
|
|
|
FieldIndex_t nDeltaPosIndex = pDmeVertexDeltaData->CreateField( CDmeVertexDeltaData::FIELD_POSITION );
|
|
pDmeVertexDeltaData->AddVertexData( nDeltaPosIndex, vDeltas.Count() );
|
|
|
|
pDmeVertexDeltaData->SetVertexData( nDeltaPosIndex, 0, vDeltas.Count(), AT_VECTOR3, vDeltas.Base() );
|
|
pDmeVertexDeltaData->SetVertexIndices( nDeltaPosIndex, 0, nDeltaIndices.Count(), nDeltaIndices.Base() );
|
|
|
|
if ( FindOrCreateControl( pDmeComboOp, pszDeltaName ) )
|
|
{
|
|
pDmeVertexDeltaData->SetValue( "corrected", true );
|
|
}
|
|
|
|
// TODO: See if FBX handle exporting expressions? Face rules?
|
|
// TODO: Handle normals
|
|
|
|
if ( Verbose2() )
|
|
{
|
|
Msg( " + Shape %3d Deltas: %5d - %s\n",
|
|
nBlendShapeChannelIndex, nControlPointIndicesCount, sDeltaName.String() );
|
|
}
|
|
|
|
AssertMsg( nTargetShapeCount == 1, "TODO: Handle multiple target shapes?" );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pDmeComboOp->AddTarget( pDmeMesh );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeCombinationOperator * CDmFbxSerializer::FindOrCreateComboOp( CDmElement *pDmeRoot ) const
|
|
{
|
|
CDmeCombinationOperator *pDmeComboOp = pDmeRoot->GetValueElement< CDmeCombinationOperator >( "combinationOperator" );
|
|
|
|
if ( !pDmeComboOp )
|
|
{
|
|
pDmeComboOp = CreateElement< CDmeCombinationOperator >( "combinationOperator", pDmeRoot->GetFileId() );
|
|
pDmeRoot->SetValue( "combinationOperator", pDmeComboOp );
|
|
}
|
|
|
|
return pDmeComboOp;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmFbxSerializer::FindOrCreateControl( CDmeCombinationOperator *pDmeComboOp, const char *pszName ) const
|
|
{
|
|
if ( m_bOptUnderscoreForCorrectors )
|
|
{
|
|
if ( strchr( pszName, '_' ) ) // Don't create a control if m_bOptUnderscoreForCorrectors is true and name has '_' in it
|
|
return false;
|
|
}
|
|
|
|
const ControlIndex_t nControlIndex = pDmeComboOp->FindOrCreateControl( pszName, false, true );
|
|
|
|
return nControlIndex >= 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CUtlString CleanupName( const char *pszName )
|
|
{
|
|
CUtlString sCleanName( pszName );
|
|
|
|
const int nNameLen = V_strlen( pszName );
|
|
if ( nNameLen > 1 )
|
|
{
|
|
const char *pszColon = V_strrchr( pszName, ':' );
|
|
if ( pszColon && nNameLen > ( pszColon - pszName + 1 ) && *( pszColon + 1 ) )
|
|
{
|
|
sCleanName.Set( pszColon + 1 );
|
|
}
|
|
}
|
|
|
|
return sCleanName;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CUtlString GetName( const FbxNode *pFbxNode )
|
|
{
|
|
const FbxString sName = pFbxNode->GetNameOnly();
|
|
const char *pszName = sName.Buffer();
|
|
|
|
return CleanupName( pszName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::GetName( CUtlString &sCleanName, const FbxNode *pFbxNode ) const
|
|
{
|
|
FbxString sName = pFbxNode->GetNameOnly();
|
|
const char *pszName = sName.Buffer();
|
|
|
|
sCleanName = ::CleanupName( pszName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::CleanupName( CUtlString &sCleanName, const char *pszName ) const
|
|
{
|
|
sCleanName = ::CleanupName( pszName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
struct FbxDmxAnimData_t
|
|
{
|
|
FbxDmxAnimData_t()
|
|
: m_pFbxNode( nullptr )
|
|
, m_pDmePosLog( nullptr )
|
|
, m_pDmeRotLog( nullptr )
|
|
, m_pParent( nullptr )
|
|
, m_pFbxAnimCurve( nullptr )
|
|
, m_pDmeFloatLog( nullptr )
|
|
, m_flMin( 0.0f )
|
|
, m_flMax( 1.0f )
|
|
, m_bNormalize( false )
|
|
{
|
|
SetIdentityMatrix( m_mWorldInverse );
|
|
}
|
|
|
|
void SetWorldMatrix( const matrix3x4_t &mWorld )
|
|
{
|
|
MatrixInvert( mWorld, m_mWorldInverse );
|
|
}
|
|
|
|
FbxNode *m_pFbxNode;
|
|
CDmeVector3Log *m_pDmePosLog;
|
|
CDmeQuaternionLog *m_pDmeRotLog;
|
|
|
|
FbxDmxAnimData_t *m_pParent;
|
|
matrix3x4_t m_mWorldInverse;
|
|
|
|
FbxProperty m_fbxProperty;
|
|
FbxAnimCurve *m_pFbxAnimCurve;
|
|
CDmeFloatLog *m_pDmeFloatLog;
|
|
|
|
bool m_bNormalize;
|
|
float m_flMin;
|
|
float m_flMax;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static CDmeFloatLog *CreateMorphChannel( const char *pszChannelName, CDmeChannelsClip *pDmeChannelsClip )
|
|
{
|
|
CDmeChannel *pDmeFloatChannel = CreateElement< CDmeChannel >( CFmtStr( "%s_flex_channel", pszChannelName ).Access(), pDmeChannelsClip->GetFileId() );
|
|
pDmeFloatChannel->SetMode( CM_PLAY );
|
|
|
|
CDmElement *pDmeToElement = CreateElement< CDmElement >( pszChannelName, pDmeFloatChannel->GetFileId() );
|
|
pDmeToElement->SetValue( "flexWeight", 0.0f );
|
|
pDmeFloatChannel->SetOutput( pDmeToElement, "flexWeight" );
|
|
|
|
CDmeFloatLog *pDmeFloatLog = pDmeFloatChannel->CreateLog< float >();
|
|
pDmeFloatLog->SetValueThreshold( 1.0e-6 );
|
|
pDmeFloatChannel->SetValue( "channelType", "morph" );
|
|
pDmeChannelsClip->m_Channels.AddToTail( pDmeFloatChannel );
|
|
|
|
return pDmeFloatLog;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::ComputeVstFlexSliderAnimDataList_R(
|
|
FbxAnimLayer *pFbxAnimLayer,
|
|
CUtlVector< FbxDmxAnimData_t * > &animDataList,
|
|
CDmeChannelsClip *pDmeChannelsClip,
|
|
const CDmFbxSerializer::FbxToDmxMap_t &fbxToDmxMap,
|
|
FbxNode *pFbxNode ) const
|
|
{
|
|
CDmFbxSerializer::FbxToDmxMap_t::IndexType_t nIndex = fbxToDmxMap.Find( pFbxNode );
|
|
if ( !fbxToDmxMap.IsValidIndex( nIndex ) )
|
|
return;
|
|
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
if ( pFbxNodeAttribute )
|
|
{
|
|
const FbxNodeAttribute::EType nAttributeType = pFbxNodeAttribute->GetAttributeType();
|
|
if ( nAttributeType == FbxNodeAttribute::eNull )
|
|
{
|
|
const CUtlString sNodeName = ::GetName( pFbxNode );
|
|
if ( sNodeName == "vstFlexSlider" || pFbxNode->FindProperty( "vstFlexSlider", false ).IsValid() )
|
|
{
|
|
for ( FbxProperty fbxProperty = pFbxNode->GetFirstProperty(); fbxProperty.IsValid(); fbxProperty = pFbxNode->GetNextProperty( fbxProperty ) )
|
|
{
|
|
const FbxDataType fbxDataType = fbxProperty.GetPropertyDataType();
|
|
const EFbxType eFbxType = fbxDataType.GetType();
|
|
|
|
if ( fbxProperty.GetFlag( FbxPropertyFlags::eUserDefined ) && ( eFbxType == eFbxDouble || eFbxType == eFbxFloat ) )
|
|
{
|
|
const char *pszChannelName = fbxProperty.GetNameAsCStr();
|
|
|
|
FbxDmxAnimData_t *pAnimData = animDataList[ animDataList.AddToTail( new FbxDmxAnimData_t ) ];
|
|
animDataList.AddToTail( pAnimData );
|
|
pAnimData->m_fbxProperty = fbxProperty;
|
|
|
|
if ( fbxProperty.HasMinLimit() && fbxProperty.HasMaxLimit() )
|
|
{
|
|
pAnimData->m_bNormalize = true;
|
|
pAnimData->m_flMin = fbxProperty.GetMinLimit();
|
|
pAnimData->m_flMax = fbxProperty.GetMaxLimit();
|
|
}
|
|
|
|
pAnimData->m_pDmeFloatLog = CreateMorphChannel( pszChannelName, pDmeChannelsClip );
|
|
|
|
if ( Verbose1() )
|
|
{
|
|
Msg( " - vstFlexSlider FlexControl Channel: %s\n", pszChannelName );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < pFbxNode->GetChildCount(); ++i )
|
|
{
|
|
ComputeVstFlexSliderAnimDataList_R( pFbxAnimLayer, animDataList, pDmeChannelsClip, fbxToDmxMap, pFbxNode->GetChild( i ) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::ComputeAnimDataList_R(
|
|
FbxAnimLayer *pFbxAnimLayer,
|
|
CUtlVector< FbxDmxAnimData_t * > &animDataList,
|
|
CDmeChannelsClip *pDmeChannelsClip,
|
|
const CDmFbxSerializer::FbxToDmxMap_t &fbxToDmxMap,
|
|
FbxNode *pFbxNode,
|
|
FbxDmxAnimData_t *pAnimDataParent ) const
|
|
{
|
|
CDmFbxSerializer::FbxToDmxMap_t::IndexType_t nIndex = fbxToDmxMap.Find( pFbxNode );
|
|
if ( !fbxToDmxMap.IsValidIndex( nIndex ) )
|
|
return;
|
|
|
|
FbxNodeAttribute *pFbxNodeAttribute = pFbxNode->GetNodeAttribute();
|
|
if ( pFbxNodeAttribute && pFbxNodeAttribute->GetAttributeType() == FbxNodeAttribute::eMesh )
|
|
{
|
|
FbxGeometry *pFbxGeometry = static_cast< FbxGeometry * >( pFbxNodeAttribute );
|
|
const int nBlendShapeDeformerCount = pFbxGeometry->GetDeformerCount( FbxDeformer::eBlendShape );
|
|
for ( int lBlendShapeIndex = 0; lBlendShapeIndex < nBlendShapeDeformerCount; ++lBlendShapeIndex )
|
|
{
|
|
FbxBlendShape *pFbxBlendShape = static_cast< FbxBlendShape * >( pFbxGeometry->GetDeformer( lBlendShapeIndex, FbxDeformer::eBlendShape ) );
|
|
if ( pFbxBlendShape )
|
|
{
|
|
const int nBlendShapeChannelCount = pFbxBlendShape->GetBlendShapeChannelCount();
|
|
for ( int nChannelIndex = 0; nChannelIndex < nBlendShapeChannelCount; ++nChannelIndex )
|
|
{
|
|
FbxBlendShapeChannel *pFbxBlendShapeChannel = pFbxBlendShape->GetBlendShapeChannel( nChannelIndex );
|
|
const CUtlString sChannelName = ::CleanupName( pFbxBlendShapeChannel->GetName() );
|
|
const char *pszChannelName = sChannelName.Get();
|
|
const char *pszExt = V_GetFileExtension( pszChannelName ); // FBX will probably name this blendShape.<THING> we just want <THING>
|
|
if ( pszExt )
|
|
{
|
|
pszChannelName = pszExt;
|
|
}
|
|
|
|
FbxAnimCurve *pFbxAnimCurve = pFbxGeometry->GetShapeChannel( lBlendShapeIndex, nChannelIndex, pFbxAnimLayer, true );
|
|
if ( pFbxAnimCurve )
|
|
{
|
|
bool bDefined = false;
|
|
|
|
FOR_EACH_VEC( animDataList, aIt )
|
|
{
|
|
const FbxDmxAnimData_t *pFbxDmxAnimData = animDataList[aIt];
|
|
if ( pFbxDmxAnimData->m_pDmeFloatLog && pFbxDmxAnimData->m_fbxProperty.IsValid() && !V_stricmp( pFbxDmxAnimData->m_fbxProperty.GetName(), pszChannelName ) )
|
|
{
|
|
if ( Verbose1() )
|
|
{
|
|
Warning( " - vstFlexSlider Already defined FlexControl Channel: %s, ignoring FbxBlendShapeChannel with same name\n", pszChannelName );
|
|
}
|
|
bDefined = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bDefined )
|
|
{
|
|
if ( Verbose1() )
|
|
{
|
|
Msg( " - FbxBlendShapeChannel: %s\n", pszChannelName );
|
|
}
|
|
|
|
FbxDmxAnimData_t *pAnimData = animDataList[ animDataList.AddToTail( new FbxDmxAnimData_t ) ];
|
|
animDataList.AddToTail( pAnimData );
|
|
pAnimData->m_pFbxAnimCurve = pFbxAnimCurve;
|
|
|
|
pAnimData->m_pDmeFloatLog = CreateMorphChannel( pszChannelName, pDmeChannelsClip );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FbxDmxAnimData_t *pAnimData = new FbxDmxAnimData_t;
|
|
animDataList.AddToTail( pAnimData );
|
|
|
|
CDmeDag *pDmeDag = fbxToDmxMap.Element( nIndex );
|
|
const bool bIsRoot = pDmeDag->GetValue( "__rootNode", false );
|
|
pAnimData->m_pFbxNode = pFbxNode;
|
|
pAnimData->m_pParent = bIsRoot ? NULL : pAnimDataParent;
|
|
|
|
CDmeTransform *pDmeTransform = pDmeDag->GetTransform();
|
|
|
|
CDmeChannel *pDmePosChannel = CreateElement< CDmeChannel >( CFmtStr( "%s_p", pDmeTransform->GetName() ).Access(), pDmeChannelsClip->GetFileId() );
|
|
pDmePosChannel->SetMode( CM_PLAY );
|
|
pDmePosChannel->SetOutput( pDmeTransform, "position" );
|
|
CDmeVector3Log *pDmePosLog = pDmePosChannel->CreateLog< Vector >();
|
|
pDmePosLog->SetValueThreshold( 1.0e-6 );
|
|
pDmeChannelsClip->m_Channels.AddToTail( pDmePosChannel );
|
|
|
|
CDmeChannel *pDmeRotChannel = CreateElement< CDmeChannel >( CFmtStr( "%s_o", pDmeTransform->GetName() ).Access(), pDmeChannelsClip->GetFileId() );
|
|
pDmeRotChannel->SetMode( CM_PLAY );
|
|
pDmeRotChannel->SetOutput( pDmeTransform, "orientation" );
|
|
CDmeQuaternionLog *pDmeRotLog = pDmeRotChannel->CreateLog< Quaternion >();
|
|
pDmeRotLog->SetValueThreshold( 1.0e-6 );
|
|
pDmeChannelsClip->m_Channels.AddToTail( pDmeRotChannel );
|
|
|
|
pAnimData->m_pDmePosLog = pDmePosLog;
|
|
pAnimData->m_pDmeRotLog = pDmeRotLog;
|
|
|
|
for ( int i = 0; i < pFbxNode->GetChildCount(); ++i )
|
|
{
|
|
ComputeAnimDataList_R( pFbxAnimLayer, animDataList, pDmeChannelsClip, fbxToDmxMap, pFbxNode->GetChild( i ), pAnimData );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::LoadAnimation(
|
|
CDmElement *pDmeRoot, CDmeModel *pDmeModel, const FbxToDmxMap_t &fbxToDmxMap, FbxScene *pFbxScene, FbxNode *pFbxRootNode, FbxTime::EMode eFbxTimeMode ) const
|
|
{
|
|
// Only process the first animation layer of the first animation stack
|
|
FbxAnimStack *pFbxAnimStack = pFbxScene->GetSrcObject<FbxAnimStack>();
|
|
if ( !pFbxAnimStack )
|
|
return;
|
|
|
|
FbxAnimLayer *pFbxAnimLayer = pFbxAnimStack->GetMember<FbxAnimLayer >();
|
|
if ( !pFbxAnimLayer )
|
|
return;
|
|
|
|
FbxArray< FbxString * > mAnimStackNameArray;
|
|
pFbxScene->FillAnimStackNameArray( mAnimStackNameArray );
|
|
|
|
if ( mAnimStackNameArray.GetCount() <= 0 )
|
|
return;
|
|
|
|
pFbxScene->SetCurrentAnimationStack( pFbxAnimStack );
|
|
|
|
FbxTakeInfo *pFbxTakeInfo = pFbxScene->GetTakeInfo( *( mAnimStackNameArray[0] ) );
|
|
if ( !pFbxTakeInfo )
|
|
return;
|
|
|
|
const FbxTime tFbxStart = pFbxTakeInfo->mLocalTimeSpan.GetStart();
|
|
const FbxLongLong nFbxStart = tFbxStart.GetFrameCount( eFbxTimeMode );
|
|
const FbxTime tFbxEnd = pFbxTakeInfo->mLocalTimeSpan.GetStop();
|
|
const FbxLongLong nFbxEnd = tFbxEnd.GetFrameCount( eFbxTimeMode );
|
|
|
|
const double flFrameRate = FbxTime::GetFrameRate( eFbxTimeMode );
|
|
const DmeFramerate_t dmeFrameRate( static_cast< float >( flFrameRate ) );
|
|
|
|
if ( Verbose1() )
|
|
{
|
|
Msg( " * Animation Stack %s Layer %s - %s\n", pFbxAnimStack->GetName(), pFbxAnimLayer->GetName(), mAnimStackNameArray[0]->Buffer() );
|
|
Msg( " + Fbx Time Start: %6.2f End: %6.2f Duration: %6.2f @ %6.2f fps\n",
|
|
tFbxStart.GetSecondDouble(),
|
|
tFbxEnd.GetSecondDouble(),
|
|
pFbxTakeInfo->mLocalTimeSpan.GetDuration().GetSecondDouble(),
|
|
flFrameRate );
|
|
Msg( " + Fbx Frame Start: %6lld End: %6lld Duration: %6lld @ %6.2f fps\n",
|
|
nFbxStart,
|
|
nFbxEnd,
|
|
pFbxTakeInfo->mLocalTimeSpan.GetDuration().GetFrameCount( eFbxTimeMode ),
|
|
flFrameRate );
|
|
}
|
|
|
|
const char *pszAnimName = "anim"; // TODO: Get this value, name of file?
|
|
|
|
DmFileId_t nFileId = pDmeRoot->GetFileId();
|
|
|
|
CDmeAnimationList *pDmeAnimationList = CreateElement< CDmeAnimationList >( pszAnimName, nFileId );
|
|
CDmeChannelsClip *pDmeChannelsClip = CreateElement< CDmeChannelsClip >( pszAnimName, nFileId );
|
|
pDmeAnimationList->AddAnimation( pDmeChannelsClip );
|
|
pDmeRoot->SetValue( "animationList", pDmeAnimationList );
|
|
pDmeModel->SetValue( "animationList", pDmeAnimationList );
|
|
|
|
pDmeChannelsClip->SetStartTime( DmeTime_t( tFbxStart.GetSecondDouble() ) );
|
|
pDmeChannelsClip->SetTimeOffset( pDmeChannelsClip->GetStartTime() );
|
|
|
|
pDmeChannelsClip->SetValue( "frameRate", static_cast< int >( dmeFrameRate.GetFramesPerSecond() ) );
|
|
|
|
CUtlVector< FbxDmxAnimData_t * > animList;
|
|
|
|
// Look for flex animation on vstFlexSlider nodes first
|
|
for ( int i = 0; i < pFbxRootNode->GetChildCount(); ++i )
|
|
{
|
|
ComputeVstFlexSliderAnimDataList_R( pFbxAnimLayer, animList, pDmeChannelsClip, fbxToDmxMap, pFbxRootNode->GetChild( i ) );
|
|
}
|
|
|
|
for ( int i = 0; i < pFbxRootNode->GetChildCount(); ++i )
|
|
{
|
|
ComputeAnimDataList_R( pFbxAnimLayer, animList, pDmeChannelsClip, fbxToDmxMap, pFbxRootNode->GetChild( i ), NULL );
|
|
}
|
|
|
|
matrix3x4_t mDmeWorld;
|
|
matrix3x4_t mDmeLocal;
|
|
|
|
FbxLongLong nFbxCurrent;
|
|
FbxTime tFbxCurrent;
|
|
|
|
for ( nFbxCurrent = nFbxStart; nFbxCurrent <= nFbxEnd; nFbxCurrent += 1 )
|
|
{
|
|
tFbxCurrent.SetFrame( nFbxCurrent, eFbxTimeMode );
|
|
const DmeTime_t tDmeCurrent( tFbxCurrent.GetSecondDouble() );
|
|
|
|
if ( Verbose2() )
|
|
{
|
|
Msg( " * Fbx Time: %6.2f Fbx Frame: %6lld Dmx Time: %6.2f Dmx Frame: %d\n",
|
|
tFbxCurrent.GetSecondDouble(), tFbxCurrent.GetFrameCount( eFbxTimeMode ),
|
|
tDmeCurrent.GetSeconds(), tDmeCurrent.CurrentFrame( dmeFrameRate ) );
|
|
}
|
|
|
|
for ( int i = 0; i < animList.Count(); ++i )
|
|
{
|
|
FbxDmxAnimData_t *pAnimData = animList[ i ];
|
|
|
|
if ( pAnimData->m_pDmeFloatLog )
|
|
{
|
|
if ( pAnimData->m_fbxProperty.IsValid() )
|
|
{
|
|
float flFloatValue = pAnimData->m_fbxProperty.EvaluateValue< float >( tFbxCurrent );
|
|
if ( pAnimData->m_bNormalize )
|
|
{
|
|
flFloatValue = RemapVal( flFloatValue, pAnimData->m_flMin, pAnimData->m_flMax, 0.0f, 1.0f );
|
|
}
|
|
pAnimData->m_pDmeFloatLog->SetKey( tDmeCurrent, flFloatValue );
|
|
}
|
|
else if ( pAnimData->m_pFbxAnimCurve )
|
|
{
|
|
const float flFloatValue = pAnimData->m_pFbxAnimCurve->Evaluate( tFbxCurrent );
|
|
pAnimData->m_pDmeFloatLog->SetKey( tDmeCurrent, flFloatValue );
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
FbxNode *pFbxNode = pAnimData->m_pFbxNode;
|
|
|
|
const FbxAMatrix &mFbxWorld = pFbxNode->EvaluateGlobalTransform( tFbxCurrent );
|
|
|
|
const FbxVector4 vFbxTranslate = mFbxWorld.GetT();
|
|
const FbxQuaternion qFbxRotate = mFbxWorld.GetQ();
|
|
|
|
Assert( vFbxTranslate[3] == 0.0 || vFbxTranslate[3] == 1.0 );
|
|
|
|
Vector vDmeTranslate( vFbxTranslate[0], vFbxTranslate[1], vFbxTranslate[2] );
|
|
Quaternion qDmeRotate( qFbxRotate[0], qFbxRotate[1], qFbxRotate[2], qFbxRotate[3] );
|
|
|
|
AngleMatrix( RadianEuler( qDmeRotate ), vDmeTranslate, mDmeWorld );
|
|
pAnimData->SetWorldMatrix( mDmeWorld );
|
|
|
|
if ( pAnimData->m_pParent )
|
|
{
|
|
MatrixMultiply( pAnimData->m_pParent->m_mWorldInverse, mDmeWorld, mDmeLocal );
|
|
MatrixAngles( mDmeLocal, qDmeRotate, vDmeTranslate );
|
|
}
|
|
|
|
pAnimData->m_pDmePosLog->SetKey( tDmeCurrent, vDmeTranslate );
|
|
pAnimData->m_pDmeRotLog->SetKey( tDmeCurrent, qDmeRotate );
|
|
}
|
|
}
|
|
|
|
pDmeChannelsClip->SetDuration( DmeTime_t( pFbxTakeInfo->mLocalTimeSpan.GetDuration().GetSecondDouble() ) );
|
|
|
|
if ( Verbose1() )
|
|
{
|
|
Msg( " + Dme Time Start: %6.2f End: %6.2f Duration: %6.2f @ %6.2f fps\n",
|
|
pDmeChannelsClip->GetStartTime().GetSeconds(),
|
|
pDmeChannelsClip->GetEndTime().GetSeconds(),
|
|
pDmeChannelsClip->GetDuration().GetSeconds(),
|
|
flFrameRate );
|
|
Msg( " + Dme Frame Start: %6d End: %6d Duration: %6d @ %6.2f fps\n",
|
|
pDmeChannelsClip->GetStartTime().CurrentFrame( dmeFrameRate ),
|
|
pDmeChannelsClip->GetEndTime().CurrentFrame( dmeFrameRate ),
|
|
pDmeChannelsClip->GetDuration().CurrentFrame( dmeFrameRate ),
|
|
flFrameRate );
|
|
}
|
|
|
|
animList.PurgeAndDeleteElements();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
FbxManager *CDmFbxSerializer::GetFbxManager()
|
|
{
|
|
static bool bWarned = false;
|
|
|
|
if ( !g_pFbx )
|
|
{
|
|
if ( !bWarned )
|
|
{
|
|
Log_Warning( LOG_FBX_SYSTEM, "Warning! FBX system not initialized\n" );
|
|
bWarned = true;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
return g_pFbx->GetFbxManager();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmFbxSerializer::AddConversionError( DmFileId_t nDmFileId, const char *pszErrorMsg )
|
|
{
|
|
if ( !pszErrorMsg )
|
|
return;
|
|
|
|
CDmElement *pDmRoot = g_pDataModel->GetElement( g_pDataModel->GetFileRoot( nDmFileId ) );
|
|
|
|
if ( !pDmRoot )
|
|
return;
|
|
|
|
CDmAttribute *pConversionErrorsAttr = pDmRoot->AddAttribute( "conversionErrors", AT_STRING_ARRAY );
|
|
if ( pConversionErrorsAttr )
|
|
{
|
|
CDmrStringArray conversionErrors( pConversionErrorsAttr );
|
|
for ( int i = 0; i < conversionErrors.Count(); ++i )
|
|
{
|
|
if ( !V_stricmp( conversionErrors[i], pszErrorMsg ) )
|
|
return;
|
|
}
|
|
|
|
conversionErrors.AddToTail( pszErrorMsg );
|
|
Warning( "%s\n", pszErrorMsg );
|
|
}
|
|
}
|