1464 lines
39 KiB
C++
1464 lines
39 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Serialize and Unserialize Wavefront OBJ <-> DME Data
|
|
//
|
|
//=============================================================================
|
|
|
|
|
|
// Valve includes
|
|
#include "tier1/characterset.h"
|
|
#include "movieobjects/dmedag.h"
|
|
#include "movieobjects/dmemesh.h"
|
|
#include "movieobjects/dmefaceset.h"
|
|
#include "movieobjects/dmematerial.h"
|
|
#include "movieobjects/dmobjserializer.h"
|
|
#include "movieobjects/dmecombinationoperator.h"
|
|
#include "movieobjects/dmemodel.h"
|
|
#include "filesystem.h"
|
|
#include "tier2/tier2.h"
|
|
#include "tier1/UtlStringMap.h"
|
|
#include "mathlib/mathlib.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CFaceSetData
|
|
{
|
|
public:
|
|
void Clear();
|
|
|
|
inline CUtlVector< int > *GetFaceSetIndices( const char *pFaceSetName )
|
|
{
|
|
return &m_faceSetIndices[ pFaceSetName ];
|
|
}
|
|
|
|
void AddToMesh( CDmeMesh *pMesh );
|
|
protected:
|
|
|
|
CUtlStringMap< CUtlVector< int > > m_faceSetIndices;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CFaceSetData::Clear()
|
|
{
|
|
m_faceSetIndices.Clear();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CFaceSetData::AddToMesh( CDmeMesh *pMesh )
|
|
{
|
|
const int nFaceSets( m_faceSetIndices.GetNumStrings() );
|
|
for ( int i( 0 ); i < nFaceSets; ++i )
|
|
{
|
|
const char *pName( m_faceSetIndices.String( i ) );
|
|
CUtlVector< int > &faceSetIndices( m_faceSetIndices[ pName ] );
|
|
|
|
if ( faceSetIndices.Count() )
|
|
{
|
|
CDmeFaceSet *pFaceSet = CreateElement< CDmeFaceSet >( pName, pMesh->GetFileId() );
|
|
|
|
CDmeMaterial *pMaterial = CreateElement< CDmeMaterial >( pName, pMesh->GetFileId() );
|
|
pMaterial->SetMaterial( pName );
|
|
|
|
pFaceSet->AddIndices( faceSetIndices.Count() );
|
|
pFaceSet->SetIndices( 0, faceSetIndices.Count(), faceSetIndices.Base() );
|
|
|
|
pFaceSet->SetMaterial( pMaterial );
|
|
|
|
pMesh->AddFaceSet( pFaceSet );
|
|
}
|
|
}
|
|
|
|
Clear();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CVertexData
|
|
{
|
|
public:
|
|
void Clear();
|
|
|
|
inline void AddPosition( const Vector &p ) { m_positions.AddToTail( p ); }
|
|
|
|
inline void AddPositionIndex( int i ) { m_pIndices.AddToTail( i ); }
|
|
|
|
inline void AddNormal( const Vector &n ) { m_normals.AddToTail( n ); }
|
|
|
|
inline void AddNormalIndex( int i ) { m_nIndices.AddToTail( i ); }
|
|
|
|
inline void AddUV( const Vector2D &uv ) { AddUniqueValue( uv, m_uvs, m_uvIndexMap, FLT_EPSILON * 0.1f ); }
|
|
|
|
inline void AddUVIndex( int i ) { Assert( i < m_uvIndexMap.Count() ); m_uvIndices.AddToTail( m_uvIndexMap[ i ] ); }
|
|
|
|
inline int VertexCount() const { return m_pIndices.Count(); }
|
|
|
|
CDmeVertexDataBase *AddToMesh( CDmeMesh *pMesh, bool bAbsolute, const char *pName, bool bDelta );
|
|
|
|
protected:
|
|
template < class T_t > void AddUniqueValue(
|
|
const T_t &v,
|
|
CUtlVector< T_t > &vs,
|
|
CUtlVector< int > &map,
|
|
float flThresh = FLT_EPSILON )
|
|
{
|
|
const int nVs( vs.Count() );
|
|
for ( int i( 0 ); i < nVs; ++i )
|
|
{
|
|
if ( v.DistToSqr( vs[ i ] ) < flThresh )
|
|
{
|
|
map.AddToTail( i );
|
|
return;
|
|
}
|
|
}
|
|
|
|
map.AddToTail( vs.Count() );
|
|
vs.AddToTail( v );
|
|
}
|
|
|
|
CDmeVertexDataBase *Add( CDmeMesh *pMesh, const char *pName = "bind" );
|
|
|
|
CDmeVertexDeltaData *AddDelta( CDmeMesh *pMesh, bool bAbsolute, const char *pName = "bind" );
|
|
|
|
CUtlVector< Vector > m_positions;
|
|
CUtlVector< int > m_pIndices;
|
|
|
|
CUtlVector< Vector > m_normals;
|
|
CUtlVector< int > m_nIndices;
|
|
|
|
CUtlVector< Vector2D > m_uvs;
|
|
CUtlVector< int > m_uvIndexMap;
|
|
CUtlVector< int > m_uvIndices;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CVertexData::Clear()
|
|
{
|
|
m_positions.RemoveAll();
|
|
m_pIndices.RemoveAll();
|
|
|
|
m_normals.RemoveAll();
|
|
m_nIndices.RemoveAll();
|
|
|
|
m_uvs.RemoveAll();
|
|
m_uvIndexMap.RemoveAll();
|
|
m_uvIndices.RemoveAll();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeVertexDataBase *CVertexData::AddToMesh( CDmeMesh *pMesh, bool bAbsolute, const char *pName, bool delta )
|
|
{
|
|
if ( delta )
|
|
return AddDelta( pMesh, bAbsolute, pName );
|
|
|
|
return Add( pMesh, pName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeVertexDataBase *CVertexData::Add( CDmeMesh *pMesh, const char *pName )
|
|
{
|
|
CDmeVertexDataBase *pVertexData( NULL );
|
|
|
|
if ( m_positions.Count() && m_pIndices.Count() )
|
|
{
|
|
{
|
|
CDmeVertexData *pBaseVertexData = pMesh->FindOrCreateBaseState( pName );
|
|
pMesh->SetCurrentBaseState( pName );
|
|
pBaseVertexData->AddVertexIndices( m_pIndices.Count() );
|
|
pVertexData = pBaseVertexData;
|
|
}
|
|
|
|
pVertexData->FlipVCoordinate( true );
|
|
|
|
const FieldIndex_t pIndex( pVertexData->CreateField( CDmeVertexData::FIELD_POSITION ) );
|
|
pVertexData->AddVertexData( pIndex, m_positions.Count() );
|
|
pVertexData->SetVertexData( pIndex, 0, m_positions.Count(), AT_VECTOR3, m_positions.Base() );
|
|
pVertexData->SetVertexIndices( pIndex, 0, m_pIndices.Count(), m_pIndices.Base() );
|
|
|
|
if ( pVertexData && m_normals.Count() && m_nIndices.Count() )
|
|
{
|
|
Assert( m_pIndices.Count() == m_nIndices.Count() );
|
|
|
|
const FieldIndex_t nIndex( pVertexData->CreateField( CDmeVertexData::FIELD_NORMAL ) );
|
|
pVertexData->AddVertexData( nIndex, m_normals.Count() );
|
|
pVertexData->SetVertexData( nIndex, 0, m_normals.Count(), AT_VECTOR3, m_normals.Base() );
|
|
pVertexData->SetVertexIndices( nIndex, 0, m_nIndices.Count(), m_nIndices.Base() );
|
|
}
|
|
|
|
if ( pVertexData && m_uvs.Count() && m_uvIndices.Count() )
|
|
{
|
|
Assert( m_pIndices.Count() == m_uvIndices.Count() );
|
|
|
|
const FieldIndex_t uvIndex( pVertexData->CreateField( CDmeVertexData::FIELD_TEXCOORD ) );
|
|
pVertexData->AddVertexData( uvIndex, m_uvs.Count() );
|
|
pVertexData->SetVertexData( uvIndex, 0, m_uvs.Count(), AT_VECTOR2, m_uvs.Base() );
|
|
pVertexData->SetVertexIndices( uvIndex, 0, m_uvIndices.Count(), m_uvIndices.Base() );
|
|
}
|
|
}
|
|
|
|
return pVertexData;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeVertexDeltaData *CVertexData::AddDelta( CDmeMesh *pMesh, bool bAbsolute, const char *pName )
|
|
{
|
|
CDmeVertexDeltaData *pDelta( NULL );
|
|
|
|
if ( m_positions.Count() )
|
|
{
|
|
CDmeVertexData *pBind = pMesh->FindBaseState( "bind" );
|
|
if ( pBind == NULL )
|
|
return NULL;
|
|
|
|
const FieldIndex_t pBindIndex( pBind->FindFieldIndex( CDmeVertexData::FIELD_POSITION ) );
|
|
|
|
if ( pBindIndex < 0 )
|
|
return NULL;
|
|
|
|
CDmrArrayConst< Vector > pBindData( pBind->GetVertexData( pBindIndex ) );
|
|
|
|
const int pCount( m_positions.Count() );
|
|
if ( pBindData.Count() != pCount )
|
|
return NULL;
|
|
|
|
for ( int i( 0 ); i < pCount; ++i )
|
|
{
|
|
m_positions[ i ] -= pBindData[ i ];
|
|
}
|
|
|
|
int *pIndices = reinterpret_cast< int * >( alloca( pCount * sizeof( int ) ) );
|
|
int nNonZero( 0 );
|
|
for ( int i( 0 ); i < pCount; ++i )
|
|
{
|
|
const Vector &v( m_positions[ i ] );
|
|
// Kind of a magic number but it's because of 16 bit compression of the delta values
|
|
if ( fabs( v.x ) >= ( 1 / 4096.0f ) || fabs( v.y ) >= ( 1 / 4096.0f ) || fabs( v.z ) >= ( 1 / 4096.0f ) )
|
|
{
|
|
m_positions[ nNonZero ] = v;
|
|
pIndices[ nNonZero ] = i;
|
|
++nNonZero;
|
|
}
|
|
}
|
|
|
|
pDelta = pMesh->FindOrCreateDeltaState( pName );
|
|
pDelta->FlipVCoordinate( true );
|
|
pDelta->SetValue( "corrected", !bAbsolute );
|
|
|
|
const FieldIndex_t pIndex( pDelta->CreateField( CDmeVertexData::FIELD_POSITION ) );
|
|
pDelta->AddVertexData( pIndex, nNonZero );
|
|
pDelta->SetVertexData( pIndex, 0, nNonZero, AT_VECTOR3, m_positions.Base() );
|
|
pDelta->SetVertexIndices( pIndex, 0, nNonZero, pIndices );
|
|
|
|
const FieldIndex_t nBindNormalIndex = pBind->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
|
|
if ( nBindNormalIndex >= 0 )
|
|
{
|
|
CDmrArrayConst< Vector > bindNormalData( pBind->GetVertexData( nBindNormalIndex ) );
|
|
const int nNormalCount = m_normals.Count();
|
|
if ( bindNormalData.Count() == nNormalCount )
|
|
{
|
|
for ( int i = 0; i < nNormalCount; ++i )
|
|
{
|
|
m_normals[ i ] -= bindNormalData[ i ];
|
|
}
|
|
|
|
int *pNormalIndices = reinterpret_cast< int * >( stackalloc( nNormalCount * sizeof( int ) ) );
|
|
int nNormalDeltaCount = 0;
|
|
for ( int i = 0; i < nNormalCount; ++i )
|
|
{
|
|
const Vector &n = m_normals[ i ];
|
|
// Kind of a magic number but it's because of 16 bit compression of the delta values
|
|
if ( fabs( n.x ) >= ( 1 / 4096.0f ) || fabs( n.y ) >= ( 1 / 4096.0f ) || fabs( n.z ) >= ( 1 / 4096.0f ) )
|
|
{
|
|
m_normals[ nNormalDeltaCount ] = n;
|
|
pNormalIndices[ nNormalDeltaCount ] = i;
|
|
++nNormalDeltaCount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return pDelta;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Convert from DME -> OBJ
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmObjSerializer::Serialize( CUtlBuffer &buf, CDmElement *pRoot )
|
|
{
|
|
return false; // For now
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Convert from OBJ -> DME
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmObjSerializer::Unserialize( CUtlBuffer &buf, const char *pEncodingName, int nEncodingVersion,
|
|
const char *pSourceFormatName, int nSourceFormatVersion,
|
|
DmFileId_t fileid, DmConflictResolution_t idConflictResolution, CDmElement **ppRoot )
|
|
{
|
|
*ppRoot = ReadOBJ( buf, fileid, "bind" );
|
|
return *ppRoot != NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Convert from OBJ -> DME
|
|
// If mesh is not NULL, the OBJ is added as a delta state to the mesh
|
|
//-----------------------------------------------------------------------------
|
|
CDmElement *CDmObjSerializer::ReadOBJ(
|
|
const char *pFilename,
|
|
CDmeMesh **ppCreatedMesh,
|
|
bool bLoadAllDeltas /* = true */,
|
|
bool bAbsolute /* = true */ )
|
|
{
|
|
char filename[ MAX_PATH ];
|
|
Q_strncpy( filename, pFilename, sizeof( filename ) );
|
|
Q_FixSlashes( filename );
|
|
|
|
CUtlBuffer utlBuf( 0, 0, CUtlBuffer::TEXT_BUFFER );
|
|
if ( !g_pFullFileSystem->ReadFile( filename, NULL, utlBuf ) )
|
|
return NULL;
|
|
|
|
char baseFile[ MAX_PATH ];
|
|
Q_FileBase( filename, baseFile, sizeof( baseFile ) );
|
|
|
|
CDmeMesh *pMesh( NULL );
|
|
|
|
DmFileId_t nFileId = g_pDataModel->FindOrCreateFileId( pFilename );
|
|
|
|
CDmElement *pRoot = ReadOBJ( utlBuf, nFileId, baseFile, filename, NULL, &pMesh, bAbsolute );
|
|
if ( pRoot && pMesh )
|
|
{
|
|
if ( ppCreatedMesh )
|
|
{
|
|
*ppCreatedMesh = pMesh;
|
|
}
|
|
|
|
CDmeCombinationOperator *pCombo( NULL );
|
|
|
|
// Check if there are deltas in the directory with the same prefix
|
|
// But only if the rest of the file is <prefix>=<suffix>.obj or is <prefix>_zero.obj
|
|
|
|
char *pSuffix = Q_strrchr( baseFile, '=' );
|
|
if ( !pSuffix || !*pSuffix )
|
|
{
|
|
pSuffix = Q_strrchr( baseFile, '_' );
|
|
if ( !pSuffix || !*pSuffix )
|
|
return pRoot;
|
|
|
|
if ( Q_stricmp( pSuffix, "_zero" ) )
|
|
return pRoot;
|
|
}
|
|
|
|
char findGlob[ MAX_PATH ];
|
|
Q_strncpy( findGlob, baseFile, sizeof( findGlob ) );
|
|
pSuffix = findGlob + ( pSuffix - baseFile );
|
|
*( pSuffix + 0 ) = '_'; // Just in case it was <prefix>=<suffix>.obj
|
|
*( pSuffix + 1 ) = '*';
|
|
*( pSuffix + 2 ) = '.';
|
|
Q_strncpy( pSuffix + 3, Q_GetFileExtension( filename ), sizeof( findGlob ) - ( pSuffix - findGlob + 3 ) );
|
|
|
|
char path[ MAX_PATH ];
|
|
Q_ExtractFilePath( filename, path, sizeof( path ) );
|
|
|
|
m_objDirectory = path;
|
|
|
|
char findPath[ MAX_PATH ];
|
|
Q_ComposeFileName( path, findGlob, findPath, sizeof( findPath ) );
|
|
|
|
FileFindHandle_t hFind;
|
|
|
|
char deltaFile[ MAX_PATH ];
|
|
char deltaPath[ MAX_PATH ];
|
|
|
|
for ( const char *pFindFile( g_pFullFileSystem->FindFirst( findPath, &hFind ) ); pFindFile && *pFindFile; pFindFile = g_pFullFileSystem->FindNext( hFind ) )
|
|
{
|
|
Q_FileBase( pFindFile, deltaFile, sizeof( deltaFile ) );
|
|
|
|
if ( Q_stricmp( baseFile, deltaFile ) )
|
|
{
|
|
Q_ComposeFileName( path, pFindFile, deltaPath, sizeof( deltaPath ) );
|
|
|
|
if ( !g_pFullFileSystem->FileExists( deltaPath ) )
|
|
continue;
|
|
|
|
char *pControlName = strchr( deltaFile, '_' );
|
|
if ( pControlName && *( pControlName + 1 ) )
|
|
{
|
|
++pControlName;
|
|
char *pDeltaName( pControlName );
|
|
for ( char *pPlus( strchr( pDeltaName, '+' ) ); pPlus; pPlus = strchr( pPlus, '+' ) )
|
|
{
|
|
*pPlus = '_';
|
|
}
|
|
}
|
|
|
|
if ( !strchr( pControlName, '_' ) )
|
|
{
|
|
if ( pCombo == NULL )
|
|
{
|
|
pCombo = CreateElement< CDmeCombinationOperator >( "combinationOperator", pRoot->GetFileId() );
|
|
pRoot->SetValue( "combinationOperator", pCombo );
|
|
}
|
|
}
|
|
|
|
DeltaInfo_t &deltaInfo = m_deltas[ pControlName ];
|
|
deltaInfo.m_filename = pFindFile;
|
|
deltaInfo.m_pMesh = pMesh;
|
|
deltaInfo.m_pComboOp = pCombo;
|
|
|
|
if ( bLoadAllDeltas )
|
|
{
|
|
GetDelta( pControlName, bAbsolute );
|
|
}
|
|
}
|
|
}
|
|
|
|
g_pFullFileSystem->FindClose( hFind );
|
|
|
|
if ( pCombo )
|
|
{
|
|
pCombo->AddTarget( pMesh );
|
|
pMesh->ComputeAllCorrectedPositionsFromActualPositions();
|
|
}
|
|
}
|
|
|
|
return pRoot;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Common function both ReadOBJ & Unserialize can call
|
|
//-----------------------------------------------------------------------------
|
|
CDmElement *CDmObjSerializer::ReadOBJ( CUtlBuffer &buf,
|
|
DmFileId_t dmFileId,
|
|
const char *pName,
|
|
const char *pFilename /* = NULL */,
|
|
CDmeMesh *pBaseMesh /* = NULL */,
|
|
CDmeMesh **ppCreatedMesh /* = NULL */,
|
|
bool bAbsolute /* = true */ )
|
|
{
|
|
CDmElement *pRoot( NULL );
|
|
CDmeModel *pModel( NULL );
|
|
|
|
if ( !pBaseMesh )
|
|
{
|
|
pRoot = CreateElement< CDmElement >( "root", dmFileId );
|
|
pModel = CreateElement< CDmeModel >( "model", dmFileId );
|
|
|
|
pRoot->SetValue( "skeleton", pModel );
|
|
pRoot->SetValue( "model", pModel );
|
|
}
|
|
|
|
m_mtlLib.RemoveAll();
|
|
|
|
char tmpBuf0[ 4096 ];
|
|
char tmpBuf1[ 4096 ];
|
|
|
|
characterset_t breakSet;
|
|
CharacterSetBuild( &breakSet, "/\\" );
|
|
|
|
const char *pBuf;
|
|
|
|
Vector p;
|
|
Vector2D uv;
|
|
|
|
CVertexData vertexData;
|
|
CFaceSetData faceSetData;
|
|
|
|
CUtlString groupName;
|
|
|
|
CDmeDag *pDmeDag( NULL );
|
|
CDmeMesh *pDmeMesh( NULL );
|
|
CUtlVector< int > *pFaceIndices( NULL );
|
|
|
|
while ( buf.IsValid() )
|
|
{
|
|
buf.GetLine( tmpBuf0, sizeof( tmpBuf0 ) );
|
|
|
|
pBuf = SkipSpace( tmpBuf0 );
|
|
|
|
if ( sscanf( tmpBuf0, "v %f %f %f", &p.x, &p.y, &p.z ) == 3 )
|
|
{
|
|
if ( pDmeDag )
|
|
{
|
|
vertexData.AddToMesh( pDmeMesh, bAbsolute, "bind", false );
|
|
faceSetData.AddToMesh( pDmeMesh );
|
|
|
|
pDmeDag = NULL;
|
|
pDmeMesh = NULL;
|
|
pFaceIndices = NULL;
|
|
}
|
|
|
|
vertexData.AddPosition( p );
|
|
|
|
continue;
|
|
}
|
|
|
|
if ( sscanf( pBuf, "vn %f %f %f", &p.x, &p.y, &p.z ) == 3 )
|
|
{
|
|
vertexData.AddNormal( p );
|
|
continue;
|
|
}
|
|
|
|
if ( !pBaseMesh )
|
|
{
|
|
if ( sscanf( pBuf, "vt %f %f", &uv.x, &uv.y ) == 2 )
|
|
{
|
|
vertexData.AddUV( uv );
|
|
continue;
|
|
}
|
|
|
|
if ( pFilename && sscanf( pBuf, "mtllib %4096s", tmpBuf1 ) == 1 )
|
|
{
|
|
CUtlString mtlLib( tmpBuf1 );
|
|
|
|
Q_strncpy( tmpBuf0, pFilename, sizeof( tmpBuf0 ) );
|
|
Q_FixSlashes( tmpBuf0 );
|
|
Q_StripFilename( tmpBuf0 );
|
|
|
|
char mtlLibPath[ MAX_PATH ];
|
|
|
|
Q_ComposeFileName( tmpBuf0, tmpBuf1, mtlLibPath, sizeof( mtlLibPath ) );
|
|
CUtlBuffer utlBuf( 0, 0, CUtlBuffer::TEXT_BUFFER );
|
|
|
|
if ( g_pFullFileSystem->ReadFile( mtlLibPath, NULL, utlBuf ) )
|
|
{
|
|
ParseMtlLib( utlBuf );
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if ( sscanf( pBuf, "usemtl %4096s", tmpBuf1 ) == 1 )
|
|
{
|
|
// Remove any 'SG' suffix from the material
|
|
const uint sLen = Q_strlen( tmpBuf1 );
|
|
if ( sLen && !Q_strcmp( tmpBuf1 + sLen - 2, "SG" ) )
|
|
{
|
|
tmpBuf1[ sLen - 2 ] = '\0';
|
|
}
|
|
|
|
const char *pTexture( FindMtlEntry( tmpBuf1 ) );
|
|
if ( pTexture )
|
|
{
|
|
pFaceIndices = faceSetData.GetFaceSetIndices( pTexture );
|
|
}
|
|
else
|
|
{
|
|
pFaceIndices = faceSetData.GetFaceSetIndices( tmpBuf1 );
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if ( sscanf( pBuf, "g %4096s", tmpBuf1 ) == 1 )
|
|
{
|
|
groupName = tmpBuf1;
|
|
if ( pFaceIndices == NULL )
|
|
{
|
|
pFaceIndices = faceSetData.GetFaceSetIndices( tmpBuf1 );
|
|
}
|
|
continue;
|
|
}
|
|
if ( *pBuf == 'f' && ( *( pBuf + 1 ) == ' ' || *( pBuf + 1 ) == '\t' ) )
|
|
{
|
|
if ( pDmeDag == NULL )
|
|
{
|
|
pDmeDag = CreateElement< CDmeDag >( pName ? pName : ( groupName.IsEmpty() ? "obj" : groupName.Get() ), pRoot->GetFileId() );
|
|
Assert( pDmeDag );
|
|
pDmeMesh = CreateElement< CDmeMesh >( pName ? pName : ( groupName.IsEmpty() ? "obj" : groupName.Get() ), pRoot->GetFileId() );
|
|
if ( ppCreatedMesh && *ppCreatedMesh == NULL )
|
|
{
|
|
// Only the first mesh created...
|
|
*ppCreatedMesh = pDmeMesh;
|
|
}
|
|
pDmeDag->SetShape( pDmeMesh );
|
|
if ( pModel )
|
|
{
|
|
pModel->AddJoint( pDmeDag );
|
|
pModel->AddChild( pDmeDag );
|
|
}
|
|
}
|
|
|
|
if ( pFaceIndices == NULL )
|
|
{
|
|
pFaceIndices = faceSetData.GetFaceSetIndices( "facetSet" );
|
|
}
|
|
|
|
int v;
|
|
int t;
|
|
int n;
|
|
|
|
pBuf = SkipSpace( pBuf + 1 );
|
|
int nLen = Q_strlen( pBuf );
|
|
|
|
CUtlBuffer bufParse( pBuf, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
|
|
|
|
while ( bufParse.IsValid() )
|
|
{
|
|
if ( !ParseVertex( bufParse, breakSet, v, t, n ) )
|
|
break;
|
|
|
|
pFaceIndices->AddToTail( vertexData.VertexCount() );
|
|
if ( v > 0 )
|
|
{
|
|
vertexData.AddPositionIndex( v - 1 );
|
|
}
|
|
|
|
if ( n > 0 )
|
|
{
|
|
vertexData.AddNormalIndex( n - 1 );
|
|
}
|
|
|
|
if ( t > 0 )
|
|
{
|
|
vertexData.AddUVIndex( t - 1 );
|
|
}
|
|
}
|
|
|
|
pFaceIndices->AddToTail( -1 );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
CDmeVertexDataBase *pVertexData( NULL );
|
|
|
|
if ( pBaseMesh )
|
|
{
|
|
pVertexData = vertexData.AddToMesh( pBaseMesh, bAbsolute, pName, true );
|
|
}
|
|
else
|
|
{
|
|
pVertexData = vertexData.AddToMesh( pDmeMesh, bAbsolute, "bind", false );
|
|
faceSetData.AddToMesh( pDmeMesh );
|
|
}
|
|
|
|
if ( pModel )
|
|
{
|
|
pModel->CaptureJointsToBaseState( "bind" );
|
|
}
|
|
|
|
if ( pBaseMesh )
|
|
return pVertexData;
|
|
|
|
return pRoot;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
int CDmObjSerializer::OutputVectors(
|
|
CUtlBuffer &b,
|
|
const char *pPrefix,
|
|
const CUtlVector< Vector > &vData,
|
|
const matrix3x4_t &matrix )
|
|
{
|
|
Vector v;
|
|
|
|
const int nv( vData.Count() );
|
|
|
|
for ( int i( 0 ); i < nv; ++i )
|
|
{
|
|
VectorTransform( vData[ i ], matrix, v );
|
|
b << pPrefix << v << "\n";
|
|
}
|
|
|
|
return nv;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
int CDmObjSerializer::OutputVectors(
|
|
CUtlBuffer &b,
|
|
const char *pPrefix,
|
|
const CUtlVector< Vector2D > &vData )
|
|
{
|
|
Vector v;
|
|
|
|
const int nv( vData.Count() );
|
|
|
|
for ( int i( 0 ); i < nv; ++i )
|
|
{
|
|
b << pPrefix << vData[ i ] << "\n";
|
|
}
|
|
|
|
return nv;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmObjSerializer::MeshToObj(
|
|
CUtlBuffer &b,
|
|
const matrix3x4_t &parentWorldMatrix,
|
|
CDmeMesh *pMesh,
|
|
const char *pDeltaName,
|
|
bool absolute )
|
|
{
|
|
CUtlVector< CDmeMesh::DeltaComputation_t > compList;
|
|
|
|
if ( pDeltaName )
|
|
{
|
|
pMesh->ComputeDependentDeltaStateList( compList );
|
|
}
|
|
|
|
const int nCompList( compList.Count() );
|
|
|
|
CDmeVertexData *pBase( pMesh->FindBaseState( "bind" ) );
|
|
if ( !pBase )
|
|
return;
|
|
|
|
const FieldIndex_t nPosIndex( pBase->FindFieldIndex( CDmeVertexData::FIELD_POSITION ) );
|
|
if ( nPosIndex < 0 )
|
|
return;
|
|
|
|
int nPositionCount = 0;
|
|
int nTextureCount = 0;
|
|
int nNormalCount = 0;
|
|
|
|
b << "g " << pMesh->GetName() << "\n";
|
|
|
|
CDmrArrayConst< Vector > pArray( pBase->GetVertexData( nPosIndex ) );
|
|
const CUtlVector< int > *ppIndices( &pBase->GetVertexIndexData( nPosIndex ) );
|
|
const CUtlVector< Vector > &pConstData( pArray.Get() );
|
|
|
|
if ( nCompList )
|
|
{
|
|
CUtlVector< Vector > pData;
|
|
pData.CopyArray( pConstData.Base(), pConstData.Count() );
|
|
|
|
if ( absolute )
|
|
{
|
|
for ( int i ( 0 ); i < nCompList; ++i )
|
|
{
|
|
CDmeVertexDeltaData *pTmpDeltaState( pMesh->GetDeltaState( compList[ i ].m_nDeltaIndex ) );
|
|
if ( Q_strcmp( pTmpDeltaState->GetName(), pDeltaName ) )
|
|
continue;
|
|
|
|
b << "# Delta: " << pTmpDeltaState->GetName() << "\n";
|
|
pMesh->AddDelta( pTmpDeltaState, pData.Base(), pData.Count(), CDmeVertexData::FIELD_POSITION, 1.0f );
|
|
|
|
const CUtlVector< int > &depDeltas( compList[ i ].m_DependentDeltas );
|
|
const int nDepDeltas( depDeltas.Count() );
|
|
for ( int j( 0 ); j < nDepDeltas; ++j )
|
|
{
|
|
pTmpDeltaState = pMesh->GetDeltaState( depDeltas[ j ] );
|
|
b << "# Dependent Delta: " << pTmpDeltaState->GetName() << "\n";
|
|
pMesh->AddDelta( pTmpDeltaState, pData.Base(), pData.Count(), CDmeVertexData::FIELD_POSITION, 1.0f );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( int i ( 0 ); i < nCompList; ++i )
|
|
{
|
|
CDmeVertexDeltaData *pTmpDeltaState( pMesh->GetDeltaState( compList[ i ].m_nDeltaIndex ) );
|
|
if ( Q_strcmp( pTmpDeltaState->GetName(), pDeltaName ) )
|
|
continue;
|
|
|
|
b << "# Delta: " << pTmpDeltaState->GetName() << "\n";
|
|
pMesh->AddDelta( pTmpDeltaState, pData.Base(), pData.Count(), CDmeVertexData::FIELD_POSITION, 1.0f );
|
|
}
|
|
}
|
|
|
|
nPositionCount = OutputVectors( b, "v ", pData, parentWorldMatrix );
|
|
}
|
|
else
|
|
{
|
|
nPositionCount = OutputVectors( b, "v ", pConstData, parentWorldMatrix );
|
|
}
|
|
|
|
const CUtlVector< int > *puvIndices( NULL );
|
|
const FieldIndex_t uvIndex( pBase->FindFieldIndex( CDmeVertexData::FIELD_TEXCOORD ) );
|
|
if ( uvIndex >= 0 )
|
|
{
|
|
CDmrArrayConst< Vector2D > uvArray( pBase->GetVertexData( uvIndex ) );
|
|
const CUtlVector< Vector2D > &uvData( uvArray.Get() );
|
|
puvIndices = &pBase->GetVertexIndexData( uvIndex );
|
|
|
|
nTextureCount = OutputVectors( b, "vt ", uvData );
|
|
}
|
|
|
|
const CUtlVector< int > *pnIndices( NULL );
|
|
const FieldIndex_t nIndex( pBase->FindFieldIndex( CDmeVertexData::FIELD_NORMAL ) );
|
|
if ( nIndex >= 0 )
|
|
{
|
|
matrix3x4_t normalMatrix;
|
|
MatrixInverseTranspose( parentWorldMatrix, normalMatrix );
|
|
|
|
CDmrArrayConst< Vector > nArray( pBase->GetVertexData( nIndex ) );
|
|
const CUtlVector< Vector > &nConstData( nArray.Get() );
|
|
pnIndices = &pBase->GetVertexIndexData( nIndex );
|
|
|
|
if ( nCompList )
|
|
{
|
|
CUtlVector< Vector > nData;
|
|
nData.CopyArray( nConstData.Base(), nConstData.Count() );
|
|
|
|
if ( absolute )
|
|
{
|
|
for ( int i ( 0 ); i < nCompList; ++i )
|
|
{
|
|
CDmeVertexDeltaData *pTmpDeltaState( pMesh->GetDeltaState( compList[ i ].m_nDeltaIndex ) );
|
|
if ( Q_strcmp( pTmpDeltaState->GetName(), pDeltaName ) )
|
|
continue;
|
|
|
|
b << "# Delta: " << pTmpDeltaState->GetName() << "\n";
|
|
pMesh->AddDelta( pTmpDeltaState, nData.Base(), nData.Count(), CDmeVertexData::FIELD_NORMAL, 1.0f );
|
|
|
|
const CUtlVector< int > &depDeltas( compList[ i ].m_DependentDeltas );
|
|
const int nDepDeltas( depDeltas.Count() );
|
|
for ( int j( 0 ); j < nDepDeltas; ++j )
|
|
{
|
|
pTmpDeltaState = pMesh->GetDeltaState( depDeltas[ j ] );
|
|
b << "# Dependent Delta: " << pTmpDeltaState->GetName() << "\n";
|
|
pMesh->AddDelta( pTmpDeltaState, nData.Base(), nData.Count(), CDmeVertexData::FIELD_NORMAL, 1.0f );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( int i ( 0 ); i < nCompList; ++i )
|
|
{
|
|
CDmeVertexDeltaData *pTmpDeltaState( pMesh->GetDeltaState( compList[ i ].m_nDeltaIndex ) );
|
|
if ( Q_strcmp( pTmpDeltaState->GetName(), pDeltaName ) )
|
|
continue;
|
|
|
|
b << "# Delta: " << pTmpDeltaState->GetName() << "\n";
|
|
pMesh->AddDelta( pTmpDeltaState, nData.Base(), nData.Count(), CDmeVertexData::FIELD_NORMAL, 1.0f );
|
|
}
|
|
}
|
|
|
|
nNormalCount = OutputVectors( b, "vn ", nData, normalMatrix );
|
|
}
|
|
else
|
|
{
|
|
nNormalCount = OutputVectors( b, "vn ", nConstData, normalMatrix );
|
|
}
|
|
}
|
|
|
|
const int pCount( ppIndices->Count() );
|
|
const int uvCount( puvIndices ? puvIndices->Count() : 0 );
|
|
const int nCount( pnIndices ? pnIndices->Count() : 0 );
|
|
|
|
const int nFaceSets( pMesh->FaceSetCount() );
|
|
for ( int i= 0 ; i < nFaceSets; ++i )
|
|
{
|
|
CDmeFaceSet *pFaceSet( pMesh->GetFaceSet( i ) );
|
|
CDmeMaterial *pMaterial( pFaceSet->GetMaterial() );
|
|
if ( pMaterial )
|
|
{
|
|
b << "usemtl " << pMaterial->GetMaterialName() << "\n";
|
|
}
|
|
|
|
const int nIndices( pFaceSet->NumIndices() );
|
|
const int *pnFaceSetIndex( pFaceSet->GetIndices() );
|
|
const int *const pEnd( pnFaceSetIndex + nIndices );
|
|
int fIndex;
|
|
|
|
const char *const pFaceStart( "f " );
|
|
const char *const pFaceNext( " " );
|
|
const char *pFaceSep( pFaceStart );
|
|
|
|
if ( pCount == uvCount && pCount == nCount )
|
|
{
|
|
const CUtlVector< int > &pIndices( *ppIndices );
|
|
const CUtlVector< int > &uvIndices( *puvIndices );
|
|
const CUtlVector< int > &nvIndices( *pnIndices );
|
|
|
|
while ( pnFaceSetIndex < pEnd )
|
|
{
|
|
fIndex = *pnFaceSetIndex++;
|
|
if ( fIndex < 0 )
|
|
{
|
|
b << "\n";
|
|
pFaceSep = pFaceStart;
|
|
continue;
|
|
}
|
|
|
|
b << pFaceSep << ( pIndices[ fIndex ] + m_nPositionOffset ) << '/' << ( uvIndices[ fIndex ] + m_nTextureOffset ) << '/' << ( nvIndices[ fIndex ] + m_nNormalOffset );
|
|
pFaceSep = pFaceNext;
|
|
}
|
|
}
|
|
else if ( pCount == uvCount )
|
|
{
|
|
const CUtlVector< int > &pIndices( *ppIndices );
|
|
const CUtlVector< int > &uvIndices( *puvIndices );
|
|
|
|
while ( pnFaceSetIndex < pEnd )
|
|
{
|
|
fIndex = *pnFaceSetIndex++;
|
|
if ( fIndex < 0 )
|
|
{
|
|
b << "\n";
|
|
pFaceSep = pFaceStart;
|
|
continue;
|
|
}
|
|
|
|
b << pFaceSep << ( pIndices[ fIndex ] + m_nPositionOffset ) << '/' << ( uvIndices[ fIndex ] + m_nTextureOffset ) << '/';
|
|
pFaceSep = pFaceNext;
|
|
}
|
|
}
|
|
else if ( pCount == nCount )
|
|
{
|
|
const CUtlVector< int > &pIndices( *ppIndices );
|
|
const CUtlVector< int > &nvIndices( *pnIndices );
|
|
|
|
while ( pnFaceSetIndex < pEnd )
|
|
{
|
|
fIndex = *pnFaceSetIndex++;
|
|
if ( fIndex < 0 )
|
|
{
|
|
b << "\n";
|
|
pFaceSep = pFaceStart;
|
|
continue;
|
|
}
|
|
|
|
b << pFaceSep << ( pIndices[ fIndex ] + m_nPositionOffset ) << "//" << ( nvIndices[ fIndex ] + m_nNormalOffset );
|
|
pFaceSep = pFaceNext;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const CUtlVector< int > &pIndices( *ppIndices );
|
|
|
|
while ( pnFaceSetIndex < pEnd )
|
|
{
|
|
fIndex = *pnFaceSetIndex++;
|
|
if ( fIndex < 0 )
|
|
{
|
|
b << "\n";
|
|
pFaceSep = pFaceStart;
|
|
continue;
|
|
}
|
|
|
|
b << pFaceSep << ( pIndices[ fIndex ] + m_nPositionOffset ) << "//";
|
|
pFaceSep = pFaceNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_nPositionOffset += nPositionCount;
|
|
m_nTextureOffset += nTextureCount;
|
|
m_nNormalOffset += nNormalCount;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmObjSerializer::DagToObj(
|
|
CUtlBuffer &b,
|
|
const matrix3x4_t &parentWorldMatrix,
|
|
CDmeDag *pDag,
|
|
const char *pDeltaName,
|
|
bool absolute )
|
|
{
|
|
matrix3x4_t inclusiveMatrix;
|
|
pDag->GetTransform()->GetTransform( inclusiveMatrix );
|
|
|
|
ConcatTransforms( parentWorldMatrix, inclusiveMatrix, inclusiveMatrix );
|
|
|
|
CDmeMesh *pMesh( CastElement< CDmeMesh >( pDag->GetShape() ) );
|
|
if ( pMesh )
|
|
{
|
|
MeshToObj( b, inclusiveMatrix, pMesh, pDeltaName, absolute );
|
|
}
|
|
|
|
const int nChildren( pDag->GetChildCount() );
|
|
for ( int i( 0 ); i < nChildren; ++i )
|
|
{
|
|
DagToObj( b, inclusiveMatrix, pDag->GetChild( i ), pDeltaName, absolute );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmObjSerializer::FindDeltaMeshes( CDmeDag *pDag, CUtlVector< CDmeMesh * > &meshes )
|
|
{
|
|
CDmeMesh *pMesh( CastElement< CDmeMesh >( pDag->GetShape() ) );
|
|
if ( pMesh && pMesh->DeltaStateCount() )
|
|
{
|
|
meshes.AddToTail( pMesh );
|
|
}
|
|
|
|
const int nChildren( pDag->GetChildCount() );
|
|
for ( int i( 0 ); i < nChildren; ++i )
|
|
{
|
|
FindDeltaMeshes( pDag->GetChild( i ), meshes );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Convert from OBJ -> DME
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmObjSerializer::WriteOBJ( const char *pFilename, CDmElement *pRoot, bool bWriteOBJs, const char *pDeltaName, bool absolute )
|
|
{
|
|
CDmeDag *pModel = pRoot->GetValueElement< CDmeDag >( "model" );
|
|
|
|
if ( !pModel )
|
|
return false;
|
|
|
|
matrix3x4_t identityMatrix;
|
|
SetIdentityMatrix( identityMatrix );
|
|
|
|
if ( !pDeltaName )
|
|
{
|
|
CUtlBuffer b( 0, 0, CUtlBuffer::TEXT_BUFFER );
|
|
|
|
b << "# OBJ\n";
|
|
b << "#\n";
|
|
|
|
m_nPositionOffset = 1; // OBJs start indexing at 1
|
|
m_nTextureOffset = 1;
|
|
m_nNormalOffset = 1;
|
|
|
|
DagToObj( b, identityMatrix, pModel, pDeltaName, absolute );
|
|
|
|
g_pFullFileSystem->WriteFile( pFilename, NULL, b );
|
|
|
|
// Filesystem is silly
|
|
// On WIN32 filesystem changes all of the characters to lowercase grrrr.....
|
|
rename( pFilename, pFilename );
|
|
}
|
|
|
|
if ( !bWriteOBJs )
|
|
return true;
|
|
|
|
CUtlVector< CDmeMesh * > deltaMeshes;
|
|
FindDeltaMeshes( pModel, deltaMeshes );
|
|
|
|
if ( deltaMeshes.Count() )
|
|
{
|
|
char base[ MAX_PATH ];
|
|
Q_FileBase( pFilename, base, sizeof( base ) );
|
|
|
|
char path[ MAX_PATH ];
|
|
Q_ExtractFilePath( pFilename, path, sizeof( path ) );
|
|
|
|
char *pSuffix = strchr( base, '=' );
|
|
if ( !pSuffix )
|
|
{
|
|
pSuffix = strchr( base, '_' );
|
|
}
|
|
|
|
if ( pSuffix )
|
|
{
|
|
*( pSuffix + 0 ) = '_';
|
|
*( pSuffix + 1 ) = '\0';
|
|
}
|
|
|
|
char filename[ MAX_PATH ];
|
|
|
|
const int nDeltaMeshes( deltaMeshes.Count() );
|
|
for ( int i( 0 ); i < nDeltaMeshes; ++i )
|
|
{
|
|
CDmeMesh *pDeltaMesh( deltaMeshes[ i ] );
|
|
const int nDeltas( pDeltaMesh->DeltaStateCount() );
|
|
for ( int j( 0 ); j < nDeltas; ++j )
|
|
{
|
|
CDmeVertexDeltaData *pDelta( pDeltaMesh->GetDeltaState( j ) );
|
|
|
|
if ( !pDeltaName || !Q_strcmp( pDeltaName, pDelta->GetName() ) )
|
|
{
|
|
CUtlBuffer b( 0, 0, CUtlBuffer::TEXT_BUFFER );
|
|
|
|
b << "# Delta OBJ: " << pDelta->GetName() << "\n";
|
|
b << "#\n";
|
|
|
|
Q_strncpy( filename, pDelta->GetName(), sizeof( filename ) );
|
|
// Change _ to +
|
|
const char *const pEnd( filename + sizeof( filename ) );
|
|
for ( char *pChar = filename; *pChar && pChar < pEnd; ++pChar )
|
|
{
|
|
if ( *pChar == '_' )
|
|
{
|
|
*pChar = '+';
|
|
}
|
|
}
|
|
|
|
CUtlString deltaFile( base );
|
|
deltaFile += filename;
|
|
deltaFile += ".obj";
|
|
|
|
m_nPositionOffset = 1; // OBJs use 1 based indexes
|
|
m_nTextureOffset = 1;
|
|
m_nNormalOffset = 1;
|
|
|
|
DagToObj( b, identityMatrix, pModel, pDelta->GetName(), absolute );
|
|
|
|
Q_ComposeFileName( path, deltaFile.Get(), filename, sizeof( filename ) );
|
|
g_pFullFileSystem->WriteFile( filename, NULL, b );
|
|
// On WIN32 filesystem changes all of the characters to lowercase grrrr.....
|
|
rename( filename, filename );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmObjSerializer::ParseMtlLib( CUtlBuffer &buf )
|
|
{
|
|
char tmpBuf0[ 4096 ];
|
|
|
|
int nCurrentMtl = -1;
|
|
while ( buf.IsValid() )
|
|
{
|
|
buf.GetLine( tmpBuf0, sizeof(tmpBuf0) );
|
|
|
|
if ( StringHasPrefix( tmpBuf0, "newmtl " ) )
|
|
{
|
|
char mtlName[1024];
|
|
if ( sscanf( tmpBuf0, "newmtl %s", mtlName ) == 1 )
|
|
{
|
|
// Remove any 'SG' suffix from the material
|
|
const uint sLen = Q_strlen( mtlName );
|
|
if ( sLen > 2 && !Q_strcmp( mtlName + sLen - 2, "SG" ) )
|
|
{
|
|
mtlName[ sLen - 2 ] = '\0';
|
|
}
|
|
|
|
nCurrentMtl = m_mtlLib.AddToTail( );
|
|
m_mtlLib[nCurrentMtl].m_MtlName = mtlName;
|
|
m_mtlLib[nCurrentMtl].m_TgaName = mtlName;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( StringHasPrefix( tmpBuf0, "map_Kd " ) )
|
|
{
|
|
if ( nCurrentMtl < 0 )
|
|
continue;
|
|
|
|
char tgaPath[MAX_PATH];
|
|
char tgaName[1024];
|
|
if ( sscanf( tmpBuf0, "map_Kd %s", tgaPath ) == 1 )
|
|
{
|
|
// Try a cheesy hack - look for /materialsrc/ and set the material name off the entire path minus extension
|
|
Q_strncpy( tmpBuf0, tgaPath, sizeof( tmpBuf0 ) );
|
|
Q_FixSlashes( tmpBuf0, '/' );
|
|
const char *pMaterialSrc = Q_strstr( tmpBuf0, "/materialsrc/" );
|
|
if ( pMaterialSrc )
|
|
{
|
|
pMaterialSrc += Q_strlen( "/materialsrc/" );
|
|
Q_StripExtension( pMaterialSrc, tgaName, sizeof( tgaName) );
|
|
m_mtlLib[ nCurrentMtl ].m_TgaName = tgaName;
|
|
}
|
|
else
|
|
{
|
|
Q_FileBase( tgaPath, tgaName, sizeof(tgaName) );
|
|
m_mtlLib[nCurrentMtl].m_TgaName = tgaName;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
const char *CDmObjSerializer::FindMtlEntry( const char *pTgaName )
|
|
{
|
|
int nCount = m_mtlLib.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( !Q_stricmp( m_mtlLib[i].m_MtlName, pTgaName ) )
|
|
return m_mtlLib[i].m_TgaName;
|
|
}
|
|
return pTgaName;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmObjSerializer::ParseVertex( CUtlBuffer& bufParse, characterset_t &breakSet, int &v, int &t, int &n )
|
|
{
|
|
char cmd[1024];
|
|
int nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
|
|
if ( nLen <= 0 )
|
|
return false;
|
|
|
|
v = atoi( cmd );
|
|
n = 0;
|
|
t = 0;
|
|
|
|
char c = *(char*)bufParse.PeekGet();
|
|
bool bHasTexCoord = IN_CHARACTERSET( breakSet, c ) != 0;
|
|
bool bHasNormal = false;
|
|
if ( bHasTexCoord )
|
|
{
|
|
// Snag the '/'
|
|
nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
|
|
Assert( nLen == 1 );
|
|
|
|
c = *(char*)bufParse.PeekGet();
|
|
if ( !IN_CHARACTERSET( breakSet, c ) )
|
|
{
|
|
nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
|
|
Assert( nLen > 0 );
|
|
t = atoi( cmd );
|
|
|
|
c = *(char*)bufParse.PeekGet();
|
|
bHasNormal = IN_CHARACTERSET( breakSet, c ) != 0;
|
|
}
|
|
else
|
|
{
|
|
bHasNormal = true;
|
|
bHasTexCoord = false;
|
|
}
|
|
|
|
if ( bHasNormal )
|
|
{
|
|
// Snag the '/'
|
|
nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
|
|
Assert( nLen == 1 );
|
|
|
|
nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
|
|
Assert( nLen > 0 );
|
|
n = atoi( cmd );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
const char *CDmObjSerializer::SkipSpace(
|
|
const char *pBuf )
|
|
{
|
|
while ( *pBuf == ' ' || *pBuf == '\t' )
|
|
++pBuf;
|
|
|
|
return pBuf;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeVertexDeltaData *CDmObjSerializer::GetDelta( const char *pDeltaName, bool bAbsolute )
|
|
{
|
|
if ( !m_deltas.Defined( pDeltaName ) )
|
|
return NULL;
|
|
|
|
DeltaInfo_t &deltaInfo( m_deltas[ pDeltaName ] );
|
|
|
|
if ( deltaInfo.m_pDeltaData )
|
|
return deltaInfo.m_pDeltaData;
|
|
|
|
if ( !LoadDependentDeltas( pDeltaName ) )
|
|
return NULL;
|
|
|
|
CUtlBuffer utlBuf;
|
|
|
|
char deltaPath[ MAX_PATH ];
|
|
Q_ComposeFileName( m_objDirectory, deltaInfo.m_filename, deltaPath, sizeof( deltaPath ) );
|
|
Q_FixSlashes( deltaPath );
|
|
|
|
if ( !g_pFullFileSystem->ReadFile( deltaPath, NULL, utlBuf ) )
|
|
return NULL;
|
|
|
|
if ( deltaInfo.m_pComboOp && !strchr( pDeltaName, '_' ) )
|
|
{
|
|
deltaInfo.m_pComboOp->FindOrCreateControl( pDeltaName, false, true );
|
|
}
|
|
|
|
deltaInfo.m_pDeltaData = CastElement< CDmeVertexDeltaData >( ReadOBJ( utlBuf, deltaInfo.m_pMesh->GetFileId(), pDeltaName, deltaPath, deltaInfo.m_pMesh, NULL, bAbsolute ) );
|
|
|
|
return deltaInfo.m_pDeltaData;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmObjSerializer::LoadDependentDeltas( const char *pDeltaName )
|
|
{
|
|
// TODO: Load Dependent Deltas
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Counts the number of _'s in a string
|
|
//-----------------------------------------------------------------------------
|
|
int ComputeDimensionality( const char *pDeltaName )
|
|
{
|
|
const char *pUnderBar = pDeltaName;
|
|
int nDimensions = 0;
|
|
|
|
while ( pUnderBar )
|
|
{
|
|
++nDimensions;
|
|
pUnderBar = strchr( pUnderBar, '_' );
|
|
if ( pUnderBar )
|
|
{
|
|
++pUnderBar;
|
|
}
|
|
}
|
|
|
|
return nDimensions;
|
|
}
|
|
|
|
/*
|
|
//-----------------------------------------------------------------------------
|
|
// Generates a sorted list in order of dimensionality of the delta states
|
|
// NOTE: This assumes a naming scheme where delta state names have _ that separate control names
|
|
//-----------------------------------------------------------------------------
|
|
void CDmObjSerializer::ComputeDeltaStateComputationList( CUtlVector< CUtlVector< int > > &dependentDeltaList )
|
|
{
|
|
// Do all combinations in order of dimensionality, lowest dimension first
|
|
|
|
for ( int i = 0; i < nDeltas; ++i )
|
|
{
|
|
compList[i].m_nDeltaIndex = i;
|
|
compList[i].m_nDimensionality = ComputeDeltaStateDimensionality( i );
|
|
}
|
|
qsort( compList.Base(), nCount, sizeof(DeltaComputation_t), DeltaStateLessFunc );
|
|
}
|
|
|
|
|
|
|
|
{
|
|
CUtlVector< CUtlString > atomicControls;
|
|
deltaStateUsage.SetCount( nCount );
|
|
|
|
// Build a list of atomic controls
|
|
int nCurrentDelta;
|
|
for ( nCurrentDelta = 0; nCurrentDelta < nCount; ++nCurrentDelta )
|
|
{
|
|
if ( pInfo[nCurrentDelta].m_nDimensionality != 1 )
|
|
break;
|
|
int j = atomicControls.AddToTail( GetDeltaState( pInfo[nCurrentDelta].m_nDeltaIndex )->GetName() );
|
|
deltaStateUsage[ nCurrentDelta ].AddToTail( j );
|
|
}
|
|
|
|
for ( ; nCurrentDelta < nCount; ++nCurrentDelta )
|
|
{
|
|
CDmeVertexDeltaData *pDeltaState = GetDeltaState( pInfo[nCurrentDelta].m_nDeltaIndex );
|
|
int nLen = Q_strlen( pDeltaState->GetName() );
|
|
char *pTempBuf = (char*)_alloca( nLen + 1 );
|
|
memcpy( pTempBuf, pDeltaState->GetName(), nLen+1 );
|
|
char *pNext;
|
|
for ( char *pUnderBar = pTempBuf; pUnderBar; pUnderBar = pNext )
|
|
{
|
|
pNext = strchr( pUnderBar, '_' );
|
|
if ( pNext )
|
|
{
|
|
*pNext = 0;
|
|
++pNext;
|
|
}
|
|
|
|
// Find this name in the list of strings
|
|
int j;
|
|
int nControlCount = atomicControls.Count();
|
|
for ( j = 0; j < nControlCount; ++j )
|
|
{
|
|
if ( !Q_stricmp( pUnderBar, atomicControls[j] ) )
|
|
break;
|
|
}
|
|
if ( j == nControlCount )
|
|
{
|
|
j = atomicControls.AddToTail( pUnderBar );
|
|
}
|
|
deltaStateUsage[ nCurrentDelta ].AddToTail( j );
|
|
}
|
|
deltaStateUsage[ nCurrentDelta ].Sort( DeltaStateUsageLessFunc );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CDmObjSerializer::ComputeDependentUsage( CUtlVector< CUtlVector< int > > &deltaUsage )
|
|
{
|
|
const int nDeltas = m_deltas.GetNumStrings();
|
|
compList.EnsureCount( nDeltas );
|
|
|
|
CUtlVector< CUtlVector< int > > deltaStateUsage;
|
|
const int nCount( compList.Count() );
|
|
BuildAtomicControlLists( nCount, compList.Base(), deltaStateUsage );
|
|
|
|
// Now build up a list of dependent delta states based on usage
|
|
// NOTE: Usage is sorted in ascending order.
|
|
for ( int i = 1; i < nCount; ++i )
|
|
{
|
|
int nUsageCount1 = deltaStateUsage[i].Count();
|
|
for ( int j = 0; j < i; ++j )
|
|
{
|
|
// At the point they have the same dimensionality, no more need to check
|
|
if ( compList[j].m_nDimensionality == compList[i].m_nDimensionality )
|
|
break;
|
|
|
|
int ii = 0;
|
|
bool bSubsetFound = true;
|
|
int nUsageCount2 = deltaStateUsage[j].Count();
|
|
for ( int ji = 0; ji < nUsageCount2; ++ji )
|
|
{
|
|
for ( bSubsetFound = false; ii < nUsageCount1; ++ii )
|
|
{
|
|
if ( deltaStateUsage[j][ji] == deltaStateUsage[i][ii] )
|
|
{
|
|
++ii;
|
|
bSubsetFound = true;
|
|
break;
|
|
}
|
|
|
|
if ( deltaStateUsage[j][ji] < deltaStateUsage[i][ii] )
|
|
break;
|
|
}
|
|
|
|
if ( !bSubsetFound )
|
|
break;
|
|
}
|
|
|
|
if ( bSubsetFound )
|
|
{
|
|
compList[i].m_DependentDeltas.AddToTail( compList[j].m_nDeltaIndex );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*/ |